skilllib 1.1.0 → 1.3.0

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

@@ -29,7 +29,7 @@ function table(rows) {
 }
 
 // src/commands.ts
-import { basename as basename5, join as join11, resolve as resolve4, sep as sep4 } from "path";
+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";
@@ -112,9 +112,25 @@ function harness(id) {
   return HARNESSES.find((h) => h.id === id);
 }
 var ALL_PROJECT_DIRS = [...new Set(HARNESSES.flatMap((h) => h.projectDirs))];
-function installDirs(enabled) {
-  const needsAgents = enabled.some((id) => !harness(id).projectDirs.includes(".claude/skills"));
-  return needsAgents ? [".claude/skills", ".agents/skills"] : [".claude/skills"];
+var PREFERRED_DIRS = [AGENTS_SKILLS_DIR, PROJECT_SKILLS_DIR];
+function preference(dir) {
+  const i = PREFERRED_DIRS.indexOf(dir);
+  return i === -1 ? PREFERRED_DIRS.length : i;
+}
+function cost(dirs) {
+  return dirs.length * 100 + dirs.reduce((sum, d) => sum + preference(d), 0);
+}
+function installDirs(enabled, keep) {
+  if (enabled.length === 0) return [keep ?? PROJECT_SKILLS_DIR];
+  let best = [];
+  for (let mask = 1; mask < 1 << ALL_PROJECT_DIRS.length; mask++) {
+    const dirs = ALL_PROJECT_DIRS.filter((_, i) => mask & 1 << i).sort((a, b) => preference(a) - preference(b));
+    if (keep && !dirs.includes(keep)) continue;
+    if (!enabled.every((id) => harness(id).projectDirs.some((d) => dirs.includes(d)))) continue;
+    if (best.length === 0 || cost(dirs) < cost(best)) best = dirs;
+  }
+  const primary = keep ?? best[0];
+  return [primary, ...best.filter((d) => d !== primary)];
 }
 
 // src/config.ts
@@ -400,6 +416,9 @@ function readJson(path) {
 function skillsShLock() {
   return readJson(join7(resolve3(claudeDir(), ".."), ".agents", ".skill-lock.json"))?.skills ?? {};
 }
+function projectSkillsLock(root) {
+  return readJson(join7(root, "skills-lock.json"))?.skills ?? {};
+}
 function realpathOrNull(path) {
   try {
     return realpathSync2(path);
@@ -493,6 +512,14 @@ function claudeAiSkills() {
     }))
   );
 }
+function setPluginEnabled(id, on) {
+  const file = join7(claudeDir(), "settings.json");
+  const settings = existsSync6(file) ? readJson(file) : {};
+  if (!settings) throw new Error(`${file} isn't valid JSON, so skilllib won't rewrite it`);
+  settings.enabledPlugins = { ...settings.enabledPlugins, [id]: on };
+  mkdirSync4(claudeDir(), { recursive: true });
+  writeFileSync4(file, JSON.stringify(settings, null, 2) + "\n");
+}
 function pluginSkills() {
   const plugins = join7(claudeDir(), "plugins");
   const enabled = readJson(join7(claudeDir(), "settings.json"))?.enabledPlugins ?? {};
@@ -513,7 +540,8 @@ function pluginSkills() {
     (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;
-      return skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: `${name} (claude.ai)` }));
+      if (enabled[`${name}@synced`] === false) return [];
+      return skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: `${name}@synced` }));
     })
   ) : [];
   return [...fromMarketplaces, ...fromSynced].map(({ path, origin }) => ({
@@ -529,11 +557,11 @@ function pluginSkills() {
   }));
 }
 function machineSkills(enabled = enabledHarnesses()) {
-  const claude = enabled.includes("claude-code");
+  const claude2 = enabled.includes("claude-code");
   return [
     ...globalFolderSkills(enabled),
-    ...claude ? claudeAiSkills() : [],
-    ...claude ? pluginSkills() : [],
+    ...claude2 ? claudeAiSkills() : [],
+    ...claude2 ? pluginSkills() : [],
     ...cursorBuiltInSkills(enabled)
   ].sort(
     (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
@@ -555,7 +583,9 @@ function originFor(dir) {
   const match = machineSkills().find((s) => resolve3(s.path) === resolve3(dir));
   if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
   const project = dir.split(/[\\/]\.(?:claude|agents)[\\/]skills[\\/]/)[0];
-  return project && project !== dir ? `project: ${basename2(project)}` : dir;
+  if (!project || project === dir) return dir;
+  const locked = projectSkillsLock(project)[basename2(dir)]?.source;
+  return locked ? `skills.sh: ${locked}` : `project: ${basename2(project)}`;
 }
 
 // src/library.ts
@@ -596,11 +626,11 @@ function visibilityOf(root, name, enabled = enabledHarnesses()) {
     paths: harness(id).projectDirs.filter((dir) => existsSync7(join8(root, dir, name, "SKILL.md"))).length
   }));
 }
-function dependencyDirs(dep) {
+function dependencyDirs(root, name, dep) {
   const wanted = installDirs(enabledHarnesses());
-  if (!dep) return wanted;
-  const primary = dep.dir ?? PROJECT_SKILLS_DIR;
-  return [primary, .../* @__PURE__ */ new Set([...dep.links ?? [], ...wanted.filter((d) => d !== primary)])];
+  const untracked = ALL_PROJECT_DIRS.find((d) => existsSync7(join8(root, d, name, "SKILL.md")) && !isLink(join8(root, d, name)));
+  const primary = dep ? dep.dir ?? PROJECT_SKILLS_DIR : untracked ?? wanted[0];
+  return [primary, .../* @__PURE__ */ new Set([...dep?.links ?? [], ...wanted.filter((d) => d !== primary)])];
 }
 function isGitTracked(root, dir) {
   try {
@@ -633,6 +663,7 @@ function projectStatus(root) {
     };
   });
   const seen = new Set(Object.keys(skills));
+  const lock = projectSkillsLock(root);
   const unmanaged = [];
   const byName = /* @__PURE__ */ new Map();
   for (const dir of ALL_PROJECT_DIRS) {
@@ -649,7 +680,8 @@ function projectStatus(root) {
     const local = treeHash(real);
     const sameAsLibrary = latest !== null && (latest.hash === local || versionForHash(name, local ?? "") !== null);
     const committed = location === AGENTS_SKILLS_DIR;
-    const state = 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";
+    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,
@@ -658,7 +690,8 @@ function projectStatus(root) {
       latest: latest?.version ?? null,
       location,
       path: real,
-      visibility: visibilityOf(root, name, enabled)
+      visibility: visibilityOf(root, name, enabled),
+      ...source ? { source } : {}
     });
   }
   return [...managed, ...unmanaged].sort((a, b) => a.name.localeCompare(b.name));
@@ -716,7 +749,7 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
   if (!target) return { name, action: "skipped", reason: version === void 0 ? "not in the library" : `version ${version} doesn't exist` };
   const manifest = readManifest(root);
   const recorded = manifest.skills[name];
-  const [primary = PROJECT_SKILLS_DIR, ...linkDirs] = dependencyDirs(recorded);
+  const [primary = PROJECT_SKILLS_DIR, ...linkDirs] = dependencyDirs(root, name, recorded);
   const to = join8(root, primary, name);
   const local = isLink(to) && !recorded ? null : treeHash(to);
   const knownContent = local !== null && (local === recorded?.hash || versionForHash(name, local) !== null);
@@ -842,6 +875,10 @@ function stash(dir, bucket) {
   writeFileSync5(backupIndexFile(bucket), JSON.stringify({ ...readBackupIndex(bucket), [entry]: dir }, null, 2) + "\n");
   return target;
 }
+function removeUntracked(root, name, path) {
+  unlinkEverywhere(root, name);
+  return stash(path, "trash");
+}
 function projectsUsing(name) {
   return knownProjects().filter((p) => name in readManifest(p).skills);
 }
@@ -887,7 +924,7 @@ Instructions for Claude go here.
   return { ok: true, dir };
 }
 function listBackups() {
-  return ["trash", "global-backup"].flatMap((kind) => {
+  return ["trash", "global-backup", "tidy-backup"].flatMap((kind) => {
     const dir = join8(skilllibHome(), kind);
     if (!existsSync7(dir)) return [];
     const index = readBackupIndex(kind);
@@ -902,6 +939,7 @@ function listBackups() {
 }
 function restoreBackup(backup) {
   const to = backup.from;
+  if (backup.kind === "tidy-backup" && isLink(to)) unlinkSync(to);
   let taken = existsSync7(to);
   try {
     taken = taken || lstatSync2(to) !== null;
@@ -1020,20 +1058,395 @@ async function scanUsage(days) {
 function summarize(uses, projectOf = () => null) {
   const bySkill = /* @__PURE__ */ new Map();
   for (const use of uses) {
-    const summary = bySkill.get(use.skill) ?? { skill: use.skill, uses: 0, lastUsed: "", projects: /* @__PURE__ */ new Set() };
+    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(use.skill, summary);
+    bySkill.set(skill, summary);
   }
   return [...bySkill.values()].sort((a, b) => b.uses - a.uses);
 }
 
 // src/health.ts
-import { basename as basename4, join as join10 } from "path";
+import { basename as basename5 } from "path";
+
+// src/git.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import { join as join10, relative as relative3 } from "path";
+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;
+  }
+}
+function gitInfo(root) {
+  if (!existsSync9(join10(root, ".git"))) return null;
+  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE].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);
+    }
+    return ignoredCache.get(rel);
+  };
+  const under = (list2, rel) => list2.some((p) => p === rel || p.startsWith(rel + "/"));
+  return {
+    of: (relPath) => {
+      const rel = relPath.replace(/\/+$/, "");
+      if (under(tracked, rel)) return under(dirty, rel) ? "changed" : "committed";
+      return isIgnored(rel) ? "ignored" : "new";
+    }
+  };
+}
+function relativeTo(root, path) {
+  return relative3(root, path).split("\\").join("/");
+}
+
+// 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";
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync7(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function nonEmptyDir(path) {
+  try {
+    return readdirSync6(path).some((f) => !f.startsWith("."));
+  } catch {
+    return false;
+  }
+}
+function extrasOf(root) {
+  const manifest = readJson2(join11(root, ".claude-plugin", "plugin.json")) ?? {};
+  return [
+    ...existsSync10(join11(root, ".mcp.json")) || manifest.mcpServers ? ["MCP servers"] : [],
+    ...existsSync10(join11(root, "hooks", "hooks.json")) || manifest.hooks ? ["hooks"] : [],
+    ...nonEmptyDir(join11(root, "agents")) || manifest.agents ? ["agents"] : [],
+    ...nonEmptyDir(join11(root, "commands")) || manifest.commands ? ["commands"] : []
+  ];
+}
+function claudePlugins(machine) {
+  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];
+    return {
+      id,
+      scope: synced ? null : entry?.scope ?? "user",
+      ...entry?.projectPath ? { projectPath: entry.projectPath } : {},
+      synced,
+      skills,
+      extras: extrasOf(dirname3(dirname3(skills[0])))
+    };
+  });
+}
+function claudeBinary() {
+  const candidates = ["claude", join11(userHome(), ".local", "bin", "claude"), join11(userHome(), ".claude", "local", "claude")];
+  return candidates.find((bin) => {
+    try {
+      return execFileSync3(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 3e4, encoding: "utf-8" }).includes("Claude Code");
+    } catch {
+      return false;
+    }
+  }) ?? null;
+}
+function claude(args, cwd) {
+  const 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" });
+    return { ok: true };
+  } catch (err) {
+    const e = err;
+    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");
+  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");
+  return { ok: true };
+}
+function removedFile() {
+  return join11(skilllibHome(), "plugin-backup.json");
+}
+function removePlugin(plugin, how) {
+  if (plugin.scope && plugin.scope !== "user" && !plugin.projectPath) {
+    return { ok: false, message: `${plugin.id}: installed for one project; run \`claude plugin ${how === "delete" ? "uninstall" : "disable"} ${plugin.id} --scope ${plugin.scope}\` there` };
+  }
+  if (!plugin.synced && !claudeBinary()) {
+    return { ok: false, message: `${plugin.id}: nothing changed; Claude Code's CLI didn't run (tried \`claude\` on your PATH and ~/.local/bin/claude)` };
+  }
+  const imported = plugin.skills.filter((dir) => latestVersion(basename4(dir)) === null).map((dir) => importSkill(dir).name);
+  const scope = plugin.scope ? ["--scope", plugin.scope] : [];
+  const r = plugin.synced ? turnOffSynced(plugin.id) : claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...scope], plugin.projectPath);
+  const saved = imported.length ? `; ${imported.join(", ")} copied into Your skills` : "";
+  if (!r.ok) return { ok: false, message: `${plugin.id}: ${r.reason}${saved}` };
+  if (how === "delete" && !plugin.synced) recordRemovedPlugin(plugin.id, plugin.scope ?? "user");
+  return { ok: true, message: `${plugin.id} ${how === "delete" && !plugin.synced ? "removed" : "turned off"}${saved}` };
+}
+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");
+}
+function pluginBackups() {
+  return (readJson2(removedFile()) ?? []).map((r) => ({
+    name: r.id,
+    kind: "plugin",
+    path: r.scope,
+    movedAt: r.at.slice(0, 16).replace("T", " "),
+    from: r.id
+  }));
+}
+function restorePlugin(backup) {
+  const r = claude(["plugin", "install", backup.from, "--scope", backup.path]);
+  if (!r.ok) return r;
+  writeFileSync6(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()) : [];
+  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];
+      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";
+function entriesOf(dirs, name) {
+  return dirs.flatMap((dir) => {
+    const path = join12(dir, name);
+    if (!entryExists(path)) return [];
+    const link2 = isLink(path);
+    const real = realpathOrNull2(path);
+    const skill = existsSync11(join12(path, "SKILL.md"));
+    if (!link2 && !skill) return [];
+    return [{ dir, path, link: link2, real, hash: null }];
+  });
+}
+function hashReals(reals) {
+  if (reals.length > 1) for (const r of reals) r.hash = treeHash(r.path);
+}
+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);
+  }
+  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];
+}
+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) }))
+  };
+}
+function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {}) {
+  const report = { plans: [], conflicts: [], skipped: [] };
+  const { skills } = readManifest(root);
+  const abs = (dir) => join12(root, dir);
+  const rel = (dir) => relativeTo(root, dir);
+  const readsOf = (id) => HARNESSES.find((h) => h.id === id).projectDirs.map(abs);
+  let git2;
+  const skillsLock = projectSkillsLock(root);
+  for (const name of namesIn(ALL_PROJECT_DIRS.map(abs))) {
+    const entries = entriesOf(ALL_PROJECT_DIRS.map(abs), name);
+    const external = entries.find((e) => e.link && e.real && !(e.real + sep4).startsWith(realpathOrNull2(root) + sep4));
+    if (external) {
+      report.skipped.push({ name, reason: `${rel(external.path)} links outside the repo` });
+      continue;
+    }
+    const reals = entries.filter((e) => !e.link);
+    if (reals.length === 0) continue;
+    hashReals(reals);
+    const dep = skills[name];
+    const chosen = keep[name];
+    let primary;
+    if (dep) {
+      primary = reals.find((r) => rel(r.dir) === (dep.dir ?? PROJECT_SKILLS_DIR));
+      if (!primary) continue;
+    } else if (chosen) {
+      primary = reals.find((r) => r.dir === chosen);
+    } else {
+      if (git2 === void 0) git2 = gitInfo(root);
+      const planned = installDirs(enabled).map(abs);
+      const fromSkillsSh = name in skillsLock;
+      const rank = (e) => (git2 && ["committed", "changed"].includes(git2.of(rel(e.path))) ? 0 : 1e3) + (fromSkillsSh && e.dir === abs(AGENTS_SKILLS_DIR) ? 0 : 100) + (planned.includes(e.dir) ? planned.indexOf(e.dir) : 50);
+      primary = [...reals].sort((a, b) => rank(a) - rank(b))[0];
+    }
+    if (!primary) continue;
+    if (chosen !== primary.dir && reals.some((r) => r.hash !== primary.hash)) {
+      report.conflicts.push({ ...conflictOf(name, root, reals, enabled, readsOf), ...dep ? { managed: primary.dir } : {} });
+      continue;
+    }
+    const wanted = new Set([...installDirs(enabled, rel(primary.dir)), ...dep?.links ?? []].map(abs));
+    const steps = [];
+    for (const e of entries) {
+      if (e === primary) continue;
+      const needed = wanted.has(e.dir);
+      if (e.link) {
+        if (e.real === primary.real) {
+          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 });
+      }
+    }
+    if (steps.length) report.plans.push({ name, root, primary: primary.path, steps });
+  }
+  return report;
+}
+function globalReadsOf(id) {
+  return HARNESSES.find((h) => h.id === id).globalDirs();
+}
+function isSkillsDirPlugin(path) {
+  return existsSync11(join12(path, ".claude-plugin", "plugin.json"));
+}
+function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
+  const report = { plans: [], conflicts: [], skipped: [] };
+  const dirs = globalSkillDirs();
+  const agents = join12(userHome(), ".agents", "skills");
+  for (const name of namesIn(dirs)) {
+    const entries = entriesOf(dirs, name);
+    if (entries.some((e) => isSkillsDirPlugin(e.path))) {
+      report.skipped.push({ name, reason: "a Claude Code plugin kept in a skills folder" });
+      continue;
+    }
+    const reals = entries.filter((e) => !e.link);
+    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)) {
+      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 }));
+    report.plans.push({ name, root: null, primary: primary.path, steps });
+  }
+  return report;
+}
+function gitVisibleSteps(plan, git2 = plan.root ? gitInfo(plan.root) : null) {
+  if (!plan.root || !git2) return [];
+  return plan.steps.filter((s) => {
+    const state = git2.of(relativeTo(plan.root, s.path));
+    return state === "committed" || state === "changed";
+  });
+}
+function applyTidy(plan, { git: git2 = "keep", info: info2 } = {}) {
+  const held = git2 === "keep" ? gitVisibleSteps(plan, info2) : [];
+  const applied = [];
+  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);
+    } else stash(step.path, "tidy-backup");
+    if (step.kind === "link" || step.kind === "replace") {
+      mkdirSync7(dirname4(step.path), { recursive: true });
+      linkDir(step.target, step.path);
+    }
+    applied.push(step);
+  }
+  if (plan.root) {
+    const manifest = readManifest(plan.root);
+    const dep = manifest.skills[plan.name];
+    const added = applied.filter((s) => s.kind === "link" || s.kind === "replace").map((s) => relativeTo(plan.root, dirname4(s.path)));
+    if (dep && added.length) {
+      manifest.skills[plan.name] = { ...dep, links: [.../* @__PURE__ */ new Set([...dep.links ?? [], ...added])] };
+      writeManifest(plan.root, manifest);
+    }
+  }
+  return { name: plan.name, root: plan.root, applied, held };
+}
+function describeStep(step, root) {
+  const shown = root ? relativeTo(root, step.path) : step.path.replace(userHome(), "~");
+  switch (step.kind) {
+    case "link":
+      return `link ${shown}`;
+    case "unlink":
+      return `remove extra link ${shown}`;
+    case "replace":
+      return `${shown}: duplicate copy \u2192 link`;
+    case "remove":
+      return `remove duplicate copy ${shown}`;
+  }
+}
+function copyLabel(conflict, dir) {
+  return conflict.root ? relativeTo(conflict.root, dir) : dir.replace(userHome(), "~");
+}
+
+// src/health.ts
+function runFix(choice) {
+  try {
+    return { ok: true, message: choice.run() };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+function orThrow(r) {
+  if (!r.ok) throw new Error(r.message);
+  return r.message;
+}
+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 winners = c.managed ? c.copies.filter((x) => x.dir === c.managed) : c.copies;
+  return {
+    id: `conflict:${c.root ?? "global"}:${c.name}`,
+    severity: "problem",
+    title: `${c.name} in ${where}: the copies differ`,
+    detail: `Your agents run different versions: ${c.copies.map((x) => `${copyLabel(c, x.dir)}${x.runs.length ? ` (${agentNames(x.runs)})` : ""}`).join(" vs ")}. Keep one; the others become links to it and are restorable from Health.`,
+    choices: winners.map((x) => ({
+      label: `Keep the ${copyLabel(c, x.dir)} copy`,
+      hint: x.dir === c.managed ? "skilllib's version" : "the others become links to it",
+      run: () => {
+        const keep = { [c.name]: x.dir };
+        const plan = (c.root ? planProjectTidy(c.root, { keep }) : planGlobalTidy({ keep })).plans.find((p) => p.name === c.name);
+        if (plan) applyTidy(plan, { git: "go" });
+        return `${c.name}: kept the ${copyLabel(c, x.dir)} copy`;
+      }
+    }))
+  };
+}
+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) {
   const issues = [];
+  const statuses = new Map(projects2.map((root) => [root, statusOf(root)]));
   for (const skill of machine.filter((m) => m.broken)) {
     issues.push({
       id: `broken:${skill.name}`,
@@ -1051,36 +1464,85 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
   }
   const loaded = machine.filter((m) => !m.broken);
   const byName = /* @__PURE__ */ new Map();
-  for (const m of loaded) byName.set(m.name, [...byName.get(m.name) ?? [], m]);
+  for (const m of loaded) if (m.kind !== "plugin") byName.set(m.name, [...byName.get(m.name) ?? [], m]);
   for (const [name, copies] of byName) {
+    if (copies.every((c) => c.movable) || !copies.some((c) => c.movable)) continue;
     const harnesses = HARNESSES.filter((h) => copies.filter((c) => c.harnesses.includes(h.id)).length > 1).map((h) => h.name);
     if (harnesses.length === 0) continue;
-    const movable = copies.find((c) => c.movable);
+    const vendor = copies.filter((c) => !c.movable);
     issues.push({
       id: `dup:${name}`,
       severity: "problem",
       title: `${name}: loaded twice in ${harnesses.join(" and ")}`,
-      detail: copies.map((c) => `${c.kind} (${c.origin})`).join(" and "),
-      fix: movable && copies.some((c) => !c.movable) ? {
-        label: "Keep the vendor copy, stop loading yours globally",
-        run: () => {
-          if (!libraryNames.has(name)) importSkill(movable.path);
-          const r = unloadGlobal(movable.path, movable.links);
-          return r.ok ? `${name} now loads once` : `${name}: ${r.reason}`;
-        }
-      } : void 0
+      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)" : ""}.`
+    });
+  }
+  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}`,
+      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));
+    issues.push({
+      id: `plugin:${plugin.id}`,
+      severity: notLoaded.length === dupes.length ? "suggestion" : "problem",
+      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.` : "",
+        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." : ""
+      ].filter(Boolean).join(" "),
+      choices: plugin.synced ? [off] : plugin.extras.length ? [off, remove2] : [remove2, off]
+    });
+  }
+  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 [plugin, names] of byPlugin) {
+      issues.push({
+        id: `cursor-plugin:${plugin}`,
+        severity: "suggestion",
+        title: `${names.join(", ")}: also in the Cursor plugin ${plugin}`,
+        detail: `Cursor lists both copies when that plugin is on. Your skill wins: turn the plugin off in Cursor (Settings \u2192 Plugins).`
+      });
+    }
+  }
+  const global = planGlobalTidy();
+  if (global.plans.length) {
+    issues.push({
+      id: "tidy:global",
+      severity: "suggestion",
+      title: `${plural(global.plans.length, "global skill")} with duplicate copies`,
+      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`
+      }
     });
   }
-  const globalNames = new Set(loaded.map((m) => m.name));
+  issues.push(...global.conflicts.map(conflictIssue));
+  const kept = keptGlobal();
+  const alsoGlobal = /* @__PURE__ */ new Map();
+  const globalNames = new Set(loaded.filter((m) => m.kind !== "plugin").map((m) => m.name));
   for (const root of projects2) {
-    const where = basename4(root);
-    const status2 = statusOf(root);
+    const where = basename5(root);
+    const status2 = statuses.get(root);
     const behind = status2.filter((s) => s.state === "update available" || s.state === "folder missing");
     if (behind.length > 0) {
       issues.push({
         id: `sync:${root}`,
         severity: "problem",
-        title: `${where}: ${behind.length} skill${behind.length === 1 ? "" : "s"} out of date`,
+        title: `${where}: ${plural(behind.length, "skill")} out of date`,
         detail: behind.map((s) => s.name).join(", "),
         fix: {
           label: "Sync the project",
@@ -1091,49 +1553,123 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus)
         }
       });
     }
+    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 run = (mode) => () => {
+        const r = applyAll(tidy2.plans, mode);
+        return `${where}: tidied ${plural(r.skills, "skill")}${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`;
+      };
+      issues.push({
+        id: `tidy:${root}`,
+        severity: "suggestion",
+        title: `${where}: ${plural(tidy2.plans.length, "skill")} with extra copies or links`,
+        detail: tidy2.plans.map((p) => `${p.name}: ${p.steps.map((s) => describeStep(s, root)).join(", ")}`).join(" \xB7 ") + (visible2.length ? `. Git would see ${plural(visible2.length, "of these change")}: ${visible2.join(", ")}.` : ". Replaced copies are restorable from Health."),
+        ...visible2.length ? {
+          choices: [
+            { label: "Tidy, but keep git as it is", hint: `skips the ${plural(visible2.length, "change")} git would see`, run: run("keep") },
+            { label: "Tidy everything", hint: `${plural(visible2.length, "change")} will show in git status`, run: run("go") }
+          ]
+        } : { fix: { label: "Tidy", run: run("go") } }
+      });
+    }
+    issues.push(...tidy2.conflicts.map(conflictIssue));
+    const partial = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0));
+    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 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)` : ""}`;
+      };
+      issues.push({
+        id: `usable:${root}`,
+        severity: "suggestion",
+        title: `${where}: ${plural(partial.length, "skill")} not usable by ${agentNames(missing)}`,
+        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) },
+            { 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));
     for (const s of status2) {
+      if (isLink(s.path) || differing.has(s.name)) continue;
       if (s.state === "local only") {
         issues.push({
           id: `local:${root}:${s.name}`,
           severity: "suggestion",
           title: `${s.name}: only exists in ${where}`,
-          detail: "Import it into the library to reuse it in other projects and keep it backed up.",
-          fix: {
-            label: "Import into the library",
-            run: () => {
-              importSkill(join10(projectSkillsDir(root), s.name));
-              addSkill(root, s.name);
-              return `${s.name} imported and tracked in ${where}`;
+          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: [
+            {
+              label: "Import into the library",
+              hint: `${where} then tracks it`,
+              run: () => {
+                importSkill(s.path);
+                addSkill(root, s.name);
+                return `${s.name} imported and tracked in ${where}`;
+              }
             }
-          }
+          ]
         });
       } else if (s.state === "untracked copy of library skill") {
         issues.push({
           id: `adopt:${root}:${s.name}`,
           severity: "suggestion",
           title: `${s.name} in ${where} isn't tracked`,
-          detail: "It's identical to the library copy; track it so future library changes reach it.",
-          fix: { label: "Track it", run: () => `${addSkill(root, s.name).name} tracked in ${where}` }
+          detail: "It's identical to the library copy; track it (in skilllib.json) so future library changes reach it.",
+          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) {
-        issues.push({
-          id: `twice:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name}: in ${where} and also loaded globally`,
-          detail: "The project copy is enough; the global one loads it in every other project too.",
-          fix: machine.some((m) => m.name === s.name && m.movable) ? {
-            label: "Stop loading it globally",
+      if (globalNames.has(s.name) && s.managed) alsoGlobal.set(s.name, [...alsoGlobal.get(s.name) ?? [], root]);
+    }
+  }
+  for (const [name, roots] of alsoGlobal) {
+    const wheres = roots.map((r) => basename5(r)).join(", ");
+    if (kept.has(name)) {
+      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: [
+          {
+            label: `Remove the copies in ${wheres}`,
+            hint: "the global copy stays",
             run: () => {
-              const g = machine.find((m) => m.name === s.name && m.movable);
-              if (!libraryNames.has(s.name)) importSkill(g.path);
-              const r = unloadGlobal(g.path, g.links);
-              return r.ok ? `${s.name} no longer loads globally` : `${s.name}: ${r.reason}`;
+              const removed = roots.filter((root) => removeSkill(root, name).action === "removed").map((r) => basename5(r));
+              return `${name}: removed from ${removed.join(", ") || "no project"}; the global copy stays`;
             }
-          } : void 0
-        });
-      }
+          }
+        ]
+      });
+      continue;
     }
+    const movable = machine.find((m) => m.name === name && m.movable);
+    issues.push({
+      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).",
+      choices: movable ? [
+        {
+          label: "Stop loading it globally",
+          hint: "restorable from Health",
+          run: () => {
+            if (!libraryNames.has(name)) importSkill(movable.path);
+            const r = unloadGlobal(movable.path, movable.links);
+            if (!r.ok) throw new Error(`${name}: ${r.reason}`);
+            return `${name} no longer loads globally`;
+          }
+        }
+      ] : void 0
+    });
   }
   return issues;
 }
@@ -1143,20 +1679,24 @@ var USAGE_DAYS = 30;
 function parseArgs(argv) {
   const daysIdx = argv.indexOf("--days");
   const days = daysIdx >= 0 ? Number(argv[daysIdx + 1]) : USAGE_DAYS;
+  const keepIdx = argv.indexOf("--keep");
   return {
-    positional: argv.filter((a, i) => !a.startsWith("--") && argv[i - 1] !== "--days"),
+    positional: argv.filter((a, i) => !a.startsWith("--") && argv[i - 1] !== "--days" && argv[i - 1] !== "--keep"),
     force: argv.includes("--force"),
     all: argv.includes("--all"),
     global: argv.includes("--global"),
     fix: argv.includes("--fix"),
     allowTracked: argv.includes("--allow-tracked"),
-    days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS
+    days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS,
+    dryRun: argv.includes("--dry-run"),
+    allowGit: argv.includes("--allow-git"),
+    ...keepIdx >= 0 && argv[keepIdx + 1] ? { keep: argv[keepIdx + 1] } : {}
   };
 }
 function colorState(state) {
   if (state === "ok") return green(state);
   if (state === "folder missing" || state === "not in library") return red(state);
-  if (state === "local only") return dim(state);
+  if (state === "local only" || state === "from npx skills") return dim(state);
   return yellow(state);
 }
 function printChanges(changes) {
@@ -1176,9 +1716,9 @@ function projectOfFactory(projects2) {
   const sorted = [...projects2].sort((a, b) => b.length - a.length);
   return (cwd) => {
     if (!cwd) return null;
-    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep4));
+    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep5));
     if (known) return known;
-    const repo = cwd.split(`${sep4}.claude${sep4}worktrees${sep4}`)[0];
+    const repo = cwd.split(`${sep5}.claude${sep5}worktrees${sep5}`)[0];
     return isProjectCandidate(repo) ? repo : null;
   };
 }
@@ -1194,7 +1734,7 @@ function lastUsed(summary) {
 async function status(args) {
   const root = findProjectRoot();
   const skills = projectStatus(root);
-  info(`${basename5(root)} ${dim(tildify(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>");
@@ -1204,7 +1744,7 @@ async function status(args) {
   table(
     skills.map((s) => ({
       Skill: s.name,
-      Status: colorState(s.state),
+      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))
     }))
@@ -1230,7 +1770,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) ?? [], basename5(project)]);
+        installs.set(name, [...installs.get(name) ?? [], basename6(project)]);
       }
     }
     const usage2 = await usageBySkill(args.days);
@@ -1272,7 +1812,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: basename5(root),
+        Project: basename6(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),
@@ -1304,7 +1844,7 @@ function sync(args) {
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const changes = syncProject(root, { force: args.force });
-    if (args.all) info(`${basename5(root)} ${dim(tildify(root))}`);
+    if (args.all) info(`${basename6(root)} ${dim(tildify(root))}`);
     if (changes.length === 0) success("Installed versions match skilllib.json");
     else printChanges(changes);
   }
@@ -1315,7 +1855,7 @@ function update(args) {
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const changes = updateProject(root, args.positional.length ? args.positional : void 0, { force: args.force });
-    if (args.all) info(`${basename5(root)} ${dim(tildify(root))}`);
+    if (args.all) info(`${basename6(root)} ${dim(tildify(root))}`);
     if (changes.length === 0) success("Everything is on the latest version");
     else printChanges(changes);
   }
@@ -1323,7 +1863,7 @@ function update(args) {
 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: basename5(root), Skill: s.name, Installed: `v${s.version}`, Latest: `v${s.latest}`, Status: colorState(s.state) }))
+    (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) }))
   );
   if (rows.length === 0) return success("Everything is on the latest version");
   table(rows);
@@ -1349,10 +1889,10 @@ 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 === join11(root, ".claude", "skills") && isProjectCandidate(root)) {
+    if (skillsDir === join13(root, ".claude", "skills") && isProjectCandidate(root)) {
       if (readManifest(root).skills[name]?.hash !== treeHash(dir)) {
         const change = addSkill(root, name);
-        if (change.action !== "skipped") info(dim(`  ${basename5(root)} now depends on ${name} v${change.to}`));
+        if (change.action !== "skipped") info(dim(`  ${basename6(root)} now depends on ${name} v${change.to}`));
       }
       rememberProjects([root]);
     }
@@ -1367,13 +1907,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) => basename5(d));
+  const skillNames = (root) => [...skillDirsIn(projectSkillsDir(root)), ...skillDirsIn(agentsSkillsDir(root))].map((d) => basename6(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: basename5(root),
+      Project: basename6(root),
       Path: dim(tildify(root)),
       Skills: [...new Set(skillNames(root))].map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
@@ -1414,14 +1954,14 @@ function newSkill(args) {
     error(`Can't create ${name}: ${r.reason}`);
     process.exit(1);
   }
-  success(`Created ${tildify(join11(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join13(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
-  const backups = listBackups();
+  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)" : "~/.claude/skills", Moved: b.movedAt })));
+    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 })));
     info(dim("\n\u2192 skilllib restore <name>"));
     return;
   }
@@ -1430,7 +1970,7 @@ function restore(args) {
     error(`No backup named ${name}`);
     process.exit(1);
   }
-  const r = restoreBackup(backup);
+  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}`);
 }
@@ -1441,9 +1981,13 @@ function doctor(args) {
   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 (args.fix && issue.fix) info(`  ${green("\u2713")} ${issue.fix.run()}`);
+    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);
+      info(`  ${r.ok ? green("\u2713") : red("\u2717")} ${r.message}`);
+    }
   }
-  if (!args.fix && issues.some((i) => i.fix)) info(dim("\nRun `skilllib doctor --fix` to apply the fixes, or fix them one by one in `skilllib` \u2192 5 Health."));
+  if (!args.fix && issues.some((i) => i.fix)) info(dim("\nRun `skilllib doctor --fix` to apply the fixes, or fix them one by one in `skilllib` \u2192 Health."));
 }
 async function usage(args) {
   const summaries = summarize(await scanUsage(args.days), projectOfFactory(knownProjects()));
@@ -1452,13 +1996,13 @@ async function usage(args) {
     return;
   }
   const library = new Set(librarySkills().map((s) => s.name));
-  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join11(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join13(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
       Skill: s.skill,
       Uses: String(s.uses),
-      Projects: [...s.projects].map((p) => basename5(p)).join(", ") || dim("-"),
+      Projects: [...s.projects].map((p) => basename6(p)).join(", ") || dim("-"),
       "Last used": lastUsed(s),
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
@@ -1471,7 +2015,7 @@ async function usage(args) {
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join11(libraryDir(), name) : "";
+  const dir = name ? join13(libraryDir(), name) : "";
   if (!name || !isSkillDir(dir)) {
     error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
     process.exit(1);
@@ -1507,7 +2051,7 @@ function link(args) {
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const res = linkAll(root);
-    const label = args.all ? `${basename5(root)}: ` : "";
+    const label = args.all ? `${basename6(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`);
@@ -1535,14 +2079,45 @@ function globalCommand(args) {
   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) }) }));
+  let held = 0;
+  let changed = 0;
+  for (const { label, report } of reports) {
+    const plans = report.plans.filter((p) => !names.length || names.includes(p.name));
+    const conflicts = report.conflicts.filter((c) => !names.length || names.includes(c.name));
+    if (!plans.length && !conflicts.length && !args.all) success(`${label}: every skill has one copy and the links your agents need`);
+    for (const plan of plans) {
+      const result = args.dryRun ? { applied: [], held: gitVisibleSteps(plan) } : applyTidy(plan, { git: args.allowGit ? "go" : "keep" });
+      const show2 = args.dryRun ? plan.steps : result.applied;
+      if (show2.length) info(`${args.dryRun ? dim("would") : green("\u2713")} ${label} \xB7 ${plan.name}: ${show2.map((s) => describeStep(s, plan.root)).join(", ")}`);
+      if (!args.dryRun) for (const step of result.held) info(`${yellow("!")} ${label} \xB7 ${plan.name}: held back, git would see it: ${describeStep(step, plan.root)}`);
+      held += args.dryRun ? 0 : result.held.length;
+      changed += result.applied.length;
+    }
+    for (const c of conflicts) {
+      warn(`${label} \xB7 ${c.name}: the copies differ`);
+      for (const copy of c.copies) {
+        const runs = copy.runs.map((id) => HARNESSES.find((h) => h.id === id).name);
+        info(`    ${copyLabel(c, copy.dir)}${runs.length ? dim(`  run by ${runs.join(", ")}`) : ""}${c.managed === copy.dir ? dim("  (skilllib's copy)") : ""}`);
+      }
+      const pick = copyLabel(c, c.managed ?? c.copies[0].dir);
+      info(dim(`    keep one: skilllib tidy ${c.name}${args.global ? " --global" : ""} --keep ${pick}`));
+    }
+    for (const s of report.skipped.filter((x) => !names.length || names.includes(x.name))) info(dim(`- ${label} \xB7 ${s.name}: skipped, ${s.reason}`));
+  }
+  if (args.dryRun) info(dim("\nNothing changed (--dry-run)."));
+  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.`));
+}
 
 export {
   userHome,
   skilllibHome,
-  MANIFEST_FILE,
   HARNESSES,
-  ALL_PROJECT_DIRS,
-  installDirs,
+  harness,
   readSkillInfo,
   versionHistory,
   forgetLatest,
@@ -1561,21 +2136,22 @@ export {
   allowTrackedLinks,
   keptGlobal,
   setKeepGlobal,
+  setPluginEnabled,
   machineSkills,
   libraryOrigins,
+  recordOrigin,
   librarySkills,
   librarySkillDir,
-  visibilityOf,
   projectStatus,
   linkEverywhere,
-  unlinkEverywhere,
   relinkDependency,
-  linkAll,
   addSkill,
   removeSkill,
   syncProject,
   updateProject,
   importSkill,
+  removeUntracked,
+  projectsUsing,
   deleteLibrarySkill,
   deleteGlobal,
   unloadGlobal,
@@ -1584,8 +2160,12 @@ export {
   restoreBackup,
   error,
   scanUsage,
-  summarize,
-  findIssues,
+  gitInfo,
+  relativeTo,
+  claudeBinary,
+  recordRemovedPlugin,
+  pluginBackups,
+  restorePlugin,
   parseArgs,
   projectOfFactory,
   status,
@@ -1607,5 +2187,6 @@ export {
   show,
   harnessesCommand,
   link,
-  globalCommand
+  globalCommand,
+  tidy
 };