skilllib 1.11.2 → 1.11.4

package/dist/{chunk-OFWHWIER.js → chunk-CS6T66EE.js}

@@ -2,9 +2,9 @@
 import { resolve as resolve2, sep } from "path";
 
 // src/paths.ts
-import { realpathSync } from "fs";
+import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { dirname, join, resolve } from "path";
 function userHome() {
   return process.env.HOME || homedir();
 }
@@ -16,13 +16,13 @@ function realPath(path) {
   }
 }
 function skilllibHome() {
-  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
+  return process.env.SKILLLIB_HOME?.trim() || join(userHome(), ".skilllib");
 }
 function libraryDir() {
   return join(skilllibHome(), "library");
 }
 function claudeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR?.trim() || join(userHome(), ".claude");
 }
 function grokDir() {
   return process.env.GROK_HOME?.trim() || join(userHome(), ".grok");
@@ -41,6 +41,47 @@ function isRepoSkillLocation(location) {
   return location === AGENTS_SKILLS_DIR || location === GROK_SKILLS_DIR;
 }
 var OWN_SKILL_MARKER = ".managed-by-skilllib";
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function realpathOrNull(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+}
+function readState(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${path} isn't valid JSON: fix it, or move it away to start that file over`);
+  }
+}
+function writeState(path, data) {
+  const target = realpathOrNull(path) ?? path;
+  mkdirSync(dirname(target), { recursive: true });
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(data, null, 2) + "\n", { mode: statSync(target, { throwIfNoEntry: false })?.mode ?? 420 });
+    renameSync(temp, target);
+  } catch (err) {
+    rmSync(temp, { force: true });
+    throw err;
+  }
+}
+var BUILD_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage"]);
 
 // src/output.ts
 var jsonMode = false;
@@ -63,30 +104,29 @@ var warn = (msg) => out(`${yellow("!")} ${msg}`);
 var error = (msg) => console.error(`${red("\u2717")} ${msg}`);
 function tildify(path) {
   for (const home2 of /* @__PURE__ */ new Set([resolve2(userHome()), realPath(userHome())]))
-    if (path === home2 || path.startsWith(home2 + sep)) return ("~" + path.slice(home2.length)).replace(/\\/g, "/");
-  return path;
+    if (path === home2 || path.startsWith(home2 + sep)) path = "~" + path.slice(home2.length);
+  return path.replace(/\\/g, "/");
 }
 function truncate(s, max) {
   const line = s.replace(/\s+/g, " ");
   return line.length > max ? line.slice(0, max - 1) + "\u2026" : line;
 }
 var visible = (s) => s.replace(/\x1b\[\d+m/g, "");
-function table(rows) {
-  if (rows.length === 0) return;
-  const keys = Object.keys(rows[0]);
-  const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => visible(r[k] ?? "").length)));
+function table(rows2) {
+  if (rows2.length === 0) return;
+  const keys = Object.keys(rows2[0]);
+  const widths = keys.map((k) => Math.max(k.length, ...rows2.map((r) => visible(r[k] ?? "").length)));
   const pad = (s, w) => s + " ".repeat(Math.max(0, w - visible(s).length));
   info(dim(keys.map((k, i) => pad(k, widths[i])).join("  ")));
-  for (const row of rows) info(keys.map((k, i) => pad(row[k] ?? "", widths[i])).join("  ").trimEnd());
+  for (const row of rows2) info(keys.map((k, i) => pad(row[k] ?? "", widths[i])).join("  ").trimEnd());
+}
+function localStamp(ms) {
+  const at = new Date(ms);
+  return new Date(ms - at.getTimezoneOffset() * 6e4).toISOString().slice(0, 16).replace("T", " ");
 }
-
-// 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/config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
@@ -185,16 +225,16 @@ function installDirs(enabled, keep) {
 }
 
 // src/project.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join5, resolve as resolve3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve3 } from "path";
 
 // src/versions.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join4 } from "path";
 
 // src/skills.ts
 import { createHash } from "crypto";
-import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync as realpathSync2, rmSync, statSync } from "fs";
+import { cpSync, existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, realpathSync as realpathSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
 import { basename, join as join3, relative, sep as sep2 } from "path";
 import { parse as parseYaml } from "yaml";
 var IGNORED = /* @__PURE__ */ new Set([".DS_Store", ".git", "node_modules"]);
@@ -202,7 +242,7 @@ function readSkillInfo(dir) {
   const skillMd = join3(dir, "SKILL.md");
   const fallback = { name: basename(dir), description: "" };
   if (!existsSync2(skillMd)) return fallback;
-  const match = readFileSync(skillMd, "utf-8").match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const match = readFileSync2(skillMd, "utf-8").replace(/^\uFEFF/, "").match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return fallback;
   try {
     const fm = parseYaml(match[1]);
@@ -211,35 +251,47 @@ function readSkillInfo(dir) {
       description: typeof fm?.description === "string" ? fm.description.trim() : ""
     };
   } catch {
-    return fallback;
+    const line = (key) => match[1].match(new RegExp(`^${key}:[ 	]*(.*)$`, "m"))?.[1]?.trim().replace(/^(["'])(.*)\1$/, "$2") ?? "";
+    return { name: line("name") || fallback.name, description: line("description") };
   }
 }
 function isSkillDir(dir) {
   return existsSync2(join3(dir, "SKILL.md"));
 }
-function listFiles(dir) {
+function listFiles(dir, seen = /* @__PURE__ */ new Set()) {
+  const real = realpathSync2(dir);
+  if (seen.has(real)) return [];
+  seen.add(real);
   return readdirSync(dir).filter((entry) => !IGNORED.has(entry)).flatMap((entry) => {
     const full = join3(dir, entry);
-    const st = statSync(full, { throwIfNoEntry: false });
-    return !st ? [] : st.isDirectory() ? listFiles(full) : [full];
+    const st = statSync2(full, { throwIfNoEntry: false });
+    return !st ? [] : st.isDirectory() ? listFiles(full, seen) : [full];
   });
 }
 function treeHash(dir) {
-  if (!existsSync2(dir)) return null;
+  if (!isDir(dir)) return null;
   const hash = createHash("sha256");
-  const files = listFiles(dir).map((f) => ({ path: relative(dir, f).split(sep2).join("/"), full: f })).sort((a, b) => a.path.localeCompare(b.path));
+  const files = listFiles(dir).map((f) => ({ path: relative(dir, f).split(sep2).join("/"), full: f })).sort((a, b) => a.path.localeCompare(b.path, "en"));
   for (const file of files) {
-    hash.update(file.path).update("\0").update(createHash("sha256").update(readFileSync(file.full)).digest("hex")).update("\n");
+    hash.update(file.path).update("\0").update(createHash("sha256").update(readFileSync2(file.full)).digest("hex")).update("\n");
   }
   return hash.digest("hex").slice(0, 16);
 }
 function copySkill(from, to) {
   const source = realpathSync2(from);
-  rmSync(to, { recursive: true, force: true });
-  cpSync(source, to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) && existsSync2(src) });
+  rmSync2(to, { recursive: true, force: true });
+  const loops = (src) => src !== source && ((r) => r === source || source.startsWith(r + sep2))(realpathSync2(src));
+  cpSync(source, to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) && existsSync2(src) && !loops(src) });
+}
+function isDir(path) {
+  try {
+    return statSync2(path, { throwIfNoEntry: false })?.isDirectory() === true;
+  } catch {
+    return false;
+  }
 }
 function skillDirsIn(dir) {
-  if (!existsSync2(dir)) return [];
+  if (!isDir(dir)) return [];
   return readdirSync(dir, { withFileTypes: true }).filter((d) => (d.isDirectory() || d.isSymbolicLink()) && isSkillDir(join3(dir, d.name))).map((d) => join3(dir, d.name)).sort();
 }
 
@@ -251,11 +303,7 @@ function indexFile(name) {
   return join4(storeDir(name), "versions.json");
 }
 function versionHistory(name) {
-  try {
-    return JSON.parse(readFileSync2(indexFile(name), "utf-8"));
-  } catch {
-    return [];
-  }
+  return readState(indexFile(name)) ?? [];
 }
 function versionDir(name, version) {
   return join4(storeDir(name), String(version));
@@ -277,9 +325,10 @@ function latestVersion(name) {
       result = last;
     } else {
       const next = { version: (last?.version ?? 0) + 1, hash, date: (/* @__PURE__ */ new Date()).toISOString() };
-      mkdirSync(storeDir(name), { recursive: true });
+      if (existsSync3(versionDir(name, next.version))) throw new Error(`${versionDir(name, next.version)} exists but ${indexFile(name)} doesn't list it: fix the index before adding versions`);
+      mkdirSync2(storeDir(name), { recursive: true });
       copySkill(source, versionDir(name, next.version));
-      writeFileSync(indexFile(name), JSON.stringify([...history, next], null, 2) + "\n");
+      writeState(indexFile(name), [...history, next]);
       result = next;
     }
   }
@@ -298,7 +347,7 @@ function findProjectRoot(from = process.cwd()) {
   let dir = resolve3(from);
   while (true) {
     if (existsSync4(join5(dir, MANIFEST_FILE)) || existsSync4(join5(dir, ".git"))) return dir;
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir) return resolve3(from);
     dir = parent;
   }
@@ -310,13 +359,23 @@ function projectHere(from = process.cwd()) {
 function readManifest(root) {
   const path = join5(root, MANIFEST_FILE);
   if (!existsSync4(path)) return { skills: {} };
-  const data = JSON.parse(readFileSync3(path, "utf-8"));
+  let data;
+  try {
+    data = JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    throw new Error(`${path} isn't valid JSON (a merge conflict?): fix it, then run skilllib again`);
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data) || data.skills !== void 0 && (typeof data.skills !== "object" || data.skills === null || Array.isArray(data.skills)))
+    throw new Error(`${path} isn't a skilllib.json (it should hold an object with "skills": { name: pin })`);
   const skills = Object.fromEntries(
     Object.entries(data.skills ?? {}).flatMap(([name, value]) => {
-      if (name.startsWith("@")) return [];
+      if (name.startsWith("@") || !name || name === "." || name === ".." || /[\\/]/.test(name)) return [];
       if (typeof value === "string") return [[name, { version: versionForHash(name, value)?.version ?? 0, hash: value }]];
       if (value && typeof value === "object" && "hash" in value) {
         const dep = value;
+        const folders2 = [...typeof dep.dir === "string" ? [dep.dir] : [], ...Array.isArray(dep.links) ? dep.links.map(String) : []];
+        const bad = folders2.find((d) => !ALL_PROJECT_DIRS.includes(d));
+        if (bad !== void 0) throw new Error(`${path} isn't a valid skilllib.json: ${name}'s folder "${bad}" isn't a skill folder (${ALL_PROJECT_DIRS.join(", ")})`);
         return [
           [
             name,
@@ -329,14 +388,14 @@ function readManifest(root) {
           ]
         ];
       }
-      return [];
+      throw new Error(`${path} isn't a valid skilllib.json: ${name}'s pin has no hash`);
     })
   );
   return { ...data, skills };
 }
 function writeManifest(root, manifest) {
-  const skills = Object.fromEntries(Object.entries(manifest.skills).sort(([a], [b]) => a.localeCompare(b)));
-  writeFileSync2(join5(root, MANIFEST_FILE), JSON.stringify({ ...manifest, skills }, null, 2) + "\n");
+  const skills = Object.fromEntries(Object.entries(manifest.skills).sort(([a], [b]) => a.localeCompare(b, "en")));
+  writeState(join5(root, MANIFEST_FILE), { ...manifest, skills });
 }
 function projectsFile() {
   return join5(skilllibHome(), "projects.json");
@@ -344,7 +403,7 @@ function projectsFile() {
 function knownProjects() {
   const path = projectsFile();
   if (!existsSync4(path)) return [];
-  const list2 = JSON.parse(readFileSync3(path, "utf-8"));
+  const list2 = readState(path) ?? [];
   return onePerFolder(list2.filter((p) => existsSync4(p) && isProjectCandidate(p) && !isAgentWorktree(p)));
 }
 function isAgentWorktree(path) {
@@ -360,13 +419,34 @@ function onePerFolder(paths) {
   return [...new Set(byReal.values())];
 }
 function isProjectCandidate(root) {
-  return realPath(root) !== realPath(userHome());
+  const real = realPath(root);
+  const own = [userHome(), skilllibHome(), claudeDir(), codexHome(), grokDir(), join5(userHome(), ".agents"), join5(userHome(), ".cursor")];
+  return !own.some((d) => realPath(d) === real);
 }
 function rememberProjects(roots) {
   const incoming = roots.map((r) => resolve3(r)).filter((r) => isProjectCandidate(r) && !isAgentWorktree(r));
   const all = onePerFolder([...knownProjects(), ...incoming]).sort();
-  mkdirSync2(skilllibHome(), { recursive: true });
-  writeFileSync2(projectsFile(), JSON.stringify(all, null, 2) + "\n");
+  writeState(projectsFile(), all);
+}
+function readableRoots(roots) {
+  const unreadable = [];
+  const readable = roots.filter((root) => {
+    try {
+      readManifest(root);
+      return true;
+    } catch (err) {
+      unreadable.push({ root, reason: err.message });
+      return false;
+    }
+  });
+  return { readable, unreadable };
+}
+function pinsIn(root) {
+  try {
+    return readManifest(root).skills;
+  } catch {
+    return {};
+  }
 }
 
 // src/config.ts
@@ -374,24 +454,19 @@ function configFile() {
   return join6(skilllibHome(), "config.json");
 }
 function readConfig() {
-  try {
-    const data = JSON.parse(readFileSync4(configFile(), "utf-8"));
-    return { ...data, roots: data.roots ?? [], hidden: data.hidden ?? [] };
-  } catch {
-    return { roots: [], hidden: [] };
-  }
+  const data = readState(configFile()) ?? {};
+  return { ...data, roots: data.roots ?? [], hidden: data.hidden ?? [] };
 }
 function writeConfig(config) {
-  mkdirSync3(skilllibHome(), { recursive: true });
-  writeFileSync3(configFile(), JSON.stringify(config, null, 2) + "\n");
+  writeState(configFile(), config);
 }
 function expandHome(path) {
-  return resolve4(path.replace(/^~(?=$|\/)/, homedir2()));
+  return resolve4(path.replace(/^~(?=$|[\\/])/, userHome()));
 }
 function addRoot(path) {
   const root = expandHome(path);
   if (!existsSync5(root)) throw new Error(`${tildify(root)} doesn't exist`);
-  if (!statSync2(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
+  if (!statSync3(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
   const config = readConfig();
   if (!config.roots.includes(root)) writeConfig({ ...config, roots: [...config.roots, root].sort() });
   return root;
@@ -410,7 +485,7 @@ function setHidden(project, hidden) {
   writeConfig({ ...config, hidden: hidden ? [...rest, project].sort() : rest });
   return true;
 }
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "vendor", "target", "Library", "Applications", "Pictures", "Music", "Movies"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([...BUILD_DIRS, "Library", "Applications", "Pictures", "Music", "Movies"]);
 function findProjects(dir, depth = 4) {
   if (depth < 0 || !existsSync5(dir)) return [];
   if (isProjectCandidate(dir)) {
@@ -462,37 +537,31 @@ function setKeepGlobal(names, keep) {
   writeConfig({ ...readConfig(), keepGlobal: [...kept].sort() });
 }
 
+// src/agentSkill.ts
+import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+
 // src/library.ts
 import { execFileSync } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync4, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
-import { basename as basename3, dirname as dirname2, join as join8, relative as relative2, sep as sep3 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, readlinkSync as readlinkSync2, renameSync as renameSync2, rmSync as rmSync3, symlinkSync, unlinkSync, writeFileSync as writeFileSync2, realpathSync as realpathSync3 } from "fs";
+import { basename as basename3, dirname as dirname3, isAbsolute, join as join8, posix, relative as relative2, resolve as resolve6, sep as sep4 } from "path";
 
 // src/sources.ts
-import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync3, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2, join as join7, resolve as resolve5 } from "path";
-function readJson(path) {
-  try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readlinkSync } from "fs";
+import { basename as basename2, join as join7, resolve as resolve5, sep as sep3 } from "path";
+import { tmpdir } from "os";
 function skillsShLock() {
   return readJson(join7(userHome(), ".agents", ".skill-lock.json"))?.skills ?? {};
 }
 function projectSkillsLock(root) {
   return readJson(join7(root, "skills-lock.json"))?.skills ?? {};
 }
-function realpathOrNull(path) {
-  try {
-    return realpathSync3(path);
-  } catch {
-    return null;
-  }
+function vendorSkill(path, kind, origin, harnesses) {
+  return { name: basename2(path), kind, origin, path, description: readSkillInfo(path).description, movable: false, broken: false, harnesses, links: [] };
 }
 function harnessesReading(dir, enabled) {
   const real = realPath(dir);
-  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().some((d) => realPath(d) === real));
+  return enabled.filter((id) => harness(id).globalDirs().some((d) => realPath(d) === real));
 }
 var systemDirs = () => [codexSystemDir()];
 function globalSkillDirs() {
@@ -511,24 +580,14 @@ function globalDirAs(dir) {
 }
 function systemSkills(enabled) {
   return systemDirs().flatMap(
-    (dir) => skillDirsIn(dir).map((path) => ({
-      name: basename2(path),
-      kind: "system",
-      origin: dir.replace(/\\/g, "/"),
-      path,
-      description: readSkillInfo(path).description,
-      movable: false,
-      broken: false,
-      harnesses: harnessesReading(dir, enabled),
-      links: []
-    }))
+    (dir) => skillDirsIn(dir).map((path) => vendorSkill(path, "system", dir.replace(/\\/g, "/"), harnessesReading(dir, enabled)))
   ).filter((s) => s.harnesses.length > 0);
 }
 function globalFolderSkills(enabled) {
   const lock = skillsShLock();
   const agentsDir = join7(userHome(), ".agents", "skills");
   const entries = globalSkillDirs().flatMap((dir) => {
-    if (!existsSync6(dir)) return [];
+    if (!isDir(dir)) return [];
     return readdirSync3(dir).filter((name) => !name.startsWith(".") && name !== "synced").flatMap((name) => {
       const path = join7(dir, name);
       const isLink2 = lstatSync(path).isSymbolicLink();
@@ -550,13 +609,13 @@ function globalFolderSkills(enabled) {
     const inAgents = e.dir === agentsDir || target_.includes(".agents/skills");
     const locked = lock[e.name]?.source;
     if (existsSync6(join7(e.path, OWN_SKILL_MARKER))) {
-      skills.push({ name: e.name, kind: "skilllib", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
+      skills.push(vendorSkill(e.path, "skilllib", "skilllib", harnessesReading(e.dir, enabled)));
       continue;
     }
     skills.push({
       name: e.name,
       kind: locked || e.isLink && inAgents ? "skills.sh" : "global",
-      origin: locked ?? (e.isLink && inAgents ? "skills.sh (not in its lock file)" : e.isLink ? `link \u2192 ${target_}` : `${tildify2(e.dir)} (origin unknown)`),
+      origin: locked ?? (e.isLink && inAgents ? "skills.sh (not in its lock file)" : e.isLink ? `link \u2192 ${target_}` : `${tildify(e.dir)} (origin unknown)`),
       path: e.path,
       description: e.broken ? "" : readSkillInfo(e.path).description,
       movable: true,
@@ -573,36 +632,17 @@ function globalFolderSkills(enabled) {
   }
   return skills;
 }
-function tildify2(p) {
-  return tildify(p).replace(/\\/g, "/");
-}
 function grokBuiltInSkills(enabled) {
   if (!enabled.includes("grok")) return [];
-  return skillDirsIn(join7(grokDir(), "bundled", "skills")).map((path) => ({
-    name: basename2(path),
-    kind: "built-in",
-    origin: "Grok",
-    path,
-    description: readSkillInfo(path).description,
-    movable: false,
-    broken: false,
-    harnesses: ["grok"],
-    links: []
-  }));
+  return skillDirsIn(join7(grokDir(), "bundled", "skills")).map((path) => vendorSkill(path, "built-in", "Grok", ["grok"]));
+}
+function codexBuiltInSkills(enabled) {
+  if (!enabled.includes("codex")) return [];
+  return skillDirsIn(join7(codexHome(), "skills", ".system")).map((path) => vendorSkill(path, "built-in", "Codex", ["codex"]));
 }
 function cursorBuiltInSkills(enabled) {
   if (!enabled.includes("cursor")) return [];
-  return skillDirsIn(join7(userHome(), ".cursor", "skills-cursor")).map((path) => ({
-    name: basename2(path),
-    kind: "built-in",
-    origin: "Cursor",
-    path,
-    description: readSkillInfo(path).description,
-    movable: false,
-    broken: false,
-    harnesses: ["cursor"],
-    links: []
-  }));
+  return skillDirsIn(join7(userHome(), ".cursor", "skills-cursor")).map((path) => vendorSkill(path, "built-in", "Cursor", ["cursor"]));
 }
 function claudeAiSkills(enabled) {
   const byReal = /* @__PURE__ */ new Map();
@@ -616,23 +656,18 @@ function claudeAiSkills(enabled) {
     byReal.set(real, entry);
   }
   return [...byReal.values()].flatMap(
-    ({ dir, readers }) => readdirSync3(dir).filter((d) => !d.startsWith(".")).flatMap(
-      (bucket) => skillDirsIn(join7(dir, bucket)).map((path) => ({
-        name: basename2(path),
-        kind: "claude.ai",
-        origin: "claude.ai account",
-        path,
-        description: readSkillInfo(path).description,
-        movable: false,
-        broken: false,
-        harnesses: enabled.filter((id) => readers.includes(id)),
-        links: []
-      }))
+    ({ dir, readers }) => (isDir(dir) ? readdirSync3(dir) : []).filter((d) => !d.startsWith(".")).flatMap(
+      (bucket) => skillDirsIn(join7(dir, bucket)).map((path) => vendorSkill(path, "claude.ai", "claude.ai account", enabled.filter((id) => readers.includes(id))))
     )
   );
 }
+function installedPluginsJson() {
+  return readJson(join7(claudeDir(), "plugins", "installed_plugins.json"))?.plugins ?? {};
+}
 function pluginDirCandidates(id, installPaths) {
   const [name = "", marketplace = ""] = id.split("@");
+  const oneName = (s) => s !== "" && s !== "." && s !== ".." && !/[\\/]/.test(s);
+  if (!oneName(name) || !oneName(marketplace)) return installPaths;
   const plugins = join7(claudeDir(), "plugins");
   return [
     ...installPaths,
@@ -653,7 +688,7 @@ function pluginSkills(harnesses, root) {
   const cursor = harnesses.includes("cursor");
   if (!claude2 && !cursor) return [];
   const plugins = join7(claudeDir(), "plugins");
-  const installed = readJson(join7(plugins, "installed_plugins.json"))?.plugins ?? {};
+  const installed = installedPluginsJson();
   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) => {
@@ -665,7 +700,7 @@ function pluginSkills(harnesses, root) {
     return loadedBy.length ? skillDirsIn(join7(dir, "skills")).map((path) => ({ path, origin: id, loadedBy })) : [];
   });
   const syncedDir = join7(plugins, "synced");
-  const fromSynced = claude2 && existsSync6(syncedDir) ? readdirSync3(syncedDir).filter((b) => !b.startsWith(".")).flatMap(
+  const fromSynced = claude2 && existsSync6(syncedDir) ? readdirSync3(syncedDir).filter((b) => !b.startsWith(".") && isDir(join7(syncedDir, b))).flatMap(
     (bucket) => readdirSync3(join7(syncedDir, bucket), { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => {
       const root2 = join7(syncedDir, bucket, d.name);
       const name = readJson(join7(root2, ".claude-plugin", "plugin.json"))?.name ?? d.name;
@@ -673,17 +708,7 @@ function pluginSkills(harnesses, root) {
       return skillDirsIn(join7(root2, "skills")).map((path) => ({ path, origin: `${name}@synced`, loadedBy: ["claude-code"] }));
     })
   ) : [];
-  return [...fromMarketplaces, ...fromSynced].map(({ path, origin, loadedBy }) => ({
-    name: basename2(path),
-    kind: "plugin",
-    origin,
-    path,
-    description: readSkillInfo(path).description,
-    movable: false,
-    broken: false,
-    harnesses: loadedBy,
-    links: []
-  }));
+  return [...fromMarketplaces, ...fromSynced].map(({ path, origin, loadedBy }) => vendorSkill(path, "plugin", origin, loadedBy));
 }
 var byKindAndName = (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);
 function machineSkills(enabled = enabledHarnesses()) {
@@ -692,6 +717,7 @@ function machineSkills(enabled = enabledHarnesses()) {
     ...claudeAiSkills(enabled),
     ...pluginSkills(enabled),
     ...cursorBuiltInSkills(enabled),
+    ...codexBuiltInSkills(enabled),
     ...grokBuiltInSkills(enabled),
     ...systemSkills(enabled)
   ].sort(byKindAndName);
@@ -705,15 +731,20 @@ function originsFile() {
   return join7(skilllibHome(), "origins.json");
 }
 function libraryOrigins() {
-  return readJson(originsFile()) ?? {};
+  return readState(originsFile()) ?? {};
 }
 function recordOrigin(name, origin) {
   const origins = libraryOrigins();
   if (origins[name] === origin) return;
-  mkdirSync4(skilllibHome(), { recursive: true });
-  writeFileSync4(originsFile(), JSON.stringify({ ...origins, [name]: origin }, null, 2) + "\n");
+  mkdirSync3(skilllibHome(), { recursive: true });
+  writeState(originsFile(), { ...origins, [name]: origin });
 }
 function originFor(dir) {
+  const under = (path, folder) => path.startsWith((realpathOrNull(folder) ?? folder) + sep3);
+  const real = realpathOrNull(dir) ?? dir;
+  const temps = [tmpdir(), "/tmp", "/var/tmp"];
+  const homeInTemp = temps.some((t) => under(realpathOrNull(userHome()) ?? userHome(), t));
+  if (temps.some((t) => under(real, t)) && !(homeInTemp && under(real, userHome()))) return "";
   const match = machineSkills().find((s) => resolve5(s.path) === resolve5(dir));
   if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
   const project = dir.split(/[\\/]\.(?:claude|agents|grok|cursor|codex)[\\/]skills[\\/]/)[0];
@@ -733,13 +764,6 @@ function librarySkills() {
 function librarySkillDir(name) {
   return join8(libraryDir(), name);
 }
-function realpathOrNull2(path) {
-  try {
-    return realpathSync4(path);
-  } catch {
-    return null;
-  }
-}
 function isLink(path) {
   try {
     return lstatSync2(path).isSymbolicLink();
@@ -747,9 +771,65 @@ function isLink(path) {
     return false;
   }
 }
+function notWritable(root, dir) {
+  const top = realpathOrNull(root) ?? root;
+  let p = root;
+  for (const part of dir.split("/")) {
+    p = join8(p, part);
+    if (!entryExists(p)) return null;
+    const real = realpathOrNull(p);
+    if (!isDir(p) || real === null || real !== top && !real.startsWith(top + sep4)) return relative2(root, p).split(sep4).join("/");
+  }
+  return null;
+}
+var linksOut = (root, path) => isLink(join8(root, path)) && isDir(join8(root, path));
+function blockerSaid(root, path) {
+  const full = join8(root, path);
+  if (!isLink(full)) return `${path} is a file, not a folder`;
+  const real = realpathOrNull(full);
+  return real === null ? `${path} is a link to nothing` : linksOut(root, path) ? `${path} links out of the repo (to ${tildify(real)})` : `${path} links to a file`;
+}
+function inTheWaySaid(root, paths) {
+  return paths.map((p) => ALL_PROJECT_DIRS.includes(posix.dirname(p)) ? `${p} is taken (another copy, or a file)` : blockerSaid(root, p)).join("; ");
+}
+var writableDir = (root, dir) => notWritable(root, dir) === null;
+function reposChoice(root, dir) {
+  if (writableDir(root, dir)) return true;
+  const real = isDir(join8(root, dir)) ? realNative(join8(root, dir)) : null;
+  return real !== null && !globalSkillDirs().some((g) => realNative(g) === real);
+}
+var firstStuck = (root, dirs) => dirs.map((d) => notWritable(root, d)).find((p) => p !== null) ?? null;
+var fileAt = (path) => entryExists(path) && !isLink(path) && !isDir(path);
+function syncDone(root, name, dep) {
+  const copy = join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name);
+  return treeHash(copy) === dep.hash && (dep.links ?? []).every((d) => realpathOrNull(join8(root, d, name)) === realpathOrNull(copy));
+}
+function slotAt(link2, to) {
+  if (isLink(link2) && !isDir(link2)) return "free";
+  if (!entryExists(link2)) return "free";
+  return realpathOrNull(link2) === realpathOrNull(to) ? "ok" : "taken";
+}
+function syncBlocker(root, name, dep = readManifest(root).skills[name]) {
+  if (!dep) return null;
+  const dir = dep.dir ?? PROJECT_SKILLS_DIR;
+  const stuck = firstStuck(root, [dir, ...dep.links ?? []]);
+  if (stuck) return { said: blockerSaid(root, stuck), outside: linksOut(root, stuck) };
+  if (syncDone(root, name, dep)) return null;
+  const copy = join8(root, dir, name);
+  if (fileAt(copy)) return { said: `${dir}/${name} is a file, not a skill folder`, outside: false };
+  for (const d of dep.links ?? []) {
+    const link2 = join8(root, d, name);
+    if (!entryExists(link2)) continue;
+    if (!isLink(link2)) return { said: `${d}/${name} is in the way of its link`, outside: false };
+    if (!isDir(link2) || realpathOrNull(link2) === realpathOrNull(copy)) continue;
+    const there = treeHash(link2);
+    if (there !== dep.hash && versionForHash(name, there ?? "") === null) return { said: `${d}/${name} links to a different copy`, outside: false };
+  }
+  return null;
+}
 function linkDir(target, link2) {
   if (process.platform === "win32") symlinkSync(target, link2, "junction");
-  else symlinkSync(relative2(dirname2(link2), target), link2);
+  else symlinkSync(relative2(dirname3(link2), target), link2);
 }
 function entryExists(path) {
   return isLink(path) || existsSync7(path);
@@ -760,11 +840,160 @@ function visibilityOf(root, name, enabled = enabledHarnesses()) {
     paths: harness(id).projectDirs.filter((dir) => existsSync7(join8(root, dir, name, "SKILL.md"))).length
   }));
 }
+function realNative(p) {
+  try {
+    return realpathSync3.native(p);
+  } catch {
+    return null;
+  }
+}
+function survives(path, gone) {
+  return lostAt(path, gone) === null;
+}
+function lostAt(path, gone) {
+  const key = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+  const canon = (p) => {
+    const dir = realNative(dirname3(p)) ?? dirname3(p);
+    const leaf = basename3(p);
+    try {
+      lstatSync2(join8(dir, leaf));
+      const names = readdirSync4(dir);
+      return join8(dir, names.includes(leaf) ? leaf : names.find((n) => n.toLowerCase() === leaf.toLowerCase()) ?? leaf);
+    } catch {
+      return join8(dir, leaf);
+    }
+  };
+  const moved = gone.map((g) => key(canon(g)));
+  let at = path;
+  let last = null;
+  for (let hop = 0; hop < 40; hop++) {
+    const here = canon(at);
+    if (moved.some((m) => key(here) === m || key(here).startsWith(m + sep4))) return last ?? here;
+    if (!isLink(here)) return existsSync7(join8(here, "SKILL.md")) ? null : here;
+    last = here;
+    at = resolve6(dirname3(here), readlinkSync2(here).replace(/^\\\\\?\\(UNC\\)?/, (_m, unc) => unc ? "\\\\" : ""));
+  }
+  return last;
+}
+function blindWithoutGlobal(name, copies, roots, nestedOf = (root) => nestedEntries(root), packagesOf = (root) => packageDirs(root)) {
+  const gone = copies.flatMap((c) => [c.path, ...c.links ?? []]);
+  const readers = new Set(copies.flatMap((c) => c.harnesses));
+  const enabled = enabledHarnesses();
+  const holds = (root) => ALL_PROJECT_DIRS.some((d) => reposChoice(root, d) && entryExists(join8(root, d, name))) || pinsSkill(root, name);
+  const keepsTop = (root, id) => harness(id).projectDirs.some((d) => existsSync7(join8(root, d, name, "SKILL.md")) && survives(join8(root, d, name), gone));
+  const shown = (root, p) => {
+    const under = (dir) => ((d) => p.startsWith(d + sep4) ? relative2(d, p).split(sep4).join("/") : null)(realNative(dir) ?? dir);
+    return under(root) ?? ((h) => h === null ? p : `~/${h}`)(under(userHome()));
+  };
+  const blindIn = (root) => enabled.flatMap((id) => {
+    const reach = harness(id).projectDirs.some((d) => existsSync7(join8(root, d, name, "SKILL.md")));
+    if (keepsTop(root, id) || !readers.has(id) && !reach) return [];
+    const folder = harness(id).projectDirs.map((d) => reposChoice(root, d) ? null : notWritable(root, d)).find((f) => f !== null) ?? null;
+    const shared = harness(id).projectDirs.find((d) => !writableDir(root, d) && reposChoice(root, d));
+    const at = shared && existsSync7(join8(root, shared, name, "SKILL.md")) ? lostAt(join8(root, shared, name), gone) : null;
+    if (shared && !at) return [{ root, id, folder, shared: { dir: shared, to: shown(root, realNative(join8(root, shared)) ?? join8(root, shared)) } }];
+    const own = at ? null : harness(id).projectDirs.find((d) => writableDir(root, d) && isLink(join8(root, d, name)) && existsSync7(join8(root, d, name, "SKILL.md")));
+    const ownAt = own ? lostAt(join8(root, own, name), gone) : null;
+    return [{ root, id, folder, ...at ? { link: shown(root, at) } : ownAt ? { link: shown(root, ownAt) } : {} }];
+  });
+  const nestedBlind = (root) => nestedOf(root).filter((n) => n.name === name && !survives(n.path, gone)).flatMap(
+    (n) => n.readers.filter((id) => !keepsTop(root, id)).map((id) => ((pkg) => ({ root: pkg, id, folder: null, link: shown(pkg, lostAt(n.path, gone) ?? n.path) }))(join8(root, n.location, "..", "..")))
+  );
+  const unique = [...new Map(roots.map((r) => [realpathOrNull(r) ?? r, r])).values()];
+  const key = (p) => realpathOrNull(p) ?? p;
+  const asked = new Set(unique.map(key));
+  const pinnedPackages = (root) => packagesOf(root).filter((sub) => existsSync7(join8(sub, MANIFEST_FILE)) && pinsSkill(sub, name) && !asked.has(key(sub))).flatMap((sub) => blindIn(sub).filter((b) => !keepsTop(root, b.id)));
+  const all = unique.flatMap((root) => [...holds(root) ? blindIn(root) : [], ...nestedBlind(root), ...pinnedPackages(root)]);
+  const byWho = /* @__PURE__ */ new Map();
+  for (const b of all) {
+    const k = `${key(b.root)}\0${b.id}`;
+    const had = byWho.get(k);
+    if (!had || !(had.link || had.folder || had.shared) && (b.link || b.folder || b.shared)) byWho.set(k, b);
+  }
+  const within = (d) => unique.some((r) => d === r || d.startsWith(r + sep4));
+  const home2 = realNative(userHome()) ?? userHome();
+  const belowHome = (d) => (realNative(d) ?? d) !== home2 && !home2.startsWith((realNative(d) ?? d) + sep4);
+  const gitTop = (from) => {
+    for (let d = from; d !== dirname3(d) && belowHome(d); d = dirname3(d)) if (existsSync7(join8(d, ".git"))) return d;
+    return null;
+  };
+  const servedAbove = (b) => {
+    const top = gitTop(b.root);
+    const inside = (d) => belowHome(d) && (top ? d === top || d.startsWith(top + sep4) : within(d));
+    for (let d = dirname3(b.root); inside(d) && d !== dirname3(d); d = dirname3(d)) if (keepsTop(d, b.id)) return true;
+    return false;
+  };
+  return [...byWho.values()].filter((b) => !servedAbove(b));
+}
+function strandedLinks(name, copies, roots, label = basename3) {
+  const gone = copies.flatMap((c) => [c.path, ...c.links ?? []]);
+  const unique = [...new Map(roots.map((r) => [realpathOrNull(r) ?? r, r])).values()];
+  const seen = /* @__PURE__ */ new Set();
+  const once = (p) => ((k) => seen.has(k) ? false : (seen.add(k), true))(join8(realNative(dirname3(p)) ?? dirname3(p), basename3(p)));
+  return unique.flatMap((root) => [
+    ...ALL_PROJECT_DIRS.filter(
+      (d) => writableDir(root, d) && isLink(join8(root, d, name)) && existsSync7(join8(root, d, name, "SKILL.md")) && !survives(join8(root, d, name), gone) && once(join8(root, d, name))
+    ).map(
+      (d) => `${d}/${name} in ${label(root)}`
+    ),
+    ...nestedEntries(root).filter((n) => n.name === name && isLink(n.path) && !survives(n.path, gone) && once(n.path)).map((n) => `${relative2(root, n.path).split(sep4).join("/")} in ${label(root)}`)
+  ]);
+}
+function copiesDiffer(paths) {
+  return new Set(paths.map((p) => treeHash(p)).filter((h) => h !== null)).size > 1;
+}
+function blindSaid(name, blind, label = basename3) {
+  const who = blind.map((b) => `${harness(b.id).name} in ${label(b.root)}`).join(", ");
+  const folders2 = [...new Set(blind.flatMap((b) => b.folder ? [`${b.folder} in ${label(b.root)}`] : []))];
+  const links = [...new Set(blind.flatMap((b) => b.link ? [b.link.startsWith("~") || isAbsolute(b.link) ? b.link : `${b.link} in ${label(b.root)}`] : []))];
+  const sharedBy = /* @__PURE__ */ new Map();
+  for (const b of blind.filter((x) => x.shared)) {
+    if (!sharedBy.has(b.shared.to)) sharedBy.set(b.shared.to, { to: b.shared.to, where: /* @__PURE__ */ new Set(), dirs: /* @__PURE__ */ new Set() });
+    sharedBy.get(b.shared.to).where.add(`${b.shared.dir} in ${label(b.root)}`);
+    sharedBy.get(b.shared.to).dirs.add(b.shared.dir);
+  }
+  const shared = [...sharedBy.values()].map(
+    (g) => `put a copy of ${name} in ${g.to} (${[...g.where].join(", ")} link${g.where.size === 1 ? "s" : ""} there), or point ${g.where.size === 1 ? `${[...g.dirs][0]} back into the repo` : "those folders back into their repos"}`
+  );
+  const repos = blind.filter((b) => !b.folder && !b.link && !b.shared);
+  const fixes = [
+    ...folders2.length ? [`point ${folders2.join(", ")} back into the repo`] : [],
+    // A package's link to the global copy: add or link at the repo's top doesn't touch it.
+    ...links.length ? [`give ${links.join(", ")} ${links.length === 1 ? "a copy of its own" : "each a copy of its own"} instead of a link to the global one`] : [],
+    ...shared,
+    // Named, so with other advice beside it, it's clear which repo (or package) this is about.
+    ...repos.length ? ((names) => [`give ${names.join(", ")} ${names.length === 1 ? "a copy of its own" : "their own copies"} (skilllib add, sync or link there)`])([...new Set(repos.map((b) => label(b.root)))]) : []
+  ];
+  return `${who} only ${blind.length === 1 ? "sees" : "see"} the global copy: ${fixes.join("; ")}, or keep ${name} global (skilllib global keep)`;
+}
 function dependencyDirs(root, name, dep) {
-  const wanted = installDirs(enabledHarnesses());
   const untracked = ALL_PROJECT_DIRS.find((d) => d !== GROK_SKILLS_DIR && existsSync7(join8(root, d, name, "SKILL.md")) && !isLink(join8(root, d, name)));
-  const primary = dep ? dep.dir ?? PROJECT_SKILLS_DIR : untracked ?? wanted[0];
-  return [primary, .../* @__PURE__ */ new Set([...dep?.links ?? [], ...wanted.filter((d) => d !== primary)])];
+  const primary = dep ? dep.dir ?? PROJECT_SKILLS_DIR : untracked ?? installDirs(enabledHarnesses())[0];
+  const wanted = installDirs(enabledHarnesses(), primary);
+  const real = (d) => realpathOrNull(join8(root, d));
+  const same = (d) => d === primary || real(d) !== null && real(d) === real(primary);
+  return [primary, .../* @__PURE__ */ new Set([...dep?.links ?? [], ...wanted.filter((d) => !same(d))])];
+}
+function trackBlocker(root, name) {
+  let recorded;
+  try {
+    recorded = readManifest(root).skills[name];
+  } catch {
+    return `${MANIFEST_FILE} can't be read`;
+  }
+  const stuck = firstStuck(root, dependencyDirs(root, name, recorded));
+  return stuck ? blockerSaid(root, stuck) : null;
+}
+function pinsSkill(root, name) {
+  try {
+    return name in readManifest(root).skills;
+  } catch {
+    try {
+      return readFileSync4(join8(root, MANIFEST_FILE), "utf-8").includes(JSON.stringify(name));
+    } catch {
+      return false;
+    }
+  }
 }
 function isGitTracked(root, dir) {
   try {
@@ -780,16 +1009,18 @@ function projectStatus(root) {
   const managed = Object.entries(skills).map(([name, dep]) => {
     const location = dep.dir ?? PROJECT_SKILLS_DIR;
     const path = join8(root, location, name);
-    const local = treeHash(path);
+    const local = notWritable(root, location) ? null : treeHash(path);
     const latest = latestVersion(name);
-    const edited = local !== dep.hash;
-    const behind = latest !== null && latest.hash !== dep.hash && latest.version > dep.version;
-    const state = local === null ? "folder missing" : latest === null ? "not in library" : local === latest.hash ? "ok" : edited && behind ? "edited locally, update available" : edited ? "edited locally" : behind ? "update available" : "ok";
+    const known = local !== null && local !== dep.hash && versionForHash(name, local) !== null;
+    const edited = local !== dep.hash && !known;
+    const pinned = versionForHash(name, dep.hash)?.version ?? dep.version;
+    const behind = latest !== null && latest.hash !== dep.hash && latest.version > pinned;
+    const state = local === null ? "folder missing" : latest === null ? "not in library" : local === latest.hash && !known ? "ok" : known ? "out of sync" : edited && behind ? "edited locally, update available" : edited ? "edited locally" : behind ? "update available" : "ok";
     return {
       name,
       managed: true,
       state,
-      version: dep.version || null,
+      version: pinned || null,
       latest: latest?.version ?? null,
       location,
       path,
@@ -800,7 +1031,7 @@ function projectStatus(root) {
   const lock = projectSkillsLock(root);
   const unmanaged = [];
   const byName = /* @__PURE__ */ new Map();
-  for (const dir of ALL_PROJECT_DIRS) {
+  for (const dir of ALL_PROJECT_DIRS.filter((d) => writableDir(root, d))) {
     for (const path of skillDirsIn(join8(root, dir))) {
       const name = basename3(path);
       if (seen.has(name)) continue;
@@ -809,7 +1040,7 @@ 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 location = relative2(root, join8(real, "..")).split(sep4).join("/");
     const source = lock[name]?.source;
     unmanaged.push({
       name,
@@ -841,40 +1072,57 @@ var NESTED_READERS = [
   // Cursor reads nested .grok/skills too, but skilllib doesn't count it: that folder stays Grok's.
   [".grok/skills", ["grok"]]
 ];
-var NESTED_SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage"]);
-function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
+function nestedSkills(root, { depth = PACKAGE_DEPTH, enabled = enabledHarnesses() } = {}) {
+  return nestedEntries(root, { depth, enabled }).map((n) => ({
+    name: n.name,
+    managed: false,
+    state: unmanagedState(n.name, n.path, isRepoSkillLocation(n.skillsDir), void 0),
+    version: null,
+    latest: latestVersion(n.name)?.version ?? null,
+    location: n.location,
+    path: n.path,
+    visibility: enabled.map((id) => ({ id, paths: n.readers.includes(id) ? 1 : 0 }))
+  }));
+}
+function nestedEntries(root, { depth = PACKAGE_DEPTH, enabled = enabledHarnesses(), subs } = {}) {
+  const top = realpathOrNull(root) ?? root;
+  const found = packageSkillFolders(root, subs ?? packageDirs(root, depth)).flatMap(
+    ({ sub, skillsDir, location }) => skillDirsIn(join8(sub, skillsDir)).flatMap((path) => {
+      if (isLink(path) && (realpathOrNull(path) ?? "").startsWith(top + sep4)) return [];
+      const name = basename3(path);
+      const readers = NESTED_READERS.filter(([d]) => realpathOrNull(join8(sub, d, name)) === realpathOrNull(path)).flatMap(([, r]) => r);
+      return [{ name, path, location, skillsDir, readers: enabled.filter((id) => readers.includes(id)) }];
+    })
+  );
+  return found.sort((a, b) => a.location.localeCompare(b.location) || a.name.localeCompare(b.name));
+}
+var PACKAGE_DEPTH = 5;
+function packageDirs(root, depth = PACKAGE_DEPTH) {
   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));
+      subs = readdirSync4(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !BUILD_DIRS.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, isRepoSkillLocation(skillsDir), void 0),
-            version: null,
-            latest: latestVersion(name)?.version ?? null,
-            location,
-            path,
-            visibility: enabled.map((id) => ({ id, paths: readers.includes(id) ? 1 : 0 }))
-          });
-        }
-      }
+      found.push(sub);
       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));
+  return found;
+}
+function packageSkillFolders(root, subs = packageDirs(root)) {
+  return subs.flatMap(
+    (sub) => NESTED_READERS.flatMap(([skillsDir]) => {
+      if (!existsSync7(join8(sub, skillsDir))) return [];
+      const location = relative2(root, join8(sub, skillsDir)).split(sep4).join("/");
+      return reposChoice(root, location) ? [{ sub, skillsDir, location }] : [];
+    })
+  );
 }
 function sharedByGit(root, location, name) {
   const copy = `${location}/${name}`;
@@ -889,13 +1137,24 @@ function sharedByGit(root, location, name) {
 }
 function linkEverywhere(root, name, location, { allowTracked = false, dryRun = false } = {}) {
   const enabled = enabledHarnesses();
-  const result = { created: [], blocked: [], uncommitted: [] };
+  const result = { created: [], blocked: [], uncommitted: [], inTheWay: [] };
   let shared;
+  const stuck = (path) => void (result.inTheWay.includes(path) || result.inTheWay.push(path));
   for (const id of enabled) {
     if (visibilityOf(root, name, [id])[0].paths > 0) continue;
     const dir = harness(id).projectDirs[0];
     const link2 = join8(root, dir, name);
-    if (entryExists(link2) || Object.values(result).some((dirs) => dirs.includes(dir))) continue;
+    if (Object.values(result).some((dirs) => dirs.includes(dir))) continue;
+    const blocker = notWritable(root, dir);
+    if (blocker) {
+      stuck(blocker);
+      continue;
+    }
+    const broken = isLink(link2) && !isDir(link2);
+    if (entryExists(link2) && !broken) {
+      stuck(`${dir}/${name}`);
+      continue;
+    }
     if (isGitTracked(root, dir)) {
       if (!(shared ??= sharedByGit(root, location, name))) {
         if (!result.uncommitted.includes(dir)) result.uncommitted.push(dir);
@@ -907,22 +1166,18 @@ function linkEverywhere(root, name, location, { allowTracked = false, dryRun = f
       }
     }
     if (!dryRun) {
-      mkdirSync5(join8(root, dir), { recursive: true });
+      if (broken) unlinkSync(link2);
+      mkdirSync4(join8(root, dir), { recursive: true });
       linkDir(join8(root, location, name), link2);
     }
     result.created.push(dir);
   }
   return result;
 }
-function unlinkEverywhere(root, name, removing) {
-  const gone = removing ? realpathOrNull2(removing) : null;
-  return ALL_PROJECT_DIRS.filter((dir) => {
+function unlinkEverywhere(root, name) {
+  return ALL_PROJECT_DIRS.filter((dir) => writableDir(root, dir)).filter((dir) => {
     const link2 = join8(root, dir, name);
-    if (!isLink(link2)) return false;
-    if (dir === GROK_SKILLS_DIR) {
-      const target = realpathOrNull2(link2);
-      if (target !== null && target !== gone) return false;
-    }
+    if (!isLink(link2) || realpathOrNull(link2) !== null) return false;
     unlinkSync(link2);
     return true;
   });
@@ -930,7 +1185,7 @@ function unlinkEverywhere(root, name, removing) {
 function relinkDependency(root, name, { allowTracked = false } = {}) {
   const manifest = readManifest(root);
   const dep = manifest.skills[name];
-  if (!dep) return { created: [], blocked: [], uncommitted: [] };
+  if (!dep) return { created: [], blocked: [], uncommitted: [], inTheWay: [] };
   const result = linkEverywhere(root, name, dep.dir ?? PROJECT_SKILLS_DIR, { allowTracked });
   if (result.created.length) {
     manifest.skills[name] = { ...dep, links: [.../* @__PURE__ */ new Set([...dep.links ?? [], ...result.created])] };
@@ -938,53 +1193,80 @@ function relinkDependency(root, name, { allowTracked = false } = {}) {
   }
   return result;
 }
-function linkAll(root, { allowTracked = false } = {}) {
+function linkAll(root, { allowTracked = false, names } = {}) {
   const linked = [];
   const blocked = /* @__PURE__ */ new Set();
   const uncommitted = [];
+  const inTheWay = /* @__PURE__ */ new Set();
   for (const skill of projectStatus(root)) {
-    if (!skill.visibility.some((v) => v.paths === 0) || skill.state === "folder missing") continue;
+    if (names && !names.includes(skill.name) || !skill.visibility.some((v) => v.paths === 0) || skill.state === "folder missing") continue;
     const res = skill.managed ? relinkDependency(root, skill.name, { allowTracked }) : linkEverywhere(root, skill.name, skill.location, { allowTracked });
     if (res.created.length) linked.push({ name: skill.name, into: res.created });
     for (const dir of res.blocked) blocked.add(dir);
     if (res.uncommitted.length) uncommitted.push(skill.name);
+    for (const path of res.inTheWay) inTheWay.add(path);
   }
-  return { linked, blocked: [...blocked], uncommitted };
+  return { linked, blocked: [...blocked], uncommitted, inTheWay: [...inTheWay] };
 }
-function addSkill(root, name, { force = false, version, allowTracked = false } = {}) {
-  const target = version === void 0 ? latestVersion(name) : getVersion(name, version);
-  if (!target) return { name, action: "skipped", reason: version === void 0 ? "not in the library" : `version ${version} doesn't exist` };
+function addPlan(root, name, hash, force) {
   const manifest = readManifest(root);
   const recorded = manifest.skills[name];
-  const [primary = PROJECT_SKILLS_DIR, ...linkDirs] = dependencyDirs(root, name, recorded);
+  const [primary = PROJECT_SKILLS_DIR, ...wantedLinks] = dependencyDirs(root, name, recorded);
+  const stuck = firstStuck(root, [primary, ...wantedLinks]);
+  if (stuck) return { reason: `${blockerSaid(root, stuck)}, so skilllib doesn't install there` };
   const to = join8(root, primary, name);
+  if (fileAt(to)) return { reason: `${primary}/${name} is a file, not a skill folder: move it first` };
   const local = isLink(to) && !recorded ? null : treeHash(to);
   const knownContent = local !== null && (local === recorded?.hash || versionForHash(name, local) !== null);
-  if (local !== null && local !== target.hash && !knownContent && !force) {
+  if (!recorded && entryExists(to) && isGitTracked(root, `${primary}/${name}`))
+    return { reason: `${primary}/${name} is the repo's own (committed): skilllib doesn't replace it; remove it in the repo first if the library's should win` };
+  const linked = local === null && !recorded && isLink(to) ? treeHash(to) : null;
+  if (linked !== null && linked !== hash && versionForHash(name, linked) === null && !force)
+    return { reason: `${primary}/${name} links to a different copy (use --force to replace the link)` };
+  if (local !== null && local !== hash && !knownContent && !force) {
     return {
-      name,
-      action: "skipped",
       reason: recorded ? "has local edits (use --force to overwrite, or save them to the library first)" : `${primary}/${name} already exists with different content (use --force to replace it)`
     };
   }
+  return { manifest, recorded, primary, wantedLinks, to, local };
+}
+function addRefusal(root, name, hash) {
+  const plan = addPlan(root, name, hash, false);
+  return "reason" in plan ? plan.reason : null;
+}
+function addSkill(root, name, { force = false, version, allowTracked = false } = {}) {
+  if (!name || name === "." || name === ".." || /[\\/]/.test(name)) return { name, action: "skipped", reason: "not a skill name" };
+  const target = version === void 0 ? latestVersion(name) : getVersion(name, version);
+  if (!target) return { name, action: "skipped", reason: version === void 0 ? "not in the library" : `version ${version} doesn't exist` };
+  const plan = addPlan(root, name, target.hash, force);
+  if ("reason" in plan) return { name, action: "skipped", reason: plan.reason };
+  const { manifest, recorded, primary, wantedLinks, to, local } = plan;
   let backedUp;
-  if (local !== target.hash || isLink(to)) {
-    mkdirSync5(join8(root, primary), { recursive: true });
+  const copied = local !== target.hash || isLink(to);
+  if (copied) {
+    mkdirSync4(join8(root, primary), { recursive: true });
     if (isLink(to)) unlinkSync(to);
-    else if (local !== null && !knownContent) backedUp = stash(to, "edit-backup");
+    else if (local !== null && versionForHash(name, local) === null) backedUp = stash(to, "edit-backup");
     copySkill(versionDir(name, target.version), to);
   }
   const links = [];
   const blocked = [];
   const uncommitted = [];
+  const inTheWay = [];
   let shared;
-  for (const dir of linkDirs) {
+  let relinked = false;
+  for (const dir of wantedLinks) {
     const link2 = join8(root, dir, name);
-    if (isLink(link2) && realpathOrNull2(link2) === realpathOrNull2(to)) {
+    const slot = slotAt(link2, to);
+    if (slot === "ok") {
       links.push(dir);
       continue;
     }
-    if (entryExists(link2)) continue;
+    if (slot === "taken") {
+      inTheWay.push(`${dir}/${name}`);
+      if (recorded?.links?.includes(dir)) links.push(dir);
+      continue;
+    }
     if (!recorded?.links?.includes(dir) && isGitTracked(root, dir)) {
       if (!(shared ??= sharedByGit(root, primary, name))) {
         uncommitted.push(dir);
@@ -995,9 +1277,11 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
         continue;
       }
     }
-    mkdirSync5(join8(root, dir), { recursive: true });
+    if (isLink(link2)) unlinkSync(link2);
+    mkdirSync4(join8(root, dir), { recursive: true });
     linkDir(to, link2);
     links.push(dir);
+    relinked = true;
   }
   manifest.skills[name] = {
     version: target.version,
@@ -1006,13 +1290,21 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
     ...links.length ? { links } : {}
   };
   writeManifest(root, manifest);
+  const from = recorded ? versionForHash(name, recorded.hash)?.version ?? recorded.version : void 0;
   return {
     name,
-    action: !recorded && local === null ? "installed" : backedUp && recorded?.version === target.version ? "reset" : "updated",
-    ...recorded ? { from: recorded.version } : {},
+    action: (
+      // Nothing of it was there (or only an identical untracked copy, now tracked): installed, not updated.
+      !recorded || local === null ? "installed" : backedUp && from === target.version ? "reset" : recorded && !copied && from === target.version ? (
+        // The same version, already there: only links (if any) were written.
+        relinked ? "relinked" : "unchanged"
+      ) : "updated"
+    ),
+    ...from !== void 0 ? { from } : {},
     to: target.version,
     ...blocked.length ? { blocked } : {},
     ...uncommitted.length ? { uncommitted } : {},
+    ...inTheWay.length ? { inTheWay } : {},
     ...backedUp ? { backedUp } : {}
   };
 }
@@ -1020,54 +1312,113 @@ function removeSkill(root, name, { force = false } = {}) {
   const manifest = readManifest(root);
   const recorded = manifest.skills[name];
   if (!recorded) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
-  const dir = join8(root, recorded.dir ?? PROJECT_SKILLS_DIR, name);
-  const local = treeHash(dir);
-  const edited = local !== null && local !== recorded.hash && !versionForHash(name, local);
-  if (edited && !force) return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
-  for (const linkDir2 of recorded.links ?? []) {
-    const link2 = join8(root, linkDir2, name);
-    if (isLink(link2)) unlinkSync(link2);
+  const home2 = recorded.dir ?? PROJECT_SKILLS_DIR;
+  const dir = join8(root, home2, name);
+  const takenLinks = [];
+  const unlinkOwn = () => {
+    for (const linkDir2 of (recorded.links ?? []).filter((d) => writableDir(root, d))) {
+      const link2 = join8(root, linkDir2, name);
+      if (isLink(link2) && slotAt(link2, dir) !== "taken") unlinkSync(link2);
+      else if (entryExists(link2) && slotAt(link2, dir) === "taken") takenLinks.push(`${linkDir2}/${name} is something else (another copy, or a file): left as it is`);
+    }
+  };
+  const leftLinks = (recorded.links ?? []).flatMap(
+    (d) => ((b) => b && entryExists(join8(root, d, name)) ? [`${blockerSaid(root, b)}: its link there was left alone`] : [])(notWritable(root, d))
+  );
+  const ownStuck = notWritable(root, home2);
+  if (ownStuck || fileAt(dir)) {
+    delete manifest.skills[name];
+    writeManifest(root, manifest);
+    const why = ownStuck ? blockerSaid(root, ownStuck) : `${home2}/${name} is a file, not a skill folder`;
+    const keptLinks = (recorded.links ?? []).flatMap((d) => {
+      const link2 = join8(root, d, name);
+      if (!writableDir(root, d) || !entryExists(link2)) return [];
+      return [slotAt(link2, dir) === "taken" ? `${d}/${name} is something else (another copy, or a file): left as it is` : `its link ${d}/${name} was left too`];
+    });
+    return { name, action: "removed", reason: [`${why}: only its pin was removed, and that copy was left as it is`, ...keptLinks, ...leftLinks].join("; ") };
   }
-  const backedUp = edited ? stash(dir, "edit-backup") : void 0;
-  if (!backedUp) rmSync2(dir, { recursive: true, force: true });
+  const local = treeHash(dir);
+  const inLibrary = local !== null && versionForHash(name, local) !== null;
+  const edited = local !== null && local !== recorded.hash && !inLibrary;
+  if (edited && !force)
+    return {
+      name,
+      action: "skipped",
+      // A pin from another library isn't an edit of yours: say what it is. Either way --force backs the copy up first.
+      reason: versionForHash(name, recorded.hash) === null ? "doesn't match what skilllib.json pins, and your library has neither (use --force to remove it; it's backed up first)" : "has local edits (use --force to delete anyway; they're backed up first)"
+    };
+  unlinkOwn();
+  const backedUp = local !== null && !inLibrary ? stash(dir, "edit-backup") : void 0;
+  if (!backedUp) rmSync3(dir, { recursive: true, force: true });
   delete manifest.skills[name];
   writeManifest(root, manifest);
-  return { name, action: "removed", ...backedUp ? { backedUp } : {} };
+  const left = [...leftLinks, ...takenLinks];
+  return { name, action: "removed", ...left.length ? { reason: left.join("; ") } : {}, ...backedUp ? { backedUp } : {} };
 }
-function syncProject(root, { force = false } = {}) {
-  return Object.keys(readManifest(root).skills).flatMap((name) => syncSkill(root, name, { force }));
+function syncProject(root, { force = false, names } = {}) {
+  return Object.keys(readManifest(root).skills).filter((name) => !names || names.includes(name)).flatMap((name) => syncSkill(root, name, { force }));
 }
 function syncSkill(root, name, { force = false } = {}) {
   const dep = readManifest(root).skills[name];
   if (!dep) return [];
-  const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
-  const linksOk = (dep.links ?? []).every((d) => existsSync7(join8(root, d, name, "SKILL.md")));
-  if (local === dep.hash && linksOk) return [];
-  if (local !== null && local !== dep.hash && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
-  const change = addSkill(root, name, { force: true, version: pinnedVersion(name, dep) });
-  if (change.action === "skipped") return [{ ...change, reason: `not in your library (${tildify(libraryDir())}); import it, or set SKILLLIB_HOME to the library that has it` }];
-  return [{ ...change, action: local === null ? "installed" : change.action }];
+  const copy = join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name);
+  const local = treeHash(copy);
+  const blocker = syncBlocker(root, name, dep);
+  if (blocker) return [{ name, action: "skipped", reason: `${blocker.said}: ${blocker.outside ? "skilllib only installs inside the repo" : "move it, then sync"}` }];
+  if (syncDone(root, name, dep)) return [];
+  if (local === dep.hash) return [relinkPinned(root, name, dep)];
+  const version = pinnedVersion(name, dep);
+  if (typeof version === "string") return [{ name, action: "skipped", reason: version }];
+  if (local !== null && local !== dep.hash && versionForHash(name, local) === null && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
+  const backedUp = local !== null && versionForHash(name, local) === null ? stash(copy, "edit-backup") : void 0;
+  mkdirSync4(dirname3(copy), { recursive: true });
+  copySkill(versionDir(name, version), copy);
+  const links = relinkPinned(root, name, dep);
+  const from = (local !== null ? versionForHash(name, local)?.version : void 0) ?? version;
+  return [
+    {
+      name,
+      action: local === null ? "installed" : backedUp ? "reset" : "updated",
+      from,
+      to: version,
+      ...backedUp ? { backedUp } : {},
+      ...links.action === "skipped" ? { reason: links.reason } : {}
+    }
+  ];
+}
+function relinkPinned(root, name, dep) {
+  const to = join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name);
+  for (const dir of dep.links ?? []) {
+    const link2 = join8(root, dir, name);
+    if (realpathOrNull(link2) === realpathOrNull(to)) continue;
+    if (isLink(link2)) unlinkSync(link2);
+    else if (entryExists(link2)) return { name, action: "skipped", reason: `${dir}/${name} is in the way of its link: move it, then sync` };
+    mkdirSync4(join8(root, dir), { recursive: true });
+    linkDir(to, link2);
+  }
+  return { name, action: "relinked", to: versionForHash(name, dep.hash)?.version ?? dep.version };
 }
 function pinnedVersion(name, dep) {
-  return versionForHash(name, dep.hash)?.version ?? (dep.version > 0 && getVersion(name, dep.version) ? dep.version : void 0);
+  if (!latestVersion(name)) return `not in your library (${tildify(libraryDir())}); import it, or set SKILLLIB_HOME to the library that has it`;
+  return versionForHash(name, dep.hash)?.version ?? `your library has no copy of the version skilllib.json pins (pinned from another library?); skilllib update ${name} installs your newest`;
 }
 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);
-  if (existsSync7(dir) && !isLink(dir)) stash(dir, "edit-backup");
-  return addSkill(root, name, { force: true, version: pinnedVersion(name, dep) });
+  const version = pinnedVersion(name, dep);
+  if (typeof version === "string") return { name, action: "skipped", reason: version };
+  return addSkill(root, name, { force: true, version });
 }
-function updateProject(root, names, { force = false } = {}) {
+function updateProject(root, names, { force = false, allowTracked = false } = {}) {
   const { skills } = readManifest(root);
   return Object.keys(skills).filter((name) => !names || names.includes(name)).flatMap((name) => {
     const latest = latestVersion(name);
-    if (!latest) return [{ name, action: "skipped", reason: "no longer in the library" }];
+    if (!latest) return [{ name, action: "skipped", reason: "not in your library" }];
     const dep = skills[name];
     const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
     if (dep.hash === latest.hash && local === latest.hash) return [];
     if (dep.hash === latest.hash && local !== null && !force) return [];
-    const change = addSkill(root, name, { force });
+    const change = addSkill(root, name, { force, allowTracked });
     return change.action === "skipped" || change.from !== change.to || local !== latest.hash ? [change] : [];
   });
 }
@@ -1078,8 +1429,12 @@ function importSkill(dir, { force = false } = {}) {
   const incoming = treeHash(dir);
   if (existing === incoming) return { name, status: "unchanged" };
   if (existing !== null && !force) return { name, status: "exists" };
-  mkdirSync5(libraryDir(), { recursive: true });
+  mkdirSync4(libraryDir(), { recursive: true });
   const origin = existing !== null && libraryOrigins()[name] ? null : originFor(dir);
+  if (existing !== null) {
+    forgetLatest(name);
+    latestVersion(name);
+  }
   copySkill(dir, to);
   if (origin) recordOrigin(name, origin);
   forgetLatest(name);
@@ -1090,19 +1445,15 @@ function backupIndexFile(bucket) {
   return join8(skilllibHome(), bucket, "index.json");
 }
 function readBackupIndex(bucket) {
-  try {
-    return JSON.parse(readFileSync6(backupIndexFile(bucket), "utf-8"));
-  } catch {
-    return {};
-  }
+  return readState(backupIndexFile(bucket)) ?? {};
 }
 function move(from, to) {
   try {
-    renameSync(from, to);
+    renameSync2(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
     cpSync2(from, to, { recursive: true, verbatimSymlinks: true });
-    rmSync2(from, { recursive: true, force: true });
+    rmSync3(from, { recursive: true, force: true });
   }
 }
 function stash(dir, bucket) {
@@ -1111,17 +1462,21 @@ function stash(dir, bucket) {
   while (entryExists(join8(skilllibHome(), bucket, entryAt(at)))) at++;
   const entry = entryAt(at);
   const target = join8(skilllibHome(), bucket, entry);
-  mkdirSync5(join8(skilllibHome(), bucket), { recursive: true });
+  const index = readBackupIndex(bucket);
+  mkdirSync4(join8(skilllibHome(), bucket), { recursive: true });
   move(dir, target);
-  writeFileSync5(backupIndexFile(bucket), JSON.stringify({ ...readBackupIndex(bucket), [entry]: dir }, null, 2) + "\n");
+  writeState(backupIndexFile(bucket), { ...index, [entry]: dir });
   return target;
 }
 function removeUntracked(root, name, path) {
-  unlinkEverywhere(root, name, path);
-  return stash(path, "trash");
+  const stuck = notWritable(root, relative2(root, dirname3(path)));
+  if (stuck) throw new Error(`${stuck} isn't a folder in the repo: skilllib leaves what's in it alone`);
+  const to = stash(path, "trash");
+  unlinkEverywhere(root, name);
+  return to;
 }
 function projectsUsing(name) {
-  return knownProjects().filter((p) => name in readManifest(p).skills);
+  return knownProjects().filter((p) => pinsSkill(p, name));
 }
 function deleteLibrarySkill(name) {
   const using = projectsUsing(name);
@@ -1150,13 +1505,13 @@ function linkGlobal(path, agents) {
   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);
+    if (isLink(link2) && realpathOrNull(link2) === null) unlinkSync(link2);
     else if (entryExists(link2)) {
-      if (realpathOrNull2(link2) !== realpathOrNull2(path)) skipped.push(link2);
+      if (realpathOrNull(link2) !== realpathOrNull(path)) skipped.push(link2);
       continue;
     }
-    mkdirSync5(dir, { recursive: true });
-    linkDir(path, link2);
+    mkdirSync4(dir, { recursive: true });
+    linkDir(realpathOrNull(path) ?? path, join8(realpathOrNull(dir) ?? dir, name));
     linked.push(link2);
   }
   return { linked, skipped };
@@ -1165,12 +1520,13 @@ 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);
   if (existsSync7(dir)) return { ok: false, reason: `${name} already exists` };
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync5(
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync2(
     join8(dir, "SKILL.md"),
+    // JSON strings are valid YAML: a description with ": " or "#" stays one value.
     `---
 name: ${name}
-description: ${description || "Describe when an agent should use this skill."}
+description: ${JSON.stringify(description || "Describe when an agent should use this skill.")}
 ---
 
 # ${name}
@@ -1190,26 +1546,28 @@ function listBackups() {
       const match = entry.match(/^(.*)-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-\d{3}Z$/);
       if (!match) return [];
       const name = match[1];
-      const from = index[entry] ?? (kind === "trash" ? librarySkillDir(name) : join8(claudeDir(), "skills", name));
-      return [{ name, kind, path: join8(dir, entry), movedAt: `${match[2]} ${match[3]}:${match[4]}`, from }];
+      const from = index[entry] ?? (kind === "trash" ? librarySkillDir(name) : kind === "global-backup" ? join8(claudeDir(), "skills", name) : "");
+      return [{ name, kind, path: join8(dir, entry), movedAt: localStamp(Date.parse(`${match[2]}T${match[3]}:${match[4]}:${match[5]}Z`)), from }];
     });
   }).sort((a, b) => b.path.slice(-24).localeCompare(a.path.slice(-24)));
 }
+function movedTogether(backups, backup) {
+  if (backup.kind === "plugin") return [backup];
+  const at = (b) => Date.parse(b.path.slice(-24).replace(/^(.{13})-(\d\d)-(\d\d)-(\d{3})Z$/, "$1:$2:$3.$4Z"));
+  return backups.filter((b) => b.name === backup.name && b.kind === backup.kind && Math.abs(at(b) - at(backup)) <= 2e3);
+}
 function backupFrom(backup) {
   if (backup.kind === "plugin") return "Claude Code plugin";
-  return backup.from === librarySkillDir(backup.name) ? "library (deleted)" : tildify(dirname2(backup.from));
+  if (!backup.from) return "unknown";
+  return backup.from === librarySkillDir(backup.name) ? "library (deleted)" : tildify(dirname3(backup.from));
 }
 function restoreBackup(backup) {
   const to = backup.from;
+  if (!to) return { ok: false, reason: `skilllib doesn't know where it came from; its files are in ${tildify(backup.path)}` };
   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;
-  } catch {
-  }
-  if (taken) return { ok: false, reason: `${backup.name} already exists there` };
-  mkdirSync5(join8(to, ".."), { recursive: true });
+  if (backup.kind === "edit-backup" && !isLink(to) && versionForHash(backup.name, treeHash(to) ?? "") !== null) rmSync3(to, { recursive: true, force: true });
+  if (entryExists(to)) return { ok: false, reason: `${backup.name} already exists there` };
+  mkdirSync4(join8(to, ".."), { recursive: true });
   move(backup.path, to);
   forgetLatest(backup.name);
   return { ok: true, to };
@@ -1218,56 +1576,51 @@ function restoreBackup(backup) {
 // src/agentSkill.ts
 var AGENT_SKILL_NAME = "skilllib";
 function shippedSkill() {
-  return readFileSync7(new URL("../skills/skilllib/SKILL.md", import.meta.url), "utf-8");
+  return readFileSync5(new URL("../skills/skilllib/SKILL.md", import.meta.url), "utf-8");
 }
 function agentSkillDirs(enabled = enabledHarnesses()) {
   const claudeSkills = join9(claudeDir(), "skills");
   const agentsSkills = join9(userHome(), ".agents", "skills");
   const needsClaude = enabled.some((id) => harness(id).globalDirs().includes(claudeSkills));
   const needsAgents = enabled.some((id) => !harness(id).globalDirs().includes(claudeSkills));
-  return [...needsClaude ? [claudeSkills] : [], ...needsAgents ? [agentsSkills] : []].map((d) => join9(d, AGENT_SKILL_NAME));
+  const dirs = [...needsClaude ? [claudeSkills] : [], ...needsAgents ? [agentsSkills] : []];
+  return dirs.filter((d, i) => dirs.findIndex((o) => realPath(o) === realPath(d)) === i).map((d) => join9(d, AGENT_SKILL_NAME));
 }
 function isOurs(dir) {
   return existsSync8(join9(dir, OWN_SKILL_MARKER));
 }
 function isDangling(path) {
-  return entryExists2(path) && lstatSync3(path).isSymbolicLink() && !existsSync8(path);
-}
-function entryExists2(path) {
-  try {
-    lstatSync3(path);
-    return true;
-  } catch {
-    return false;
-  }
+  return entryExists(path) && lstatSync3(path).isSymbolicLink() && !existsSync8(path);
 }
 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";
+  return [primary, ...links].every((d) => readFileSync5(join9(d, "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));
+  const foreign = [primary, ...links].find((d) => entryExists(d) && !isOurs(d) && !isDangling(d));
   if (foreign) return { ok: false, reason: `${tildify(foreign)} already exists and isn't skilllib's` };
   for (const d of [primary, ...links]) if (isDangling(d)) unlinkSync2(d);
-  mkdirSync6(primary, { recursive: true });
-  writeFileSync6(join9(primary, "SKILL.md"), shippedSkill());
-  writeFileSync6(join9(primary, OWN_SKILL_MARKER), "Installed by skilllib. `skilllib agent-skill remove` removes it.\n");
+  mkdirSync5(primary, { recursive: true });
+  writeFileSync3(join9(primary, "SKILL.md"), shippedSkill());
+  writeFileSync3(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 });
+    if (entryExists(link2) && !isLink(link2) && isOurs(link2)) rmSync4(link2, { recursive: true, force: true });
+    if (entryExists(link2)) continue;
+    mkdirSync5(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)));
+  const removed = all.filter((d) => entryExists(d) && (isOurs(d) || isDangling(d)));
   for (const d of removed) {
+    if (!entryExists(d)) continue;
     if (lstatSync3(d).isSymbolicLink()) unlinkSync2(d);
-    else rmSync3(d, { recursive: true, force: true });
+    else rmSync4(d, { recursive: true, force: true });
   }
   return removed;
 }
@@ -1279,14 +1632,14 @@ function refreshAgentSkill() {
 }
 
 // src/commands.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
 import { parseArgs as parseFlags } from "util";
-import { basename as basename9, join as join14, resolve as resolve7, sep as sep5 } from "path";
+import { basename as basename9, join as join15, resolve as resolve8, sep as sep8 } 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";
+import { existsSync as existsSync9, realpathSync as realpathSync4 } from "fs";
+import { isAbsolute as isAbsolute2, join as join10, relative as relative3, sep as sep5 } 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 });
@@ -1296,11 +1649,32 @@ function git(root, args, input) {
   }
 }
 function gitInfo(root, extraDirs = []) {
-  if (!existsSync9(join10(root, ".git"))) return null;
-  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE, ...extraDirs].filter((d) => existsSync9(join10(root, d)));
+  let inRepo;
+  try {
+    inRepo = execFileSync2("git", ["rev-parse", "--show-prefix"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    if (!existsSync9(join10(root, ".git"))) return null;
+    inRepo = "";
+  }
+  const real = (p) => {
+    try {
+      return realpathSync4.native(p);
+    } catch {
+      return p;
+    }
+  };
+  const realRoot = real(root);
+  const places = new Map(
+    [.../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS, MANIFEST_FILE, ...extraDirs])].filter((d) => existsSync9(join10(root, d))).map((d) => [d, relative3(realRoot, real(join10(root, d))).split(sep5).join("/")]).filter(([, place]) => place !== "" && place !== ".." && !place.startsWith("../") && !isAbsolute2(place))
+  );
+  const dirs = [...new Set(places.values())];
   if (dirs.length === 0) return { of: () => "new" };
+  const placeOf = (rel) => {
+    const dir = [...places.keys()].find((d) => rel === d || rel.startsWith(d + "/"));
+    return dir === void 0 ? rel : places.get(dir) + rel.slice(dir.length);
+  };
   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 dirty = (git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...dirs]) ?? "").split("\0").filter(Boolean).map((entry) => entry.slice(3)).filter((path) => path.startsWith(inRepo)).map((path) => path.slice(inRepo.length));
   const ignoredCache = /* @__PURE__ */ new Map();
   const isIgnored = (rel) => {
     if (!ignoredCache.has(rel)) {
@@ -1312,7 +1686,7 @@ function gitInfo(root, extraDirs = []) {
   const under = (list2, rel) => list2.some((p) => p === rel || p.startsWith(rel + "/"));
   return {
     of: (relPath) => {
-      const rel = relPath.replace(/\/+$/, "");
+      const rel = placeOf(relPath.replace(/\/+$/, ""));
       if (under(tracked, rel)) return under(dirty, rel) ? "changed" : "committed";
       return isIgnored(rel) ? "ignored" : "new";
     }
@@ -1323,24 +1697,17 @@ function relativeTo(root, path) {
 }
 
 // src/here.ts
-import { readdirSync as readdirSync7 } from "fs";
+import { readdirSync as readdirSync8 } from "fs";
 import { basename as basename7 } from "path";
 
 // src/health.ts
-import { lstatSync as lstatSync4 } from "fs";
-import { basename as basename6, dirname as dirname5 } from "path";
+import { existsSync as existsSync12, lstatSync as lstatSync4, readdirSync as readdirSync7 } from "fs";
+import { basename as basename6, dirname as dirname6, isAbsolute as isAbsolute3, join as join13, relative as relative4, sep as sep7 } from "path";
 
 // src/plugins.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join11, resolve as resolve6 } from "path";
-function readJson2(path) {
-  try {
-    return JSON.parse(readFileSync8(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join11, resolve as resolve7 } from "path";
 function nonEmptyDir(path) {
   try {
     return readdirSync5(path).some((f) => !f.startsWith("."));
@@ -1349,7 +1716,7 @@ function nonEmptyDir(path) {
   }
 }
 function extrasOf(root) {
-  const manifest = readJson2(join11(root, ".claude-plugin", "plugin.json")) ?? {};
+  const manifest = readJson(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"] : [],
@@ -1358,21 +1725,22 @@ function extrasOf(root) {
   ];
 }
 function claudePlugins(machine, root) {
-  const installed = readJson2(join11(claudeDir(), "plugins", "installed_plugins.json"))?.plugins ?? {};
+  const installed = installedPluginsJson();
   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 entries = installed[origin] ?? [];
     const entry = entries.find((e) => root && e.projectPath === root) ?? entries.find((e) => (e.scope ?? "user") === "user") ?? entries[0];
     return {
-      id,
+      id: origin,
       scope: synced ? null : entry?.scope ?? "user",
       ...entry?.projectPath ? { projectPath: entry.projectPath } : {},
       synced,
+      // Turned on in your settings with no install record (as installedPlugins finds it).
+      ...!synced && !entries.length ? { settingsOnly: true } : {},
       skills,
-      extras: extrasOf(dirname3(dirname3(skills[0])))
+      extras: extrasOf(dirname4(dirname4(skills[0])))
     };
   });
 }
@@ -1385,10 +1753,10 @@ function newer(a, b) {
 }
 function updateOf(name, marketplace, entry, catalogs) {
   const dir = join11(claudeDir(), "plugins", "marketplaces", marketplace);
-  if (!catalogs.has(marketplace)) catalogs.set(marketplace, readJson2(join11(dir, ".claude-plugin", "marketplace.json"))?.plugins ?? []);
+  if (!catalogs.has(marketplace)) catalogs.set(marketplace, readJson(join11(dir, ".claude-plugin", "marketplace.json"))?.plugins ?? []);
   const listed = catalogs.get(marketplace).find((p) => p.name === name);
   if (!listed) return void 0;
-  const version = listed.version ?? (typeof listed.source === "string" ? readJson2(join11(dir, listed.source, ".claude-plugin", "plugin.json"))?.version : void 0);
+  const version = listed.version ?? (typeof listed.source === "string" ? readJson(join11(dir, listed.source, ".claude-plugin", "plugin.json"))?.version : void 0);
   if (version && entry.version) return newer(version, entry.version) ? version : void 0;
   const sha = typeof listed.source === "object" ? listed.source?.sha : void 0;
   return sha && entry.gitCommitSha && sha !== entry.gitCommitSha ? "newer" : void 0;
@@ -1398,12 +1766,12 @@ function pluginRoot(id, entry) {
   return candidates.find((c) => existsSync10(join11(c, "skills"))) ?? candidates.find((c) => existsSync10(c)) ?? candidates[0];
 }
 function describe(root) {
-  const manifest = readJson2(join11(root, ".claude-plugin", "plugin.json")) ?? {};
+  const manifest = readJson(join11(root, ".claude-plugin", "plugin.json")) ?? {};
   return { description: manifest.description ?? "", version: manifest.version, skills: skillDirsIn(join11(root, "skills")), extras: extrasOf(root) };
 }
 function installedPlugins() {
   const plugins = join11(claudeDir(), "plugins");
-  const installed = readJson2(join11(plugins, "installed_plugins.json"))?.plugins ?? {};
+  const installed = installedPluginsJson();
   const catalogs = /* @__PURE__ */ new Map();
   const fromMarketplaces = Object.entries(installed).flatMap(
     ([id, entries]) => entries.map((entry) => {
@@ -1435,18 +1803,18 @@ function installedPlugins() {
   const syncedDir = join11(plugins, "synced");
   const dirs = (p) => existsSync10(p) ? readdirSync5(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => join11(p, d.name)) : [];
   const fromSynced = dirs(syncedDir).flatMap(dirs).map((root) => {
-    const id = `${readJson2(join11(root, ".claude-plugin", "plugin.json"))?.name ?? basename4(root)}@synced`;
+    const id = `${readJson(join11(root, ".claude-plugin", "plugin.json"))?.name ?? basename4(root)}@synced`;
     return { id, scope: null, synced: true, agent: "claude-code", on: user[id] !== false, root, ...describe(root) };
   });
   return [...fromMarketplaces, ...fromSettings, ...fromSynced];
 }
 function cursorPlugins() {
   const cache = join11(userHome(), ".cursor", "plugins", "cache");
-  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync3(join11(p, d)).isDirectory()) : [];
+  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync4(join11(p, d)).isDirectory()) : [];
   return dirs(cache).flatMap(
     (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
       const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
-      const root = versions.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
+      const root = versions.sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs)[0];
       if (!root) return [];
       const about = describe(root);
       return [{ id: `${plugin}@${marketplace}`, scope: null, synced: false, agent: "cursor", on: null, root, ...about, version: about.version ?? basename4(root) }];
@@ -1485,11 +1853,10 @@ function claude(args, cwd, bin = claudeBinary()) {
   }
 }
 function setPluginIn(file, id, on) {
-  const settings = existsSync10(file) ? readJson2(file) : {};
+  const settings = existsSync10(file) ? readJson(file) : {};
   if (!settings) return { ok: false, reason: `can't read ${file}` };
   const enabled = settings.enabledPlugins ?? {};
-  mkdirSync7(dirname3(file), { recursive: true });
-  writeFileSync7(file, JSON.stringify({ ...settings, enabledPlugins: { ...enabled, [id]: on } }, null, 2) + "\n");
+  writeState(file, { ...settings, enabledPlugins: { ...enabled, [id]: on } });
   return { ok: true };
 }
 function ignoreLocalSettings(root) {
@@ -1511,10 +1878,10 @@ function ignoreLocalSettings(root) {
   } catch {
   }
   try {
-    const exclude = resolve6(root, git2("rev-parse", "--git-path", "info/exclude"));
-    const before = existsSync10(exclude) ? readFileSync8(exclude, "utf-8") : "";
-    mkdirSync7(dirname3(exclude), { recursive: true });
-    writeFileSync7(exclude, `${before}${before && !before.endsWith("\n") ? "\n" : ""}/${git2("rev-parse", "--show-prefix")}${file}
+    const exclude = resolve7(root, git2("rev-parse", "--git-path", "info/exclude"));
+    const before = existsSync10(exclude) ? readFileSync6(exclude, "utf-8") : "";
+    mkdirSync6(dirname4(exclude), { recursive: true });
+    writeFileSync4(exclude, `${before}${before && !before.endsWith("\n") ? "\n" : ""}/${git2("rev-parse", "--show-prefix")}${file}
 `);
     return ", which git now ignores via .git/info/exclude";
   } catch {
@@ -1523,7 +1890,7 @@ function ignoreLocalSettings(root) {
 }
 function turnOffIn(plugin, root) {
   const done = `${plugin.id} turned off in ${basename4(root)}; other repos keep it`;
-  const bin = plugin.synced ? null : claudeBinary();
+  const bin = plugin.synced || plugin.settingsOnly ? null : claudeBinary();
   if (!bin) {
     const r2 = setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false);
     return r2.ok ? { ok: true, message: `${done} (in .claude/settings.local.json${ignoreLocalSettings(root)})` } : { ok: false, message: `${plugin.id}: ${r2.reason}` };
@@ -1540,7 +1907,8 @@ function whereOf(p) {
   return p.projectPath ? ` in ${basename4(p.projectPath)} (${p.scope})` : "";
 }
 function setPluginOn(p, on) {
-  const done = { ok: true, message: `${p.id} is ${on ? "on" : "off"}${whereOf(p)}${p.synced ? "" : "; Claude Code picks it up in its next session"}` };
+  const shared = p.scope === "project" && p.projectPath ? "; it's in .claude/settings.json, which git tracks, so commit it if the team should get it" : "";
+  const done = { ok: true, message: `${p.id} is ${on ? "on" : "off"}${whereOf(p)}${p.synced ? "" : "; Claude Code picks it up in its next session"}${shared}` };
   if (p.scope && p.scope !== "user" && !p.projectPath) return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin ${on ? "enable" : "disable"} ${p.id} --scope ${p.scope}\` there` };
   const bin = p.synced || p.settingsOnly ? null : claudeBinary();
   if (bin) {
@@ -1549,7 +1917,8 @@ function setPluginOn(p, on) {
   }
   const r = setPluginIn(settingsFileOf(p), p.id, on);
   if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}` };
-  return p.scope === "local" && p.projectPath ? { ...done, message: done.message + ignoreLocalSettings(p.projectPath) } : done;
+  if (p.scope === "local" && p.projectPath) return { ...done, message: done.message + ignoreLocalSettings(p.projectPath) };
+  return done;
 }
 function uninstallPlugin(p) {
   if (p.synced) return { ok: false, message: `${p.id} is synced from your claude.ai account: remove it there, or turn it off here` };
@@ -1579,35 +1948,44 @@ function removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
 }
 function removePlugin(plugin, how) {
+  if (plugin.settingsOnly && how === "delete") return { ok: false, message: `${plugin.id} isn't installed, only turned on in your settings: turn it off instead` };
   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()) {
+  const viaSettings = plugin.synced || plugin.settingsOnly || !claudeBinary() && how === "off" && !plugin.projectPath;
+  if (!viaSettings && !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 wasOn = enabledPlugins(plugin.projectPath)[plugin.id] === true;
+  const yours = new Set(machineSkills().filter((m) => m.movable).map((m) => m.name));
+  const imported = plugin.skills.filter((dir) => !yours.has(basename4(dir)) && latestVersion(basename4(dir)) === null).map((dir) => importSkill(dir).name);
   const scope = plugin.scope ? ["--scope", plugin.scope] : [];
-  const r = plugin.synced ? (
-    // Synced plugins aren't installed, so `claude plugin` can't touch them: their switch is enabledPlugins.
+  const r = viaSettings ? (
+    // Synced and settings-only plugins aren't installed, so `claude plugin` can't touch them: their switch is enabledPlugins.
     setPluginIn(join11(claudeDir(), "settings.json"), plugin.id, false)
-  ) : claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...scope], plugin.projectPath);
+  ) : (
+    // --keep-data, as uninstallPlugin: its saved data stays, so a restore brings it back as it was.
+    claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...how === "delete" ? ["--keep-data"] : [], ...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", plugin.projectPath, true);
-  return { ok: true, message: `${plugin.id} ${how === "delete" && !plugin.synced ? "removed" : "turned off"}${saved}` };
+  if (how === "delete" && !plugin.synced) recordRemovedPlugin(plugin.id, plugin.scope ?? "user", plugin.projectPath, wasOn);
+  const others = how === "delete" ? (installedPluginsJson()[plugin.id] ?? []).filter((e) => (e.scope ?? "user") !== (plugin.scope ?? "user") || e.projectPath !== plugin.projectPath) : [];
+  const left = others.length ? `; its ${others.map((e) => `${e.scope ?? "user"} install${e.projectPath ? ` in ${basename4(e.projectPath)}` : ""}`).join(", ")} stays` : "";
+  return { ok: true, message: `${plugin.id} ${how === "delete" && !plugin.synced ? `removed (${plugin.scope ?? "user"} install)` : "turned off"}${saved}${left}` };
 }
 function recordRemovedPlugin(id, scope, projectPath, on = true) {
-  const list2 = readJson2(removedFile()) ?? [];
-  mkdirSync7(skilllibHome(), { recursive: true });
-  writeFileSync7(removedFile(), JSON.stringify([...list2, { id, scope, ...projectPath ? { projectPath } : {}, on, at: (/* @__PURE__ */ new Date()).toISOString() }], null, 2) + "\n");
+  const list2 = readState(removedFile()) ?? [];
+  mkdirSync6(skilllibHome(), { recursive: true });
+  writeState(removedFile(), [...list2, { id, scope, ...projectPath ? { projectPath } : {}, on, at: (/* @__PURE__ */ new Date()).toISOString() }]);
 }
 function pluginBackups() {
-  return (readJson2(removedFile()) ?? []).map((r) => ({
+  return (readState(removedFile()) ?? []).map((r) => ({
     name: r.id,
     kind: "plugin",
     // Project and local installs go back into their project.
     path: r.projectPath ? `${r.scope}:${r.projectPath}` : r.scope,
-    movedAt: r.at.slice(0, 16).replace("T", " "),
+    movedAt: localStamp(Date.parse(r.at)),
     from: r.id
   }));
 }
@@ -1616,11 +1994,11 @@ function restorePlugin(backup) {
   const projectPath = rest.join(":") || void 0;
   const r = claude(["plugin", "install", backup.from, "--scope", scope], projectPath);
   if (!r.ok) return r;
-  const records = readJson2(removedFile()) ?? [];
+  const records = readState(removedFile()) ?? [];
   const same = (x) => x.id === backup.from && (x.projectPath ?? void 0) === projectPath && x.scope === scope;
   const wasOff = records.filter(same).pop()?.on === false;
   const off = wasOff ? claude(["plugin", "disable", backup.from, "--scope", scope], projectPath) : null;
-  writeFileSync7(removedFile(), JSON.stringify(records.filter((x) => !same(x)), null, 2) + "\n");
+  writeState(removedFile(), records.filter((x) => !same(x)));
   const where = `Claude Code plugins (${scope}${projectPath ? ` in ${basename4(projectPath)}` : ""}${wasOff ? off?.ok ? ", off as it was" : ", but it's on: turn it off from Plugins" : ""})`;
   return { ok: true, to: where };
 }
@@ -1629,14 +2007,14 @@ function cursorPluginSkills(plugins = cursorPlugins()) {
 }
 
 // src/tidy.ts
-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";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync6, unlinkSync as unlinkSync3 } from "fs";
+import { basename as basename5, dirname as dirname5, join as join12, sep as sep6 } 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 real = realpathOrNull(path);
     const skill = existsSync11(join12(path, "SKILL.md"));
     if (!link2 && !skill) return [];
     return [{ dir, path, link: link2, real, hash: null }];
@@ -1648,12 +2026,13 @@ function hashReals(reals) {
 function namesIn(dirs) {
   const names = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
-    if (!existsSync11(dir)) continue;
+    if (!isDir(dir)) continue;
     for (const name of readdirSync6(dir)) if (!name.startsWith(".") && name !== "synced") names.add(name);
   }
   return [...names].sort();
 }
 var PROJECT_TIDY_DIRS = ALL_PROJECT_DIRS.filter((d) => d !== GROK_SKILLS_DIR);
+var repoTidyDirs = (root) => PROJECT_TIDY_DIRS.filter((d) => notWritable(root, d) === null);
 function globalTidyDirs() {
   const own = realPath(join12(grokDir(), "skills"));
   return globalSkillDirs().filter((d) => realPath(d) !== own);
@@ -1661,7 +2040,7 @@ function globalTidyDirs() {
 function runsFrom(id, dirsWithCopy, readsOf) {
   const reads = readsOf(id).filter((d) => dirsWithCopy.includes(d));
   if (id === "codex") return reads;
-  const pick = (d) => CURSOR_PICKS.indexOf(basename5(dirname4(d)));
+  const pick = (d) => CURSOR_PICKS.indexOf(basename5(dirname5(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) {
@@ -1677,17 +2056,19 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   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);
+  const readsOf = (id) => harness(id).projectDirs.map(abs);
   let git2;
   const skillsLock = projectSkillsLock(root);
-  for (const name of namesIn(PROJECT_TIDY_DIRS.map(abs))) {
-    const entries = entriesOf(PROJECT_TIDY_DIRS.map(abs), name);
-    const external = entries.find((e) => e.link && e.real && !(e.real + sep4).startsWith(realpathOrNull2(root) + sep4));
+  const dirs = repoTidyDirs(root).map(abs);
+  for (const name of namesIn(dirs)) {
+    const entries = entriesOf(dirs, name);
+    const external = entries.find((e) => e.link && e.real && !(e.real + sep6).startsWith(realpathOrNull(root) + sep6));
     if (external) {
-      report.skipped.push({ name, reason: `${rel(external.path)} links outside the repo` });
+      const differs = entries.some((e) => e !== external && e.real && existsSync11(join12(e.real, "SKILL.md")) && treeHash(e.real) !== treeHash(external.real));
+      report.skipped.push({ name, reason: `${rel(external.path)} links outside the repo`, ...differs ? { differs } : {} });
       continue;
     }
-    const reals = entries.filter((e) => !e.link);
+    const reals = entries.filter((e, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull(o.path) === realpathOrNull(e.path)) === i);
     if (reals.length === 0) continue;
     hashReals(reals);
     const dep = skills[name];
@@ -1710,17 +2091,24 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
       report.conflicts.push({ ...conflictOf(name, root, reals, enabled, readsOf), ...dep ? { managed: primary.dir } : {} });
       continue;
     }
+    const elsewhere = entries.find((e) => e.link && e.real && e.real !== primary.real && existsSync11(join12(e.real, "SKILL.md")) && treeHash(e.real) !== treeHash(primary.path));
+    if (elsewhere) {
+      report.skipped.push({ name, reason: `${rel(elsewhere.path)} links to a different copy`, differs: true });
+      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;
+      if (e === primary || !e.link && e.real === primary.real) continue;
       const needed = wanted.has(e.dir);
       if (e.link) {
         if (e.real === primary.real) {
+          if (!needed && !dep && ["committed", "changed"].includes((git2 ??= gitInfo(root))?.of(rel(e.path)) ?? "")) continue;
           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 {
         const differs = e.hash !== primary.hash ? { differs: true } : {};
+        if (!needed && ["committed", "changed"].includes((git2 ??= gitInfo(root))?.of(rel(e.path)) ?? "")) continue;
         steps.push(needed ? { kind: "replace", path: e.path, target: primary.path, ...differs } : { kind: "remove", path: e.path, ...differs });
       }
     }
@@ -1729,7 +2117,7 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   return report;
 }
 function globalReadsOf(id) {
-  return HARNESSES.find((h) => h.id === id).globalDirs().map(globalDirAs);
+  return harness(id).globalDirs().map(globalDirAs);
 }
 function isSkillsDirPlugin(path) {
   return existsSync11(join12(path, ".claude-plugin", "plugin.json"));
@@ -1744,7 +2132,7 @@ function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
       report.skipped.push({ name, reason: "a Claude Code plugin kept in a skills folder" });
       continue;
     }
-    const reals = entries.filter((e, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull2(o.path) === realpathOrNull2(e.path)) === i);
+    const reals = entries.filter((e, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull(o.path) === realpathOrNull(e.path)) === i);
     if (reals.length < 2) continue;
     hashReals(reals);
     const kept = reals.find((r) => r.dir === keep[name]);
@@ -1760,21 +2148,22 @@ function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
 }
 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";
-  });
+  const shared = (rel) => ["committed", "changed"].includes(git2.of(rel));
+  const dep = readManifest(plan.root).skills[plan.name];
+  const recordsLink = (s) => !!dep && (s.kind === "link" || s.kind === "replace") && !dep.links?.includes(relativeTo(plan.root, dirname5(s.path)));
+  return plan.steps.filter((s) => shared(relativeTo(plan.root, s.path)) || recordsLink(s) && shared(MANIFEST_FILE));
 }
 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 ("target" in step && realpathOrNull(step.path) === realpathOrNull(step.target)) continue;
     if (step.kind === "link" || step.kind === "unlink") {
       if (isLink(step.path)) unlinkSync3(step.path);
     } else stash(step.path, "tidy-backup");
     if (step.kind === "link" || step.kind === "replace") {
-      mkdirSync8(dirname4(step.path), { recursive: true });
+      mkdirSync7(dirname5(step.path), { recursive: true });
       linkDir(step.target, step.path);
     }
     applied.push(step);
@@ -1782,7 +2171,7 @@ function applyTidy(plan, { git: git2 = "keep", info: info2 } = {}) {
   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)));
+    const added = applied.filter((s) => s.kind === "link" || s.kind === "replace").map((s) => relativeTo(plan.root, dirname5(s.path)));
     if (dep && added.length) {
       manifest.skills[plan.name] = { ...dep, links: [.../* @__PURE__ */ new Set([...dep.links ?? [], ...added])] };
       writeManifest(plan.root, manifest);
@@ -1803,18 +2192,19 @@ function describeStep(step, root) {
       return `remove ${step.differs ? "differing" : "duplicate"} copy ${shown}`;
   }
 }
-function copyLabel(conflict, dir) {
-  return folderLabel(conflict.root, dir);
-}
 function folderLabel(root, dir) {
   return root ? relativeTo(root, dir) : tildify(dir);
 }
 function foldersOf(root, name) {
-  const entries = entriesOf(root ? PROJECT_TIDY_DIRS.map((d) => join12(root, d)) : globalTidyDirs(), name);
+  const entries = entriesOf(root ? repoTidyDirs(root).map((d) => join12(root, d)) : globalTidyDirs(), name);
   return { all: entries.map((e) => e.dir), real: entries.filter((e) => !e.link).map((e) => e.dir) };
 }
 
 // src/health.ts
+function detailWithGit(issue) {
+  const notes = [...issue.fix ? [issue.fix] : [], ...issue.choices ?? []].filter((c) => c.hint && /\bgit\b|committed/.test(c.hint)).map((c) => `"${c.label}": ${c.hint}.`);
+  return notes.length ? `${issue.detail} ${notes.join(" ")}` : issue.detail;
+}
 function runFix(choice) {
   try {
     return { ok: true, message: choice.run() };
@@ -1826,50 +2216,193 @@ function orThrow(r) {
   if (!r.ok) throw new Error(r.message);
   return r.message;
 }
+function intoLibrary(path, force = false) {
+  const r = importSkill(path, { force });
+  if (r.status === "exists") throw new Error(`${r.name}: your library has a different ${r.name}; update or delete it first`);
+  return r.name;
+}
+function track(root, name) {
+  const c = addSkill(root, name);
+  if (c.action === "skipped") throw new Error(`${name}: ${c.reason}`);
+  return c;
+}
+var installedIn = (p) => p.projectPath ? ` in ${basename6(p.projectPath)}` : "";
+var installId = (p) => `${p.projectPath ? `${p.projectPath}:` : ""}${p.id}`;
+function summarize(where, verb, changes) {
+  const done = changes.filter((c) => c.action !== "skipped");
+  const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
+  if (!done.length) throw new Error(`${where}: nothing ${verb}${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
+  return `${where}: ${verb} ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
+}
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
-var agentNames = (ids) => ids.map((id) => HARNESSES.find((h) => h.id === id).name).join(", ");
+var rows = (root, skills) => skills.map((skill) => ({ root, skill }));
+var removesClean = (root, s) => s.managed && !s.state.startsWith("edited") && s.state !== "not in library" && !syncBlocker(root, s.name);
+var gitMemo = /* @__PURE__ */ new Map();
+var gitOf = (root) => {
+  if (!gitMemo.has(root)) gitMemo.set(root, gitInfo(root));
+  return gitMemo.get(root);
+};
+var gitNote = (root, paths) => {
+  const git2 = gitOf(root);
+  return paths.some((p) => ["committed", "changed"].includes(git2?.of(relativeTo(root, p)) ?? "")) ? "; git will see it" : "";
+};
+var agentNames = (ids) => ids.map((id) => harness(id).name).join(", ");
 function conflictIssue(c) {
   const where = c.root ? basename6(c.root) : "your global folders";
   const winners = c.managed ? c.copies.filter((x) => x.dir === c.managed) : c.copies;
+  const planFor = (dir) => (c.root ? planProjectTidy(c.root, { keep: { [c.name]: dir } }) : planGlobalTidy({ keep: { [c.name]: dir } })).plans.find((p) => p.name === c.name);
+  const keep = (dir, git2) => () => {
+    const plan = planFor(dir);
+    const r = plan ? applyTidy(plan, { git: git2 }) : null;
+    if (!r?.applied.length) throw new Error(`${c.name}: nothing changed${r?.held.length ? " (git would see every change)" : ""}`);
+    return `${c.name}: kept the ${folderLabel(c.root, dir)} copy${r.held.length ? `; held back ${plural(r.held.length, "change")} git would see` : ""}`;
+  };
   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`;
-      }
-    }))
+    detail: `Your agents run different versions: ${c.copies.map((x) => `${folderLabel(c.root, x.dir)}${x.runs.length ? ` (${agentNames(x.runs)})` : ""}`).join(" vs ")}. Keep one; the others become links to it and are restorable with skilllib restore (Settings \u203A Backups in the app).`,
+    at: rows(c.root, [c.name]),
+    choices: winners.flatMap((x) => {
+      const plan = planFor(x.dir);
+      const visible2 = plan ? gitVisibleSteps(plan).map((s) => describeStep(s, c.root)) : [];
+      const label = `Keep the ${folderLabel(c.root, x.dir)} copy`;
+      if (!visible2.length) return [{ label, hint: x.dir === c.managed ? "skilllib's version" : "the others become links to it", run: keep(x.dir, "go") }];
+      return [
+        // "Keep git as it is" only when it leaves something to do.
+        ...visible2.length < (plan?.steps.length ?? 0) ? [{ label: `${label}, but keep git as it is`, hint: `skips what git would see: ${visible2.join(", ")}`, run: keep(x.dir, "keep") }] : [],
+        { label: `${label}, and change what git tracks`, hint: `git will see: ${visible2.join(", ")}`, run: keep(x.dir, "go") }
+      ];
+    })
   };
 }
 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, loadedIn = (root) => skillsLoadedIn(root, machine), nestedOf = nestedSkills) {
-  const issues = [];
+function brokenLinksIn(root, opened) {
+  const where = basename6(root);
+  const tidyDirs = repoTidyDirs(root);
+  const hasCopy = (name) => tidyDirs.some((d) => !isLink(join13(root, d, name)) && existsSync12(join13(root, d, name, "SKILL.md")));
+  const mends = (project, dir, name) => {
+    const dep = pinsIn(project)[name];
+    return !!dep && (dep.links ?? []).includes(dir) && !syncBlocker(project, name, dep) && versionForHash(name, dep.hash) !== null;
+  };
+  const syncMends = (dir, name) => mends(root, dir, name);
+  let git2;
+  const realRoot = realNative(root) ?? root;
+  const ownerOf = (real) => {
+    let nearest = null;
+    for (let d = dirname6(dirname6(real)); d.startsWith(realRoot + sep7); d = dirname6(d)) {
+      if (!existsSync12(join13(d, MANIFEST_FILE))) continue;
+      if (opened.has(d)) return { opened: true, own: d };
+      nearest ??= d;
+    }
+    return { opened: false, own: nearest };
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const aliased = (dir) => (realNative(join13(root, dir)) ?? "") !== join13(realRoot, dir);
+  const packageFolders = packageSkillFolders(root).map((f) => ({ dir: f.location, top: false })).sort((a, b) => Number(aliased(a.dir)) - Number(aliased(b.dir)));
+  const folders2 = [...ALL_PROJECT_DIRS.map((dir) => ({ dir, top: true })), ...packageFolders].flatMap(({ dir, top }) => {
+    const real = realNative(join13(root, dir)) ?? join13(root, dir);
+    if (seen.has(real)) return [];
+    seen.add(real);
+    const owner = ownerOf(real);
+    return owner.opened ? [] : [{ dir, top: top && !owner.own, own: owner.own, real }];
+  });
+  return folders2.flatMap(({ dir, top, own, real }) => {
+    const folder = join13(root, dir);
+    if (!isDir(folder) || notWritable(root, dir)) return [];
+    return readdirSync7(folder).flatMap((name) => {
+      const path = join13(folder, name);
+      if (!isLink(path) || isDir(path) || top && (dir !== GROK_SKILLS_DIR && hasCopy(name) || syncMends(dir, name))) return [];
+      const remove2 = {
+        label: "Remove the link",
+        hint: "restorable with skilllib restore",
+        run: () => {
+          if (!isLink(path)) return `${dir}/${name} in ${where} is already gone`;
+          stash(path, "tidy-backup");
+          return `Removed the broken link ${dir}/${name} in ${where} (restorable with skilllib restore)`;
+        }
+      };
+      const placeOf = (p) => relative4(realRoot, p).split(sep7).join("/");
+      git2 ??= gitInfo(
+        root,
+        folders2.map((f) => placeOf(f.real)).filter((p) => p !== "" && p !== ".." && !p.startsWith("../") && !isAbsolute3(p))
+      );
+      const tracked = ["committed", "changed"].includes(git2?.of(placeOf(join13(real, name))) ?? "");
+      const recorded = !!own && mends(own, relative4(own, real).split(sep7).join("/"), name);
+      const pinnedThere = own ? ` ${placeOf(own)} has its own skilllib.json${recorded ? `, which records this link: skilllib sync in ${placeOf(own)} brings back what it points to` : ""}.` : "";
+      return [
+        {
+          id: `broken:${root}:${dir}/${name}`,
+          severity: "problem",
+          title: `${name}: broken link in ${where}/${dir}`,
+          detail: `It points at ${existsSync12(path) ? "a file, not a skill folder" : "a folder that no longer exists"}, so it loads nothing.${tracked ? " Git tracks the link, so removing it shows in git status." : ""}${pinnedThere}`,
+          at: rows(root, [name]),
+          // Removed by itself only at the repo's top, uncommitted: a package's link (or a committed one) is asked first.
+          ...top && !tracked ? { fix: remove2 } : { choices: [remove2] }
+        }
+      ];
+    });
+  });
+}
+function grokDiffers(projects2, machine, statusOf) {
+  if (!enabledHarnesses().includes("grok")) return [];
+  const issue = (root, name, grokCopy, other) => ({
+    id: `grok-differs:${root ?? "global"}:${name}`,
+    severity: "suggestion",
+    title: `${name}${root ? ` in ${basename6(root)}` : ""}: Grok runs a different copy`,
+    detail: `Grok reads ${grokCopy} first; your other agents run ${other}, and the two differ. skilllib doesn't change Grok's folder: update or remove that copy there to make them match.`,
+    at: rows(root, [name])
+  });
+  const grokGlobal = join13(grokDir(), "skills");
+  const global = skillDirsIn(grokGlobal).filter((path) => !isLink(path)).flatMap((path) => {
+    const name = basename6(path);
+    const other = machine.find((m) => m.name === name && m.movable && !m.broken && m.harnesses.some((id) => id !== "grok") && realPath(dirname6(m.path)) !== realPath(grokGlobal));
+    return other && treeHash(other.path) !== treeHash(path) ? [issue(null, name, tildify(path), tildify(other.path))] : [];
+  });
+  const repos = projects2.flatMap(
+    (root) => skillDirsIn(join13(root, GROK_SKILLS_DIR)).filter((path) => !isLink(path)).flatMap((path) => {
+      const name = basename6(path);
+      const other = statusOf(root).find((s) => s.name === name && !s.path.startsWith(join13(root, GROK_SKILLS_DIR)));
+      return other && treeHash(other.path) !== treeHash(path) ? [issue(root, name, `${GROK_SKILLS_DIR}/${name}`, relativeTo(root, other.path))] : [];
+    })
+  );
+  return [...global, ...repos];
+}
+function findIssues(roots, machine, libraryNames, statusOf = projectStatus, loadedIn = (root) => skillsLoadedIn(root, machine), nestedOf = nestedSkills) {
+  gitMemo = /* @__PURE__ */ new Map();
+  const { readable: projects2, unreadable } = readableRoots(roots);
+  const issues = unreadable.map(({ root, reason }) => ({
+    id: `manifest:${root}`,
+    severity: "problem",
+    title: `${basename6(root)}: skilllib.json can't be read`,
+    detail: `${reason}. Until it's fixed, skilllib leaves ${basename6(root)} out.`,
+    at: [{ root, skill: "" }]
+  }));
   const statuses = new Map(projects2.map((root) => [root, statusOf(root)]));
+  const openedProjects = new Set(projects2.map((p) => realNative(p) ?? p));
+  issues.push(...grokDiffers(projects2, machine, (root) => statuses.get(root)));
   const nested = new Map(projects2.map((root) => [root, nestedOf(root)]));
   for (const skill of machine.filter((m) => m.broken)) {
+    const reaches = isDir(skill.path) ? "folder" : existsSync12(skill.path) ? "file" : "nothing";
+    const remove2 = {
+      label: "Remove the link",
+      hint: "restorable with skilllib restore",
+      run: () => {
+        const r = unloadGlobal(skill.path);
+        if (!r.ok) throw new Error(`${skill.name}: ${r.reason}`);
+        return `Removed broken link ${skill.name}`;
+      }
+    };
     issues.push({
-      id: `broken:${skill.name}`,
+      id: `broken:${skill.path}`,
       severity: "problem",
-      title: `${skill.name}: broken link in ${tildify(dirname5(skill.path))}`,
-      detail: "It points at a folder that no longer exists, so it loads nothing.",
-      fix: {
-        label: "Remove the link",
-        run: () => {
-          const r = unloadGlobal(skill.path);
-          if (!r.ok) throw new Error(`${skill.name}: ${r.reason}`);
-          return `Removed broken link ${skill.name}`;
-        }
-      }
+      title: `${skill.name}: broken link in ${tildify(dirname6(skill.path))}`,
+      detail: reaches === "nothing" ? "It points at a folder that no longer exists, so it loads nothing." : reaches === "file" ? "It points at a file, not a skill folder, so it loads nothing." : "It points at a folder with no SKILL.md: most agents load nothing from it (Cursor may find skills deeper inside).",
+      at: rows(null, [skill.name]),
+      ...reaches === "folder" ? { choices: [remove2] } : { fix: remove2 }
     });
   }
   const loaded = machine.filter((m) => !m.broken);
@@ -1884,7 +2417,8 @@ 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)" : ""}${vendor.some((c) => c.kind === "system") ? ` (whoever manages ${vendor.find((c) => c.kind === "system").origin})` : ""}.`
+      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})` : ""}.`,
+      at: rows(null, [name])
     });
   }
   const loadedHere = new Map(projects2.map((root) => [root, loadedIn(root)]));
@@ -1893,18 +2427,21 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   ];
   const pluginAgentsIn = (plugin, root) => new Set(loadedHere.get(root).filter((m) => plugin.skills.includes(m.path)).flatMap((m) => m.harnesses));
   const globalYours = new Set(loaded.filter((m) => m.movable).map((m) => m.name));
-  const installedYours = /* @__PURE__ */ new Set([...globalYours, ...[...statuses.values()].flat().map((s) => s.name)]);
+  const installedYours = /* @__PURE__ */ new Set([...globalYours, ...[...statuses.values()].flat().map((s) => s.name), ...knownProjects().flatMap((p) => Object.keys(pinsIn(p)))]);
   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));
+    const allManaged = names.every((n) => copies.some((c) => c.name === n && removesClean(root, c)));
+    const committed = gitNote(root, copies.map((s) => s.path)) !== "";
+    const pluginAgents = pluginAgentsIn(plugin, root);
+    const leftOut = copies.flatMap((s) => s.visibility.filter((v) => v.paths > 0 && !pluginAgents.has(v.id)).map((v) => v.id));
     return [
       { label: `Turn the plugin ${plugin.id} off in ${where} only`, hint: "other repos keep it; in .claude/settings.local.json, a local-only file", run: () => orThrow(turnOffIn(plugin, root)) },
       // Only copies skilllib installed: Your skills keeps them. A repo's own skill is the team's, never removed from here.
-      ...names.length && allManaged ? [
+      ...names.length && allManaged && !committed && !leftOut.length ? [
         {
           label: `Remove your ${copies.map((s) => s.name).join(", ")} from ${where}`,
-          hint: "the plugin's copy stays; Your skills keeps yours",
+          hint: `the plugin's copy stays; Your skills keeps yours${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
           run: () => {
             for (const s of copies) {
               const r = removeSkill(root, s.name);
@@ -1929,7 +2466,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     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",
+      hint: plugin.extras.length ? `also removes its ${plugin.extras.join(", ")}` : "restorable with skilllib restore",
       run: () => orThrow(removePlugin(plugin, "delete"))
     };
     const off = { label: `Turn the plugin ${plugin.id} off`, hint: "stays installed", run: () => orThrow(removePlugin(plugin, "off")) };
@@ -1945,19 +2482,36 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         claudeBoth.length ? `Claude Code loads both (the plugin's as /${pluginName}:${claudeBoth[0]}). Your skill wins.` : "",
         cursorWheres.length ? `${cursorWheres.join(", ")} ${cursorWheres.length === 1 ? "turns" : "turn"} it off for Claude Code, but Cursor ignores repo settings and lists both there: only turning the plugin off or removing it changes that.` : "",
         notInstalled.length ? `Your ${notInstalled.join(", ")} ${notInstalled.length === 1 ? "is" : "are"} only in Your skills, not installed anywhere: once the plugin is gone, add ${notInstalled.length === 1 ? "it" : "them"} where you need ${notInstalled.length === 1 ? "it" : "them"}.` : "",
-        others ? `The plugin's other ${others === 1 ? "skill is" : `${others} skills are`} copied into Your skills first, so nothing is lost.` : "",
-        plugin.extras.length ? `It also brings ${plugin.extras.join(", ")}: ${plugin.synced ? "turning it off pauses those" : "removing it drops those, turning it off pauses them"}.` : "",
+        others ? `Turning it off or removing it copies its other ${others === 1 ? "skill" : `${others} skills`} into Your skills first, so nothing is lost.` : "",
+        plugin.extras.length ? `It also brings ${plugin.extras.join(", ")}: ${plugin.synced || plugin.settingsOnly ? "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.settingsOnly ? "It's only turned on in your settings, not installed, 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], ...inRepos.flatMap(([root, d]) => repoChoices(plugin, root, d))]
+      choices: [...plugin.synced || plugin.settingsOnly ? [off] : plugin.extras.length ? [off, remove2] : [remove2, off], ...inRepos.flatMap(([root, d]) => repoChoices(plugin, root, d))],
+      // Global's rows (yours and the plugin's), and the repos where both load.
+      at: [...rows(null, dupes), ...[...inRepos, ...cursorRepos].flatMap(([root, d]) => rows(root, d))],
+      plugin: plugin.id
     });
   }
+  if (enabledHarnesses().includes("claude-code"))
+    for (const p of installedPlugins().filter((x) => x.update && !x.synced && !x.settingsOnly)) {
+      const update2 = { label: p.update === "newer" ? "Update it" : `Update to ${p.update}`, hint: `runs claude plugin update ${p.id}`, run: () => orThrow(updatePlugin(p)) };
+      issues.push({
+        id: `plugin-update:${installId(p)}`,
+        severity: "suggestion",
+        title: `${p.id}${installedIn(p)}: ${p.update === "newer" ? "its marketplace has a newer commit" : `update available (${p.version ?? "?"} \u2192 ${p.update})`}`,
+        detail: "Updates can bring new commands, hooks or MCP servers. If the marketplace asks to run a command, skilllib stops and you update it yourself. Claude Code uses the new version after a restart.",
+        choices: [update2],
+        plugin: p.id,
+        pluginAt: p.projectPath ?? null
+      });
+    }
   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)) {
+    for (const plugin of enabledHarnesses().includes("claude-code") ? 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));
@@ -1967,7 +2521,9 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         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)
+        choices: repoChoices(plugin, root, inRepo),
+        at: rows(root, dupes),
+        plugin: plugin.id
       });
     }
   }
@@ -1979,7 +2535,9 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         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).`
+        detail: `Cursor lists both copies when that plugin is on. Your skill wins: turn the plugin off in Cursor (Settings \u2192 Plugins).`,
+        at: [...rows(null, names.filter((n) => globalYours.has(n))), ...projects2.flatMap((root) => rows(root, names.filter((n) => statuses.get(root).some((s) => s.name === n))))],
+        plugin
       });
     }
   }
@@ -1989,7 +2547,8 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       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.`,
+      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 with skilllib restore.`,
+      at: rows(null, global.plans.map((p) => p.name)),
       fix: {
         label: "Keep one copy of each",
         run: () => {
@@ -2002,13 +2561,14 @@ 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))];
+  const unreviewed = [...new Set(loaded.filter((m) => m.movable && m.harnesses.length && !kept.has(m.name)).map((m) => m.name))];
   if (unreviewed.length) {
     issues.push({
       id: "review:global",
       severity: "suggestion",
       title: `${plural(unreviewed.length, "global skill")} of yours ${unreviewed.length === 1 ? "loads" : "load"} in every repo`,
-      detail: `${unreviewed.join(", ")}. Move each to the repos that need it (skilllib global move <name> --to <repo>...), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
+      detail: `${unreviewed.join(", ")}. Move each to the repos that need it (skilllib global move <name> --to <repo>...), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`,
+      at: rows(null, unreviewed)
     });
   }
   const enabled = enabledHarnesses();
@@ -2035,6 +2595,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       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 global move), which works for every agent too.`}`,
+      at: rows(null, [...new Set(skills.map((m) => m.name))]),
       ...onPurpose ? { fix: link2 } : { choices: [link2] }
     });
   }
@@ -2044,31 +2605,77 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   for (const root of projects2) {
     const where = basename6(root);
     const status2 = statuses.get(root);
-    const restorable = status2.filter((s) => s.state === "folder missing" && s.latest !== null);
+    issues.push(...brokenLinksIn(root, openedProjects));
+    const pins = readManifest(root).skills;
+    const blockedFor = /* @__PURE__ */ new Map();
+    const untrackable = (s) => {
+      if (!blockedFor.has(s.name)) blockedFor.set(s.name, trackBlocker(root, s.name));
+      return blockedFor.get(s.name);
+    };
+    const blockers = new Map(status2.filter((s) => s.managed).flatMap((s) => ((b) => b ? [[s.name, b]] : [])(syncBlocker(root, s.name, pins[s.name]))));
+    for (const [name, blocker] of blockers)
+      issues.push({
+        id: `stuck:${root}:${name}`,
+        severity: "problem",
+        title: `${name} in ${where}: sync can't put it back as skilllib.json pins it`,
+        // What to do depends on what's there: a folder that links out of the repo is a setup of yours, and a pin
+        // your library has no version of can't come back by sync anyway.
+        detail: `${blocker.said}, so sync can't put it back there.${blocker.outside ? " skilllib only installs inside the repo: point that folder back into the repo, or remove the skill here (skilllib remove)." : versionForHash(name, pins[name]?.hash ?? "") !== null ? " Move it out of the way, then run skilllib sync." : " Move it out of the way; your library has no copy of the pinned version either."}`,
+        at: rows(root, [name])
+      });
+    const unstuck = status2.filter((s) => !blockers.has(s.name));
+    const missing = unstuck.filter((s) => s.state === "folder missing" && s.latest !== null);
+    const knownPin = (s) => versionForHash(s.name, pins[s.name]?.hash ?? "") !== null;
+    const restorable = missing.filter(knownPin);
+    for (const s of unstuck.filter((m) => (m.state === "folder missing" || m.state === "out of sync") && m.latest !== null && !knownPin(m)))
+      issues.push({
+        id: `pin:${root}:${s.name}`,
+        severity: "problem",
+        title: `${s.name}: the version ${where}'s skilllib.json pins isn't in your library`,
+        detail: `${s.state === "folder missing" ? "The folder is missing, and no" : "The copy is another version, and no"} version in Your skills has the content it pins (pinned from another library?). ${untrackable(s) ? `${untrackable(s)}, so skilllib can't install it here.` : `Install your newest v${s.latest}; ${where}'s skilllib.json then pins it.`}`,
+        at: rows(root, [s.name]),
+        // It changes what the shared skilllib.json pins: a choice, never run by `doctor --fix`.
+        ...untrackable(s) ? {} : { choices: [{ label: `Install your newest (v${s.latest})`, hint: `${where}'s skilllib.json pins it`, run: () => `${s.name}: installed v${track(root, s.name).to}` }] }
+      });
     if (restorable.length > 0) {
       issues.push({
         id: `sync:${root}`,
         severity: "problem",
         title: `${where}: ${plural(restorable.length, "skill")} in skilllib.json not installed`,
         detail: `${restorable.map((s) => s.name).join(", ")}: the folder is missing`,
+        at: rows(root, restorable.map((s) => s.name)),
         fix: {
           label: "Sync the project",
-          run: () => {
-            const changes = syncProject(root);
-            const done = changes.filter((c) => c.action !== "skipped");
-            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
-            if (!done.length) throw new Error(`${where}: nothing restored${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
-            return `${where}: restored ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
-          }
+          // Only the missing folders: an out-of-sync copy (maybe committed) is its own issue's choice.
+          run: () => summarize(where, "restored", syncProject(root, { names: restorable.map((s) => s.name) }))
         }
       });
     }
-    for (const s of status2.filter((s2) => s2.state === "folder missing" && s2.latest === null))
+    const drifted = unstuck.filter((s) => s.state === "out of sync" && knownPin(s));
+    if (drifted.length) {
+      const seen = drifted.some((s) => ["committed", "changed"].includes(gitOf(root)?.of(relativeTo(root, s.path)) ?? ""));
+      const yours = drifted.some((s) => untrackable(s));
+      const install = {
+        label: "Install the pinned versions",
+        hint: seen ? "git will see the copies change" : "your library keeps every version",
+        run: () => summarize(where, "synced", syncProject(root, { names: drifted.map((s) => s.name) }))
+      };
+      issues.push({
+        id: `out-of-sync:${root}`,
+        severity: "suggestion",
+        title: `${where}: ${plural(drifted.length, "skill")} not at the version skilllib.json pins`,
+        detail: `${drifted.map((s) => s.name).join(", ")}: each copy is another version from your library. sync installs the pinned one.${yours ? ` ${[...new Set(drifted.flatMap((s) => untrackable(s) ? [untrackable(s)] : []))].map((why) => `${drifted.filter((s) => untrackable(s) === why).map((s) => s.name).join(", ")}: ${why}`).join("; ")}, so skilllib can't pin the version that's there; ${drifted.filter((s) => untrackable(s)).length === 1 ? "it may be edits you copied into Your skills on purpose, and stays" : "they may be edits you copied into Your skills on purpose, and stay"} unless you choose this.` : ""}`,
+        at: rows(root, drifted.map((s) => s.name)),
+        ...seen || yours ? { choices: [install] } : { fix: install }
+      });
+    }
+    for (const s of unstuck.filter((s2) => s2.state === "folder missing" && s2.latest === null))
       issues.push({
         id: `unavailable:${root}:${s.name}`,
         severity: "problem",
         title: `${s.name}: pinned in ${where}'s skilllib.json, but not in your library`,
-        detail: `Its folder is missing, and your library (${tildify(libraryDir())}) has no copy to restore: import it, or set SKILLLIB_HOME to the library that has it.`,
+        detail: `Its folder is missing, and your library (${tildify(libraryDir())}) has no copy to restore: import it, or set SKILLLIB_HOME to the skilllib folder whose library has it.`,
+        at: rows(root, [s.name]),
         // Editing skilllib.json is the team's call: a choice, never run by `doctor --fix`.
         choices: [
           {
@@ -2082,27 +2689,26 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
           }
         ]
       });
-    const behind = status2.filter((s) => s.state === "update available");
+    const behind = unstuck.filter((s) => s.state === "update available" && !untrackable(s));
     if (behind.length > 0)
       issues.push({
         id: `update:${root}`,
         severity: "suggestion",
         title: `${where}: ${plural(behind.length, "skill")} out of date`,
         detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
-        fix: {
-          label: "Update to the newest versions",
-          run: () => {
-            const changes = updateProject(root, behind.map((s) => s.name));
-            const done = changes.filter((c) => c.action !== "skipped");
-            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
-            if (!done.length) throw new Error(`${where}: nothing updated${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
-            return `${where}: updated ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
+        at: rows(root, behind.map((s) => s.name)),
+        // It changes what the repo pins and the copies its agents load (often committed): a choice, never `doctor --fix`.
+        choices: [
+          {
+            label: "Update to the newest versions",
+            hint: ["committed", "changed"].includes(gitOf(root)?.of(MANIFEST_FILE) ?? "") ? "git will see the new copies and skilllib.json" : "replaces each copy with your library's newest",
+            run: () => summarize(where, "updated", updateProject(root, behind.map((s) => s.name)))
           }
-        }
+        ]
       });
     const tidy2 = planProjectTidy(root);
     if (tidy2.plans.length) {
-      const git3 = gitInfo(root);
+      const git3 = gitOf(root);
       const visible2 = tidy2.plans.flatMap((p) => gitVisibleSteps(p, git3).map((s) => describeStep(s, root)));
       const run = (mode) => () => {
         const r = applyAll(tidy2.plans, mode);
@@ -2113,41 +2719,90 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         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."),
+        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(", ")}.` : tidy2.plans.some((p) => p.steps.some((s) => s.kind === "replace" || s.kind === "remove")) ? ". Replaced copies are restorable with skilllib restore." : "."),
+        at: rows(root, tidy2.plans.map((p) => p.name)),
         ...visible2.length ? {
           choices: [
-            { label: "Tidy, but keep git as it is", hint: `skips the ${plural(visible2.length, "change")} git would see`, run: run("keep") },
+            // "Keep git as it is" only when it leaves something to do.
+            ...visible2.length < tidy2.plans.reduce((n, p) => n + p.steps.length, 0) ? [{ 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 blindHere = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0)).map((s) => ({ s, would: linkEverywhere(root, s.name, s.location, { dryRun: true }) }));
+    for (const s of tidy2.skipped.filter((x) => x.differs))
+      issues.push({
+        id: `linkdiffers:${root}:${s.name}`,
+        severity: "problem",
+        title: `${s.name} in ${where}: the copies differ`,
+        detail: `${s.reason}, with other content than the copy beside it: your agents run different versions. Make them the same, or remove the link; skilllib doesn't change a link to another copy.`,
+        at: rows(root, [s.name])
+      });
+    const loadsGlobally = (name, id) => {
+      const here = status2.find((s) => s.name === name);
+      return globalCopies.some((m) => m.name === name && m.harnesses.includes(id) && (!here || treeHash(m.path) === treeHash(here.path)));
+    };
+    const blindHere = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0 && !loadsGlobally(s.name, v.id))).map((s) => ({ s, would: linkEverywhere(root, s.name, s.location, { dryRun: true }) }));
+    const enabledIds = enabledHarnesses();
+    const notFolders = /* @__PURE__ */ new Set();
+    for (const dir of new Set(enabledIds.map((id) => harness(id).projectDirs[0]))) {
+      const blocker = notWritable(root, dir);
+      if (!blocker || notFolders.has(blocker)) continue;
+      notFolders.add(blocker);
+      const who = agentNames(enabledIds.filter((id) => notWritable(root, harness(id).projectDirs[0]) === blocker));
+      const out2 = linksOut(root, blocker);
+      issues.push({
+        id: `notdir:${root}:${blocker}`,
+        severity: out2 ? "suggestion" : "problem",
+        title: out2 ? `${where}: ${blocker} links out of the repo` : `${where}: ${blocker} isn't a folder`,
+        detail: out2 ? `${blockerSaid(root, blocker)}. ${who} ${who.includes(",") || who.includes(" and ") ? "load" : "loads"} what's there, but skilllib treats it as outside ${where}: it adds, links and removes nothing there.` : `${blockerSaid(root, blocker)}: ${who} can't load skills from ${where}, and skilllib adds none there. Move it out of the way, then run skilllib link.`,
+        at: [{ root, skill: "" }]
+        // the repo itself: its row in Places
+      });
+    }
+    for (const { s, would } of blindHere) {
+      const way = would.inTheWay.filter((p) => !notFolders.has(p));
+      if (!way.length || blockers.has(s.name)) continue;
+      issues.push({
+        id: `intheway:${root}:${s.name}`,
+        severity: "problem",
+        title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it here`,
+        detail: `${inTheWaySaid(root, way)}. skilllib won't link past what's there: clear the way, then run skilllib link.`,
+        at: rows(root, [s.name])
+      });
+    }
     for (const { s, would } of blindHere.filter(({ would: w }) => !w.created.length && !w.blocked.length && w.uncommitted.length))
       issues.push({
         id: `uncommitted:${root}:${s.name}`,
         severity: "suggestion",
         title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it until it's committed`,
-        detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`, or from Health).`
+        detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`).`,
+        at: rows(root, [s.name])
       });
     const partial = blindHere.filter(({ would }) => would.created.length || would.blocked.length).map(({ s }) => s);
     if (partial.length) {
-      const missing = [...new Set(partial.flatMap((s) => s.visibility.filter((v) => v.paths === 0).map((v) => v.id)))];
+      const missing2 = [...new Set(partial.flatMap((s) => s.visibility.filter((v) => v.paths === 0).map((v) => v.id)))];
       const tracked = [...new Set(blindHere.flatMap(({ would }) => would.blocked))];
+      const manifestShared = partial.some((s) => s.managed) && ["committed", "changed"].includes(gitOf(root)?.of(MANIFEST_FILE) ?? "");
       const run = (allowTracked) => () => {
         if (allowTracked) allowTrackedLinks(root);
-        const r = linkAll(root, { allowTracked });
+        const r = linkAll(root, { allowTracked, names: partial.map((s) => s.name) });
         const notes = `${r.blocked.length ? `; skipped ${r.blocked.join(", ")} (git tracks ${r.blocked.length === 1 ? "it" : "them"})` : ""}${r.uncommitted.length ? `; ${r.uncommitted.join(", ")} not linked into folders git tracks (not committed, so teammates would get broken links)` : ""}`;
-        if (!r.linked.length) throw new Error(`${where}: nothing linked${notes}`);
-        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing)}${notes}`;
+        if (!r.linked.length) {
+          const still = partial.filter((s) => visibilityOf(root, s.name).some((v) => v.paths === 0 && !loadsGlobally(s.name, v.id)));
+          if (!still.length) return `${where}: already usable by ${agentNames(missing2)}`;
+          throw new Error(`${where}: nothing linked${notes}`);
+        }
+        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing2)}${notes}`;
       };
       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 ? {
+        title: `${where}: ${plural(partial.length, "skill")} not usable by ${agentNames(missing2)}`,
+        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.` : ""}${manifestShared ? " The new links are recorded in skilllib.json, which git tracks." : ""}`,
+        at: rows(root, partial.map((s) => s.name)),
+        ...manifestShared && !tracked.length ? { choices: [{ label: "Add the links", hint: "git will see skilllib.json change", run: run(false) }] } : tracked.length ? {
           choices: [
             // Only when some link goes where git doesn't track: otherwise this one would link nothing.
             ...blindHere.some(({ would }) => would.created.length) ? [{ label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) }] : [],
@@ -2157,22 +2812,24 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       });
     }
     const differing = new Set(tidy2.conflicts.map((c) => c.name));
-    const git2 = gitInfo(root);
+    const git2 = gitOf(root);
     const committed = (s) => ["committed", "changed"].includes(git2?.of(relativeTo(root, s.path)) ?? "");
-    for (const s of status2) {
+    for (const s of unstuck) {
       if (isLink(s.path) || differing.has(s.name)) continue;
-      if (s.state === "local only" && committed(s)) {
+      if (s.state === "local only" && (committed(s) || untrackable(s))) {
+        const why = committed(s) ? "it's the team's (committed)" : `${untrackable(s)}, so skilllib can't track it here`;
         issues.push({
           id: `local:${root}:${s.name}`,
           severity: "suggestion",
           title: `${s.name} in ${where} isn't in your library`,
-          detail: "Copy it into the library to reuse it in other projects. The repo's copy stays as it is: it's the team's (committed).",
+          detail: `Copy it into the library to reuse it in other projects. The repo's copy stays as it is: ${why}.`,
+          at: rows(root, [s.name]),
           choices: [
             {
               label: "Copy into the library",
               hint: `${where}'s copy stays as it is`,
               run: () => {
-                importSkill(s.path);
+                intoLibrary(s.path);
                 return `${s.name} copied into your library; ${where}'s copy stays as it is`;
               }
             }
@@ -2184,27 +2841,102 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
           severity: "suggestion",
           title: `${s.name} in ${where} isn't in your library`,
           detail: "Import it into the library to reuse it in other projects and keep it backed up. The repo then tracks it in skilllib.json.",
+          at: rows(root, [s.name]),
           choices: [
             {
               label: "Import into the library",
-              hint: `${where} then tracks it`,
+              // Tracking it writes skilllib.json.
+              hint: `copies it into Your skills${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
               run: () => {
-                importSkill(s.path);
-                addSkill(root, s.name);
+                intoLibrary(s.path);
+                track(root, s.name);
                 return `${s.name} imported and tracked in ${where}`;
               }
             }
           ]
         });
-      } else if (s.state === "untracked copy of library skill") {
+      } else if (s.state === "untracked copy of library skill" && !committed(s) && !untrackable(s)) {
         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 (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}` }]
+          at: rows(root, [s.name]),
+          choices: [{ label: "Track it", hint: `adds it to ${where}'s skilllib.json`, run: () => `${track(root, s.name).name} tracked in ${where}` }]
+        });
+      } else if (s.state === "untracked, differs from library" || s.state === "repo skill, differs from library") {
+        const teams = s.state.startsWith("repo skill") || committed(s) || !!untrackable(s);
+        const whose = s.state.startsWith("repo skill") || committed(s) ? "It's the team's copy (committed, or in the repo's own .agents/skills)" : `${untrackable(s)}, so skilllib can't track it here`;
+        issues.push({
+          id: `differs:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name} in ${where} differs from your library`,
+          detail: teams ? `${whose}, and no version in Your skills matches it. Update your library from it if it's the one to keep; ${where}'s copy stays as it is.` : `No version in Your skills matches it. Update your library from it (${where} then tracks it), or replace it with your library's.`,
+          at: rows(root, [s.name]),
+          choices: [
+            {
+              label: "Update your library from it",
+              hint: teams ? `a new version in Your skills; ${where}'s copy stays as it is` : `a new version in Your skills; ${where} then tracks it`,
+              run: () => {
+                intoLibrary(s.path, true);
+                if (teams) return `${s.name}: your library has ${where}'s copy; ${where}'s copy stays as it is`;
+                const c = track(root, s.name);
+                return `${s.name}: your library has ${where}'s copy as v${c.to}; ${where} tracks it`;
+              }
+            },
+            ...teams ? [] : [
+              {
+                label: "Replace it with your library's",
+                hint: "this copy is restorable with skilllib restore",
+                run: () => {
+                  const c = addSkill(root, s.name, { force: true });
+                  if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
+                  return `${s.name} in ${where} is your library's v${c.to} now; the old copy is restorable with skilllib restore`;
+                }
+              }
+            ]
+          ]
+        });
+      } else if (s.state === "from npx skills" && !((committed(s) || untrackable(s)) && versionForHash(s.name, treeHash(s.path) ?? "") !== null)) {
+        const teams = committed(s) || !!untrackable(s);
+        issues.push({
+          id: `npx:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name} in ${where} came from npx skills, not your library`,
+          detail: `Installed with \`npx skills add\`${s.source ? ` (${s.source})` : ""}. Import it into your library to reuse it in other projects and keep it backed up${teams ? `; ${where}'s copy stays as it is (${committed(s) ? "committed" : `${untrackable(s)}, so skilllib can't track it here`})` : `; ${where} then tracks it in skilllib.json`}.`,
+          at: rows(root, [s.name]),
+          choices: [
+            {
+              label: "Import it into your library",
+              hint: teams ? `${where}'s copy stays as it is` : `${where} then tracks it`,
+              run: () => {
+                intoLibrary(s.path);
+                if (teams) return `${s.name} copied into your library; ${where}'s copy stays as it is`;
+                track(root, s.name);
+                return `${s.name} imported and tracked in ${where}`;
+              }
+            }
+          ]
         });
       }
+      if (s.state === "not in library")
+        issues.push({
+          id: `not-in-lib:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name} in ${where} is tracked, but no longer in your library`,
+          detail: `${where}'s skilllib.json pins it, but your library has no copy: if the folder goes, sync can't restore it, and your other repos can't add it. Copy ${where}'s copy back into the library.`,
+          at: rows(root, [s.name]),
+          choices: [
+            {
+              label: "Copy it back into your library",
+              hint: `${where}'s copy stays as it is`,
+              run: () => {
+                intoLibrary(s.path);
+                return `${s.name} copied back into your library`;
+              }
+            }
+          ]
+        });
       if (s.state === "edited locally" || s.state === "edited locally, update available") {
         const newer2 = s.state !== "edited locally";
         const pinned = s.version ? `v${s.version}` : "the library version";
@@ -2212,11 +2944,21 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
           id: `edited:${root}:${s.name}`,
           severity: "suggestion",
           title: `${s.name} in ${where} has local edits`,
-          detail: `It no longer matches ${pinned} from Your skills${newer2 ? `, and v${s.latest} is out` : ""}. Save the edits as a new version so your other repos can get them, or discard them. Keeping them is fine too: skilllib never overwrites edits.`,
-          choices: [
+          detail: `It no longer matches ${pinned} from Your skills${newer2 ? `, and v${s.latest} is out` : ""}. ${untrackable(s) ? `${untrackable(s)}, so skilllib can't re-pin or discard them here; copy them into Your skills to keep them for your other repos.` : "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."}`,
+          at: rows(root, [s.name]),
+          choices: untrackable(s) ? [
+            {
+              label: "Copy the edits into Your skills",
+              hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : "a new version there"}; ${where}'s copy and pin stay as they are (skilllib sync there would put the pinned version back)`,
+              run: () => {
+                intoLibrary(s.path, true);
+                return `${s.name}: the edits are in Your skills as v${latestVersion(s.name)?.version}; ${where} stays as it is`;
+              }
+            }
+          ] : [
             {
               label: "Save as a new version in Your skills",
-              hint: newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`,
+              hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`}${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
               run: () => {
                 importSkill(s.path, { force: true });
                 const c = addSkill(root, s.name);
@@ -2226,7 +2968,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
             },
             {
               label: "Discard the edits",
-              hint: `back to ${pinned}; the edited copy is restorable from Health`,
+              hint: `back to ${pinned}; the edited copy is restorable with skilllib restore${gitNote(root, [s.path, join13(root, MANIFEST_FILE)])}`,
               run: () => {
                 const c = discardEdits(root, s.name);
                 if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
@@ -2242,48 +2984,77 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   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 }]);
+      if (alsoLoadedGlobally(n) && !copies.some((c) => c.root === root)) alsoGlobal.set(n.name, [...copies, { root, managed: false, nested: true }]);
     }
   }
+  const everyRepo = [...projects2, ...knownProjects()];
+  const nestedMemo = /* @__PURE__ */ new Map();
+  const subsMemo = /* @__PURE__ */ new Map();
+  const subsOf = (root) => subsMemo.get(root) ?? (subsMemo.set(root, packageDirs(root)), subsMemo.get(root));
+  const entriesOf2 = (root) => nestedMemo.get(root) ?? (nestedMemo.set(root, nestedEntries(root, { subs: subsOf(root) })), nestedMemo.get(root));
   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 removable = copies.filter((c) => c.managed && statuses.get(c.root)?.some((s) => s.name === name && removesClean(c.root, s))).map((c) => c.root);
     const repoOwn = copies.filter((c) => !c.managed).map((c) => basename6(c.root));
+    const at = [...copies.flatMap((c) => rows(c.root, [name])), ...rows(null, [name])];
     if (kept.has(name)) {
-      const removeWheres = removable.map((r) => basename6(r)).join(", ");
+      const globalLoaders = new Set(globalCopies.filter((m) => m.name === name).flatMap((m) => m.harnesses));
+      const onlyHere = (root) => visibilityOf(root, name).filter((v) => v.paths > 0 && !globalLoaders.has(v.id)).map((v) => harness(v.id).name);
+      const needed = removable.filter((root) => onlyHere(root).length);
+      const extra = removable.filter((root) => !onlyHere(root).length);
+      const removeWheres = extra.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.${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 ? [
+        detail: [
+          extra.length ? `The global copy already loads in ${removeWheres} for every agent that reads the project copy, so those are extra.` : "",
+          needed.length ? `In ${needed.map((r) => `${basename6(r)} (${onlyHere(r).join(", ")})`).join(", ")}, some agents read only the repo's copy: keep it there, or link the global one for them.` : "",
+          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.` : ""
+        ].filter(Boolean).join(" "),
+        at,
+        choices: extra.length ? [
           {
             label: `Remove the copies in ${removeWheres}`,
-            hint: "the global copy stays",
+            // Removing a managed copy edits its skilllib.json too.
+            hint: `the global copy stays${extra.some((r) => gitNote(r, [...statuses.get(r).filter((s) => s.name === name).map((s) => s.path), join13(r, MANIFEST_FILE)])) ? "; git will see it" : ""}`,
             run: () => {
-              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`;
+              const results = extra.map((root) => [root, removeSkill(root, name)]);
+              const removed = results.filter(([, c]) => c.action === "removed").map(([r]) => basename6(r));
+              const kept2 = results.filter(([, c]) => c.action !== "removed").map(([r, c]) => `${basename6(r)} (${c.reason})`);
+              if (kept2.length) throw new Error(`${name}: ${removed.length ? `removed from ${removed.join(", ")}; ` : ""}kept in ${kept2.join(", ")}`);
+              return `${name}: removed from ${removed.join(", ")}; the global copy stays`;
             }
           }
         ] : void 0
       });
       continue;
     }
-    const movable = machine.find((m) => m.name === name && m.movable);
+    const movable = machine.find((m) => m.name === name && m.movable && !m.broken);
+    const doomed = machine.filter((x) => x.name === name && x.movable);
+    const differ = copiesDiffer(doomed.map((m) => m.path));
+    const libraryDiffers = !!movable && libraryNames.has(name) && versionForHash(name, treeHash(movable.path) ?? "") === null;
+    const blind = movable && !differ && !libraryDiffers ? blindWithoutGlobal(name, doomed, everyRepo, entriesOf2, subsOf) : [];
     issues.push({
+      at,
       id: `twice:${name}`,
       severity: "suggestion",
       title: `${name}: in ${wheres} and also loaded globally`,
-      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 ? [
+      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 ? `The global copy comes from ${machine.find((m) => m.name === name && !m.movable)?.origin ?? "a vendor"}: turn it off there.` : differ ? `Your global copies of ${name} differ: keep one first (skilllib tidy --global), then stop loading it globally.` : libraryDiffers ? `The global copy isn't a version in Your skills (agents loading it globally run different content than the repo's): update your library from it first (skilllib import ${tildify(movable.path)} --force), or keep it global (skilllib global keep).` : blind.length ? `${blindSaid(name, blind)}.` : "Stop loading it globally, or keep it global on purpose (skilllib global keep)."}`,
+      choices: movable && !differ && !libraryDiffers && !blind.length ? [
         {
           label: "Stop loading it globally",
-          hint: "restorable from Health",
+          hint: "restorable with skilllib restore",
           run: () => {
+            const now = blindWithoutGlobal(name, doomed, everyRepo);
+            if (now.length) throw new Error(`${name}: ${blindSaid(name, now)}`);
             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`;
+            const left = strandedLinks(name, doomed, everyRepo);
+            for (const m of machine.filter((x) => x.name === name && x.movable)) {
+              const r = unloadGlobal(m.path, m.links);
+              if (!r.ok) throw new Error(`${name}: ${r.reason}`);
+            }
+            return `${name} no longer loads globally${left.length ? `; ${left.join(", ")} now point${left.length === 1 ? "s" : ""} at nothing: remove ${left.length === 1 ? "it" : "them"}` : ""}`;
           }
         }
       ] : void 0
@@ -2305,6 +3076,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       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.",
+      at: rows(null, ["skilllib"]),
       ...agentSkill2 === "missing" ? { choices: [install] } : { fix: install }
     });
   }
@@ -2319,6 +3091,7 @@ function addedAt(path) {
   }
 }
 function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectStatus) {
+  gitMemo = /* @__PURE__ */ new Map();
   if (!enabledHarnesses().includes("claude-code")) return [];
   const issues = [];
   const since = Date.now() - uses.days * 24 * 60 * 60 * 1e3;
@@ -2326,26 +3099,45 @@ function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectS
     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);
+    const removable = unused.filter((s) => removesClean(root, s));
     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." : ""}`,
+      title: `${where}: ${plural(unused.length, "skill")} unused in ${plural(uses.days, "day")}`,
+      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.some((s) => !s.managed) ? " The repo's own skills are the team's: remove those in the repo if nobody needs them." : ""}${unused.some((s) => s.managed && !removable.includes(s)) ? ` Not offered: ${unused.filter((s) => s.managed && !removable.includes(s)).map((s) => `${s.name} (${s.state.startsWith("edited") ? "edited" : s.state === "not in library" ? "not in your library" : "something is in sync's way"})`).join(", ")}; their own issues say what to do first.` : ""}`,
+      at: rows(root, unused.map((s) => s.name)),
       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",
+          hint: `Your skills keeps them; edited ones stay${gitNote(root, [...removable.map((s) => s.path), join13(root, MANIFEST_FILE)])}`,
           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)` : ""}`;
+            if (kept.length) throw new Error(`${where}: ${removed.length ? `removed ${removed.join(", ")}; ` : "removed nothing; "}kept ${kept.join(", ")} (${changes.find((c) => c.action !== "removed")?.reason ?? "skipped"})`);
+            return `${where}: removed ${removed.join(", ")}`;
           }
         }
       ] : void 0
     });
   }
+  if (uses.asUsed)
+    for (const p of installedPlugins().filter((x) => x.agent === "claude-code" && x.on && x.skills.length)) {
+      const name = p.id.split("@")[0];
+      if (p.skills.some((path) => uses.asUsed(`${name}:${basename6(path)}`) > 0)) continue;
+      issues.push({
+        id: `plugin-unused:${installId(p)}`,
+        severity: "suggestion",
+        title: `${p.id}${installedIn(p)}: its skills weren't used in ${plural(uses.days, "day")}`,
+        detail: `No Claude Code session used ${p.skills.map((path) => `/${name}:${basename6(path)}`).join(", ")}. Each one's name and description still takes context in every session.${p.extras.length ? ` It also brings ${p.extras.join(", ")}: turning it off pauses those too.` : ""}`,
+        choices: [
+          { label: `Turn the plugin ${p.id} off`, hint: p.scope === "project" ? `stays installed; edits ${basename6(p.projectPath ?? "the repo")}'s committed .claude/settings.json` : "stays installed", run: () => orThrow(setPluginOn(p, false)) },
+          ...p.synced || p.settingsOnly ? [] : [{ label: `Uninstall the plugin ${p.id}`, hint: `its data stays; restorable with skilllib restore${p.scope === "project" ? `; edits ${basename6(p.projectPath ?? "the repo")}'s committed .claude/settings.json` : ""}`, run: () => orThrow(uninstallPlugin(p)) }]
+        ],
+        plugin: p.id,
+        pluginAt: p.projectPath ?? null
+      });
+    }
   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];
@@ -2355,15 +3147,18 @@ function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectS
     issues.push({
       id: "unused:library",
       severity: "suggestion",
-      title: `${plural(idle.length, "skill")} in Your skills: in no repo, unused in ${uses.days} days`,
+      title: `${plural(idle.length, "skill")} in Your skills: in no repo, unused in ${plural(uses.days, "day")}`,
       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.`,
+      // Your skills' rows (none loads globally, so none is in Global).
+      at: rows(null, idle),
       choices: [
         {
           label: `Delete ${idle.length === 1 ? "it" : `all ${idle.length}`} from Your skills`,
-          hint: "restorable from Health",
+          hint: "restorable with skilllib restore",
           run: () => {
             const done = idle.map((name) => [name, deleteLibrarySkill(name)]);
             const failed = done.filter(([, r]) => !r.ok).map(([name]) => name);
+            if (failed.length === done.length) throw new Error(`Deleted nothing; kept ${failed.join(", ")}`);
             return `Deleted ${plural(done.length - failed.length, "skill")} from Your skills${failed.length ? `; kept ${failed.join(", ")}` : ""}`;
           }
         }
@@ -2385,13 +3180,12 @@ function groupBy(items) {
 }
 var sameSet = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
 function globalFrom(kind, origin, path) {
-  if (kind === "global" || kind === "skilllib") return tildify(path.replace(/[\\/][^\\/]+$/, "")).replace(/\\/g, "/");
+  if (kind === "global" || kind === "skilllib") return tildify(path.replace(/[\\/][^\\/]+$/, ""));
   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);
+    return readdirSync8(root, { withFileTypes: true }).filter((d) => !d.name.startsWith(".") && !BUILD_DIRS.has(d.name)).map((d) => d.isDirectory() ? `${d.name}/` : d.name).sort().slice(0, 60);
   } catch {
     return [];
   }
@@ -2407,13 +3201,13 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   const group = (list2) => groupBy(
     list2.map((s) => {
       const loadedBy = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
-      const behind = s.managed && s.latest !== null && s.version !== null && s.latest > s.version;
+      const behind = s.state.endsWith("update available");
       const gitState = git2?.of(relativeTo(root, s.path));
       const repo = !s.managed && (s.state.startsWith("repo skill") || gitState === "committed" || gitState === "changed");
       const usual = s.state === "ok" || s.state === "local only" || repo && s.state !== "from npx skills";
       const attrs = {
         source: s.managed ? "library" : repo ? "repo" : "local",
-        dir: s.location !== ".claude/skills" ? s.location : void 0,
+        dir: s.location !== PROJECT_SKILLS_DIR ? s.location : void 0,
         version: s.version ?? void 0,
         state: usual ? void 0 : s.state,
         latest: behind ? s.latest : void 0,
@@ -2423,7 +3217,14 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
       return [JSON.stringify(attrs), s.name, () => ({ ...attrs, skills: [] })];
     })
   );
-  const skills = group(inRepo ? projectStatus(root) : []);
+  const own = (() => {
+    try {
+      return inRepo ? projectStatus(root) : [];
+    } catch {
+      return [];
+    }
+  })();
+  const skills = group(own);
   const nested = group(nestedHere);
   const machine = machineSkills(agents);
   const loaded = inRepo ? skillsLoadedIn(root, machine, agents) : machine;
@@ -2437,7 +3238,7 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   for (const i of statusIssues(root, machine)) {
     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: [], ids: [], detail: i.detail, fix: i.fix?.label, choices };
+    const issue = issues.get(key) ?? { problems: [], ids: [], detail: detailWithGit(i), fix: i.fix?.label, choices };
     issue.problems.push(i.title);
     issue.ids.push(i.id);
     issues.set(key, issue);
@@ -2445,7 +3246,8 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   const usesHere = Object.fromEntries([...uses].filter(([, n]) => n > 0));
   return {
     project: tildify(root),
-    files: topLevel(root),
+    // Outside a repo there are no project files to read (and the folder may be your home).
+    files: inRepo ? topLevel(root) : [],
     agents,
     skills,
     nested: nested.length > 0 ? nested : void 0,
@@ -2460,7 +3262,7 @@ function firstSentence(description) {
   return sentence.length > 200 ? sentence.slice(0, 199).trimEnd() + "\u2026" : sentence;
 }
 function libraryFor(currentProject) {
-  const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: readManifest(p).skills }));
+  const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: pinsIn(p) }));
   const here = currentProject ? new Set(projectStatus(currentProject).map((s) => s.name)) : null;
   const all = librarySkills();
   const describe2 = (s) => {
@@ -2472,8 +3274,8 @@ function libraryFor(currentProject) {
 }
 
 // src/usage.ts
-import { createReadStream, existsSync as existsSync12, readdirSync as readdirSync8, statSync as statSync4 } from "fs";
-import { join as join13 } from "path";
+import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync9, statSync as statSync5 } from "fs";
+import { join as join14 } from "path";
 import { createInterface } from "readline";
 var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
   "add-dir",
@@ -2553,31 +3355,43 @@ function usesFromTranscriptLine(line) {
   return [];
 }
 function transcriptFiles(sinceMs) {
-  const base = join13(claudeDir(), "projects");
-  if (!existsSync12(base)) return [];
-  return readdirSync8(base).flatMap((project) => {
-    const dir = join13(base, project);
-    if (!statSync4(dir).isDirectory()) return [];
-    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join13(dir, f)).filter((f) => statSync4(f).mtimeMs >= sinceMs);
+  const base = join14(claudeDir(), "projects");
+  if (!existsSync13(base)) return [];
+  const list2 = (dir) => {
+    try {
+      return readdirSync9(dir);
+    } catch {
+      return [];
+    }
+  };
+  return list2(base).flatMap((project) => {
+    const dir = join14(base, project);
+    if (!statSync5(dir, { throwIfNoEntry: false })?.isDirectory()) return [];
+    return list2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => (statSync5(f, { throwIfNoEntry: false })?.mtimeMs ?? 0) >= 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);
+    try {
+      const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+      for await (const line of lines) {
+        for (const use of usesFromTranscriptLine(line)) {
+          if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
+        }
       }
+    } catch {
+      continue;
     }
   }
   return [...seen.values()];
 }
-function summarize(uses, projectOf = () => null) {
+var skillOf = (key) => key.split(":").pop();
+function summarize2(uses, projectOf = () => null) {
   const bySkill = /* @__PURE__ */ new Map();
   for (const use of uses) {
-    const skill = use.skill.split(":").pop();
+    const skill = skillOf(use.skill);
     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;
@@ -2593,7 +3407,8 @@ function usesByProject(uses, projectOf) {
     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);
+    const skill = skillOf(use.skill);
+    counts.set(skill, (counts.get(skill) ?? 0) + 1);
     byProject.set(root, counts);
   }
   return byProject;
@@ -2601,20 +3416,43 @@ function usesByProject(uses, projectOf) {
 
 // src/move.ts
 import { basename as basename8 } from "path";
-function moveGlobalSkills(skills, roots, { group, allowTracked = false, label = basename8 } = {}) {
+function moveGlobalSkills(skills, roots, {
+  group,
+  allowTracked = false,
+  label = basename8,
+  allowTrackedHint = "re-run with --allow-tracked"
+} = {}) {
   const byName = /* @__PURE__ */ new Map();
   for (const m of skills) byName.set(m.name, [...byName.get(m.name) ?? [], m]);
   return [...byName].map(([name, copies]) => {
-    if (new Set(copies.map((m) => treeHash(m.path))).size > 1)
+    if (copiesDiffer(copies.map((m) => m.path)))
       return { name, moved: false, reason: `your global copies of ${name} differ; nothing moved (keep one first: skilllib tidy --global)`, changes: [] };
-    if (importSkill(copies[0].path).status === "exists")
+    const elsewhere = blindWithoutGlobal(name, copies, knownProjects().filter((p) => !roots.some((r) => realPath(r) === realPath(p))));
+    if (elsewhere.length) return { name, moved: false, reason: `nothing moved: ${blindSaid(name, elsewhere, label)}`, changes: [] };
+    const hash = treeHash(copies[0].path) ?? "";
+    const cant = roots.flatMap((root) => ((b) => b ? [`${label(root)} (${b.replace(/ \(use --force to replace (it|the link)\)$/, "")})`] : [])(trackBlocker(root, name) ?? addRefusal(root, name, hash)));
+    if (cant.length) return { name, moved: false, reason: `nothing moved: it can't be added to ${cant.join(", ")}`, changes: [] };
+    const imported = importSkill(copies[0].path).status;
+    if (imported === "exists")
       return { name, moved: false, reason: `your library has a different ${name}; nothing moved (update your library from this copy first)`, changes: [] };
     if (group) recordOrigin(name, `group: ${group}`);
     const changes = roots.map((root) => [root, addSkill(root, name, { allowTracked })]);
     const skipped = changes.filter(([, c]) => c.action === "skipped");
-    if (skipped.length) return { name, moved: false, reason: `not added to ${skipped.map(([r, c]) => `${label(r)} (${c.reason})`).join(", ")}, so it still loads globally`, changes };
+    const why = (reason = "") => reason.replace(/ \(use --force to replace it\)$/, ": move or remove it there first");
+    const kept = imported === "added" ? `; it's in Your skills now` : "";
+    if (skipped.length) return { name, moved: false, reason: `not added to ${skipped.map(([r, c]) => `${label(r)} (${why(c.reason)})`).join(", ")}, so it still loads globally${kept}`, changes };
+    const blindIn = changes.flatMap(([root, c]) => ((b) => b.length ? [{ root, c, b }] : [])(blindWithoutGlobal(name, copies, [root])));
+    if (blindIn.length) {
+      const per = blindIn.map(({ root, c, b }) => {
+        const who = b.map((x) => `${harness(x.id).name}${realPath(x.root) === realPath(root) ? "" : ` in ${label(x.root)}`}`).join(", ");
+        const next = c.inTheWay?.length ? `${inTheWaySaid(root, c.inTheWay)}: clear the way, then run skilllib link there` : c.uncommitted?.length ? `git tracks ${c.uncommitted.join(", ")} but not the skill's copy: commit it first, then allow the link there` : c.blocked?.length ? `git tracks ${c.blocked.join(", ")}: ${allowTrackedHint}` : blindSaid(name, b, label);
+        return `${who} ${b.every((x) => realPath(x.root) === realPath(root)) ? `in ${label(root)} ` : `(${label(root)}) `}couldn't see it (${next})`;
+      });
+      return { name, moved: false, reason: `added, but ${per.join("; ")}, so it still loads globally`, changes };
+    }
+    const left = strandedLinks(name, copies, [...roots, ...knownProjects()], label);
     const failed = copies.map((m) => unloadGlobal(m.path, m.links)).find((r) => !r.ok);
-    return failed && !failed.ok ? { name, moved: false, reason: failed.reason, changes } : { name, moved: true, changes };
+    return failed && !failed.ok ? { name, moved: false, reason: failed.reason, changes } : { name, moved: true, changes, ...left.length ? { left } : {} };
   });
 }
 
@@ -2636,6 +3474,7 @@ var FLAGS = {
 function parseArgs(argv) {
   const { values: v, positionals } = parseFlags({ args: argv, options: FLAGS, allowPositionals: true, strict: true });
   const days = Number(v.days ?? USAGE_DAYS);
+  if (!Number.isInteger(days) || days <= 0) throw new Error(`--days takes a whole number of days, like --days 30 (got ${v.days})`);
   return {
     positional: positionals,
     force: !!v.force,
@@ -2644,7 +3483,7 @@ function parseArgs(argv) {
     fix: !!v.fix,
     allowTracked: !!v["allow-tracked"],
     json: !!v.json,
-    days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS,
+    days,
     dryRun: !!v["dry-run"],
     allowGit: !!v["allow-git"],
     ...v.keep ? { keep: v.keep } : {},
@@ -2660,27 +3499,28 @@ function colorState(state) {
 function withDirs(root, changes) {
   const { skills } = readManifest(root);
   return changes.map((c) => {
-    const dep = c.action === "installed" || c.action === "updated" || c.action === "reset" ? skills[c.name] : void 0;
-    return dep ? { ...c, dirs: [dep.dir ?? ".claude/skills", ...dep.links ?? []] } : c;
+    const dep = c.action !== "removed" && c.action !== "skipped" ? skills[c.name] : void 0;
+    return dep ? { ...c, dirs: [dep.dir ?? PROJECT_SKILLS_DIR, ...(dep.links ?? []).filter((d) => !c.inTheWay?.includes(`${d}/${c.name}`))] } : c;
   });
 }
+var incomplete = (c) => c.action === "skipped" || !!c.blocked?.length || !!c.uncommitted?.length || !!c.inTheWay?.length;
+function warnHeldLinks(root, c, where = "here") {
+  if (c.blocked?.length) warn(`${c.name}: git tracks ${c.blocked.join(", ")} ${where}, so no link was added there. Re-run with --allow-tracked to add it.`);
+  if (c.uncommitted?.length)
+    warn(`${c.name}: git tracks ${c.uncommitted.join(", ")} ${where} but not ${c.name}'s real copy, so no link was added there (teammates would get a broken link). Commit ${c.name} first, then run skilllib link --allow-tracked.`);
+  if (c.inTheWay?.length) warn(`${c.name}: not linked everywhere ${where}: ${inTheWaySaid(root, c.inTheWay)}. Clear the way, then run skilllib link.`);
+}
 function printChanges(root, changes, args) {
-  if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
+  if (changes.some(incomplete)) process.exitCode = 1;
   if (args.json) return json("changes", withDirs(root, changes));
   for (const c of changes) {
-    if (c.blocked?.length) {
-      warn(`${c.name}: git tracks ${c.blocked.join(", ")} here, so no link was added there. Re-run with --allow-tracked to add it.`);
-    }
-    if (c.uncommitted?.length) {
-      warn(
-        `${c.name}: git tracks ${c.uncommitted.join(", ")} here but not ${c.name}'s real copy, so no link was added there (teammates would get a broken link). Commit ${c.name} first, then run skilllib link --allow-tracked.`
-      );
-    }
+    warnHeldLinks(root, c);
     if (c.action === "skipped") error(`${c.name}: ${c.reason}`);
     else {
-      const icon = c.action === "removed" ? red("-") : c.action === "reset" ? yellow("\u21BA") : green(c.action === "installed" ? "+" : "\u2191");
+      const icon = c.action === "removed" ? red("-") : c.action === "reset" ? yellow("\u21BA") : c.action === "unchanged" ? dim("=") : green(c.action === "installed" ? "+" : c.action === "relinked" ? "\u21E2" : "\u2191");
       const versions = c.action === "removed" ? "" : c.from && c.from !== c.to ? ` v${c.from} \u2192 v${c.to}` : c.to ? ` v${c.to}` : "";
       info(`  ${icon} ${c.name}${versions} ${dim(c.action)}`);
+      if (c.reason) info(dim(`    ${c.reason}`));
     }
     if (c.backedUp) info(dim(`    local edits saved to ${tildify(c.backedUp)}; \`skilllib restore ${c.name}\` brings them back`));
   }
@@ -2693,9 +3533,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 + sep5));
+    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep8));
     if (known) return known;
-    const repo = cwd.split(`${sep5}.claude${sep5}worktrees${sep5}`)[0];
+    const repo = cwd.split(`${sep8}.claude${sep8}worktrees${sep8}`)[0];
     return isProjectCandidate(repo) ? repo : null;
   };
 }
@@ -2703,13 +3543,25 @@ async function usageBySkill(days, onlyProject) {
   const projectOf = projectOfFactory(onlyProject ? [onlyProject, ...knownProjects()] : knownProjects());
   const uses = await scanUsage(days);
   const scoped = onlyProject ? uses.filter((u) => projectOf(u.cwd) === onlyProject) : uses;
-  return new Map(summarize(scoped, projectOf).map((s) => [s.skill, s]));
+  return new Map(summarize2(scoped, projectOf).map((s) => [s.skill, s]));
 }
+var projectsFor = (args) => {
+  if (!args.all) return [requireProject()];
+  const { readable, unreadable } = readableRoots(visibleProjects());
+  for (const u of unreadable) {
+    error(`${basename9(u.root)}: ${u.reason}`);
+    process.exitCode = 1;
+  }
+  return readable;
+};
+var yourGlobals = () => machineSkills().filter((m) => m.movable && !m.broken);
 function requireProject() {
   const root = projectHere();
   if (root) return root;
   if (!isProjectCandidate(findProjectRoot())) {
-    const stray = existsSync13(join14(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join14(userHome(), MANIFEST_FILE))} makes it look like one` : "";
+    const top = findProjectRoot();
+    if (realPath(top) !== realPath(userHome())) throw new Error(`${tildify(top)} is skilllib's or an agent's own folder, not a project. Run this inside a project.`);
+    const stray = existsSync14(join15(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join15(userHome(), MANIFEST_FILE))} makes it look like one` : "";
     throw new Error(`Your home folder isn't a project${stray}: skills added here would load in every repo. Run this inside a project.`);
   }
   throw new Error("Not in a git repo. Run this inside a project (or `git init` first).");
@@ -2722,7 +3574,10 @@ async function status(args) {
     const root2 = findProjectRoot();
     const usage3 = await usageBySkill(args.days, root2);
     json("status", usableHere(root2, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
-    if (projectHere()) rememberProjects([root2]);
+    try {
+      if (projectHere()) rememberProjects([root2]);
+    } catch {
+    }
     return;
   }
   const root = requireProject();
@@ -2732,14 +3587,8 @@ async function status(args) {
 `);
   if (skills.length === 0 && nested.length === 0) info("No skills in this project yet. Add one from your library with: skilllib add <name>");
   const usage2 = await usageBySkill(args.days, root);
-  const git2 = gitInfo(root, [...new Set(nested.map((s) => s.location))]);
-  const committed = (path) => ["committed", "changed"].includes(git2?.of(relativeTo(root, path)) ?? "");
-  const asRepo = {
-    "local only": "repo skill",
-    "untracked copy of library skill": "repo skill, in library",
-    "untracked, differs from library": "repo skill, differs from library"
-  };
-  const stateOf = (s) => colorState(committed(s.path) && asRepo[s.state] || s.state);
+  const teamState = teamStateIn(root, nested.map((s) => s.location));
+  const stateOf = (s) => colorState(teamState(s));
   const agentsOf = (s) => {
     const ids = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
     return ids.length === s.visibility.length ? dim("all") : ids.length ? ids.map((id) => harness(id).name).join(", ") : red("none");
@@ -2767,17 +3616,19 @@ async function status(args) {
       }))
     );
   }
-  const states = new Set(skills.map((s) => s.state));
+  const states = new Set(skills.map((s) => teamState(s)));
   const hints = [];
   if (states.has("update available")) hints.push("`skilllib update` to install the newest versions");
   const missing = skills.filter((s) => s.state === "folder missing");
-  if (missing.some((s) => s.latest !== null)) hints.push("`skilllib sync` to restore missing skills");
+  if (missing.some((s) => s.latest !== null && !syncBlocker(root, s.name))) hints.push("`skilllib sync` to restore missing skills");
+  if (missing.some((s) => syncBlocker(root, s.name))) hints.push("`skilllib doctor` says what's in sync's way");
   const notInLibrary = missing.filter((s) => s.latest === null).map((s) => s.name);
   if (notInLibrary.length)
-    hints.push(`${notInLibrary.join(", ")} ${notInLibrary.length === 1 ? "isn't" : "aren't"} in your library (${tildify(libraryDir())}): \`skilllib import <dir>\` to add, or set SKILLLIB_HOME to the library that has ${notInLibrary.length === 1 ? "it" : "them"}`);
-  if (states.has("edited locally") || states.has("edited locally, update available"))
-    hints.push("`skilllib import .claude/skills/<name> --force` to save local edits to the library");
-  if (states.has("local only")) hints.push("`skilllib import .claude/skills/<name>` to add a local skill to the library");
+    hints.push(`${notInLibrary.join(", ")} ${notInLibrary.length === 1 ? "isn't" : "aren't"} in your library (${tildify(libraryDir())}): \`skilllib import <dir>\` to add, or set SKILLLIB_HOME to the skilllib folder whose library has ${notInLibrary.length === 1 ? "it" : "them"}`);
+  const at = (s) => relativeTo(root, s.path);
+  for (const s of skills.filter((x) => x.state === "edited locally" || x.state === "edited locally, update available"))
+    hints.push(`\`skilllib import ${at(s)} --force\` to save ${s.name}'s local edits to the library`);
+  for (const s of skills.filter((x) => x.state === "local only")) hints.push(`\`skilllib import ${at(s)}\` to add ${s.name} to the library`);
   if (states.has("untracked copy of library skill") || states.has("untracked, differs from library"))
     hints.push("`skilllib add <name>` to manage an untracked skill (--force if it differs)");
   if (hints.length > 0) info("\n" + hints.map((h) => dim(`\u2192 ${h}`)).join("\n"));
@@ -2804,7 +3655,7 @@ async function list(args) {
   } else {
     const installs = /* @__PURE__ */ new Map();
     for (const project of visibleProjects()) {
-      for (const name of Object.keys(readManifest(project).skills)) {
+      for (const name of Object.keys(pinsIn(project))) {
         installs.set(name, [...installs.get(name) ?? [], basename9(project)]);
       }
     }
@@ -2816,14 +3667,14 @@ async function list(args) {
       skills.map((s) => ({
         Skill: s.name,
         Description: truncate(s.description, 50),
-        From: dim(truncate(origins[s.name] ?? "", 30)),
+        From: dim(truncate(tildify(origins[s.name] ?? ""), 30)),
         Projects: (installs.get(s.name) ?? []).join(", ") || dim("none"),
         [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0)
       }))
     );
   }
   const libraryNames = new Set(skills.map((s) => s.name));
-  const globals = [...new Set(machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.name))];
+  const globals = [...new Set(yourGlobals().filter((m) => m.harnesses.length).map((m) => m.name))];
   if (globals.length > 0) {
     info("");
     warn(`${globals.length} of your global ${globals.length === 1 ? "skill still loads" : "skills still load"} in every project`);
@@ -2835,20 +3686,33 @@ async function list(args) {
     );
   }
 }
+function teamStateIn(root, extraDirs = []) {
+  const git2 = gitInfo(root, [...new Set(extraDirs)]);
+  const committed = (path) => ["committed", "changed"].includes(git2?.of(relativeTo(root, path)) ?? "");
+  const asRepo = {
+    "local only": "repo skill",
+    "untracked copy of library skill": "repo skill, in library",
+    "untracked, differs from library": "repo skill, differs from library"
+  };
+  return (s) => committed(s.path) && asRepo[s.state] || s.state;
+}
 function projects(args) {
-  const roots = visibleProjects();
+  const { readable: roots, unreadable } = readableRoots(visibleProjects());
+  for (const u of unreadable) {
+    error(`${basename9(u.root)}: ${u.reason}`);
+    process.exitCode = 1;
+  }
   if (args.json) {
     return json(
       "projects",
-      roots.map(
-        (root) => ({
+      roots.map((root) => {
+        const teamState = teamStateIn(root);
+        return {
           name: basename9(root),
           path: root,
-          skills: projectStatus(root).map(
-            (s) => ({ name: s.name, managed: s.managed, state: s.state, version: s.version, latest: s.latest })
-          )
-        })
-      )
+          skills: projectStatus(root).map((s) => ({ name: s.name, managed: s.managed, state: teamState(s), version: s.version, latest: s.latest }))
+        };
+      })
     );
   }
   if (roots.length === 0) {
@@ -2858,13 +3722,14 @@ function projects(args) {
   table(
     roots.map((root) => {
       const skills = projectStatus(root);
-      const managed = skills.filter((s) => s.managed);
-      const attention = skills.filter((s) => s.state !== "ok" && s.state !== "local only").length;
+      const teamState = teamStateIn(root);
+      const usual = /* @__PURE__ */ new Set(["ok", "local only", "repo skill", "repo skill, in library", "from npx skills"]);
+      const attention = skills.filter((s) => !usual.has(teamState(s))).length;
       return {
         Project: basename9(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),
+        Skills: skills.map((s) => s.name).join(", ") || dim("none"),
+        "Local only": String(skills.filter((s) => teamState(s) === "local only").length),
         Status: attention === 0 ? green("ok") : yellow(`${attention} need attention`)
       };
     })
@@ -2875,8 +3740,7 @@ function add(args) {
     throw new Error("Usage: skilllib add <skill-name>... [--force]");
   }
   const root = requireProject();
-  if (args.allowTracked) allowTrackedLinks(root);
-  printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force })), args);
+  printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force, allowTracked: args.allowTracked })), args);
   rememberProjects([root]);
 }
 function remove(args) {
@@ -2886,59 +3750,59 @@ function remove(args) {
   const root = requireProject();
   printChanges(root, args.positional.map((name) => removeSkill(root, name, { force: args.force })), args);
 }
-function sync(args) {
-  if (args.positional.length) throw new Error(`sync takes no skill names: it installs exactly what skilllib.json pins. To add a skill: skilllib add ${args.positional.join(" ")}`);
-  const roots = args.all ? visibleProjects() : [requireProject()];
+function changeEach(args, change, nothing) {
+  const roots = projectsFor(args);
   const results = roots.map((root) => {
-    if (args.allowTracked) allowTrackedLinks(root);
-    const changes = syncProject(root, { force: args.force });
-    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
+    const changes = change(root);
+    if (changes.some(incomplete)) process.exitCode = 1;
     if (!args.json) {
       if (args.all) info(`${basename9(root)} ${dim(tildify(root))}`);
-      if (changes.length === 0) {
-        if (existsSync13(join14(root, MANIFEST_FILE))) success("Installed versions match skilllib.json");
-        else info(dim("No skilllib.json: nothing to sync"));
-      } else printChanges(root, changes, args);
+      if (changes.length === 0) nothing(root);
+      else printChanges(root, changes, args);
     }
     return { project: basename9(root), path: root, changes: withDirs(root, changes) };
   });
   if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
+  return roots;
+}
+function sync(args) {
+  if (args.positional.length) throw new Error(`sync takes no skill names: it installs exactly what skilllib.json pins. To add a skill: skilllib add ${args.positional.join(" ")}`);
+  const roots = changeEach(
+    args,
+    (root) => syncProject(root, { force: args.force }),
+    (root) => existsSync14(join15(root, MANIFEST_FILE)) ? success("Installed versions match skilllib.json") : info(dim("No skilllib.json: nothing to sync"))
+  );
   if (!args.all) rememberProjects(roots);
 }
 function update(args) {
-  const roots = args.all ? visibleProjects() : [requireProject()];
-  const results = roots.map((root) => {
-    if (args.allowTracked) allowTrackedLinks(root);
-    const names = args.positional.length ? args.positional : void 0;
-    const changes = updateProject(root, names, { force: args.force });
-    if (!args.all) {
-      const { skills } = readManifest(root);
-      for (const name of names ?? []) if (!(name in skills)) changes.push({ name, action: "skipped", reason: "not managed by skilllib in this project" });
-    }
-    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
-    if (!args.json) {
-      if (args.all) info(`${basename9(root)} ${dim(tildify(root))}`);
-      if (changes.length === 0) success("Everything is on the latest version");
-      else printChanges(root, changes, args);
-    }
-    return { project: basename9(root), path: root, changes: withDirs(root, changes) };
-  });
-  if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
+  const names = args.positional.length ? args.positional : void 0;
+  changeEach(
+    args,
+    (root) => {
+      const changes = updateProject(root, names, { force: args.force, allowTracked: args.allowTracked });
+      if (!args.all) {
+        for (const name of names ?? []) if (!(name in readManifest(root).skills)) changes.push({ name, action: "skipped", reason: "not managed by skilllib in this project" });
+      }
+      return changes;
+    },
+    () => success("Everything is on the latest version")
+  );
 }
 function outdated(args) {
-  const roots = args.all ? visibleProjects() : [requireProject()];
+  const roots = projectsFor(args);
   const behind = roots.flatMap(
-    (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ project: basename9(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
+    (root) => projectStatus(root).filter((s) => s.state.endsWith("update available") && s.latest !== null && s.version !== null).map((s) => ({ project: basename9(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
   if (args.json) return json("outdated", behind);
-  const rows = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
-  if (rows.length === 0) return success("Everything is on the latest version");
-  table(rows);
+  const rows2 = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
+  if (rows2.length === 0) return success("Everything is on the latest version");
+  table(rows2);
   info(dim(`
 \u2192 skilllib update${args.all ? " --all" : ""}`));
 }
 function importSkills(args) {
-  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve7(p));
+  if (args.global && args.positional.length) throw new Error("skilllib import --global takes no folders: it imports all your global skills");
+  const dirs = args.global ? yourGlobals().map((m) => m.path) : args.positional.map((p) => resolve8(p));
   if (dirs.length === 0) {
     throw new Error("Usage: skilllib import <skill-dir>... [--force] | skilllib import --global");
   }
@@ -2958,14 +3822,11 @@ function importSkills(args) {
       continue;
     }
     success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
-    const skillsDir = resolve7(dir, "..");
-    const root = resolve7(skillsDir, "..", "..");
-    if (skillsDir === join14(root, ".claude", "skills") && isProjectCandidate(root)) {
-      if (readManifest(root).skills[name]?.hash !== treeHash(dir)) {
-        const change = addSkill(root, name);
-        if (change.action !== "skipped") info(dim(`  ${basename9(root)} now depends on ${name} v${change.to}`));
-      }
-      rememberProjects([root]);
+    const root = resolve8(dir, "..", "..", "..");
+    const dep = projectHere(root) === root ? readManifest(root).skills[name] : void 0;
+    if (dep && realpathOrNull(join15(root, dep.dir ?? PROJECT_SKILLS_DIR, name)) === realpathOrNull(dir) && dep.hash !== treeHash(dir)) {
+      const change = addSkill(root, name);
+      if (change.action !== "skipped") info(dim(`  ${basename9(root)} now depends on ${name} v${change.to}`));
     }
   }
   if (args.json) json("import", results);
@@ -2980,7 +3841,8 @@ function scan(args) {
   const found = discoverProjects();
   const library = new Set(librarySkills().map((s) => s.name));
   const skillNames = (root) => [
-    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.flatMap((d) => skillDirsIn(join14(root, d))).map((d) => basename9(d)), ...nestedSkills(root).map((s) => s.name)])
+    // Not a folder that links out of the repo: what's in it isn't the repo's (as in status).
+    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.filter((d) => !notWritable(root, d)).flatMap((d) => skillDirsIn(join15(root, d))).map((d) => basename9(d)), ...nestedSkills(root).map((s) => s.name)])
   ];
   const withSkills = found.filter((root) => skillNames(root).length > 0);
   info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project${found.length === 1 ? "" : "s"}, ${withSkills.length} with skills
@@ -2997,44 +3859,43 @@ ${yellow("Yellow")} skills aren't in your library yet (\`skilllib import <skill-
 }
 function folders(args) {
   const [action, ...paths] = args.positional;
-  let failed = false;
+  if (action && !["add", "remove", "rm"].includes(action)) throw new Error("Usage: skilllib folders [add|remove <folder>...]");
+  const failures = [];
   if (action === "add") {
     for (const p of paths) {
       try {
         success(`Added ${tildify(addRoot(p))}`);
       } catch (e) {
-        error(e.message);
-        failed = true;
+        failures.push(e.message);
       }
     }
     discoverProjects();
   } else if (action === "remove" || action === "rm") {
     for (const p of paths) {
       if (removeRoot(p)) success(`Removed ${tildify(expandHome(p))}`);
-      else warn(`${tildify(expandHome(p))} wasn't a project folder`);
+      else failures.push(`${tildify(expandHome(p))} wasn't a project folder`);
     }
   }
   const { roots, hidden } = readConfig();
   info(roots.length ? `Project folders:
 ${roots.map((r) => `  ${tildify(r)}`).join("\n")}` : "No project folders. Add one: skilllib folders add ~/Projects");
   if (hidden.length) info(dim(`Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}  (skilllib unhide <path>)`));
-  if (failed) process.exitCode = 1;
+  if (failures.length) throw new Error(failures.join("; "));
 }
 function unhide(args) {
   if (args.positional.length === 0) {
     throw new Error("Usage: skilllib unhide <path>...");
   }
-  let failed = false;
+  const failures = [];
   for (const p of args.positional) {
     const path = expandHome(p);
     if (setHidden(path, false)) success(`${tildify(path)} is visible again`);
     else {
       const { hidden } = readConfig();
-      error(`${tildify(path)} wasn't hidden. ${hidden.length ? `Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}` : "No projects are hidden."}`);
-      failed = true;
+      failures.push(`${tildify(path)} wasn't hidden. ${hidden.length ? `Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}` : "No projects are hidden."}`);
     }
   }
-  if (failed) process.exitCode = 1;
+  if (failures.length) throw new Error(failures.join("; "));
 }
 function newSkill(args) {
   const [name, ...rest] = args.positional;
@@ -3045,7 +3906,7 @@ function newSkill(args) {
   if (!r.ok) {
     throw new Error(`Can't create ${name}: ${r.reason}`);
   }
-  success(`Created ${tildify(join14(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join15(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
   const backups = [...listBackups(), ...pluginBackups()];
@@ -3056,16 +3917,15 @@ function restore(args) {
     info(dim("\n\u2192 skilllib restore <name>"));
     return;
   }
-  const backup = backups.find((b) => b.name === name);
-  if (!backup) {
-    throw new Error(`No backup named ${name}`);
-  }
-  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}`);
-    process.exitCode = 1;
+  const newest = backups.find((b) => b.name === name);
+  if (!newest) throw new Error(`No backup named ${name} (skilllib restore lists them; a skill removed from a repo that your library has comes back with skilllib add ${name})`);
+  const failures = [];
+  for (const backup of movedTogether(backups, newest)) {
+    const r = backup.kind === "plugin" ? restorePlugin(backup) : restoreBackup(backup);
+    if (r.ok) success(`Restored ${name} to ${tildify(r.to)}`);
+    else failures.push(r.reason);
   }
+  if (failures.length) throw new Error(`Can't restore ${name}: ${failures.join("; ")}`);
 }
 async function allIssues(args, withUsage = true) {
   const projects2 = visibleProjects();
@@ -3076,11 +3936,14 @@ async function allIssues(args, withUsage = true) {
     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]));
+    const total = new Map(summarize2(uses, projectOf).map((s) => [s.skill, s.uses]));
+    const asUsed = /* @__PURE__ */ new Map();
+    for (const u of uses) asUsed.set(u.skill, (asUsed.get(u.skill) ?? 0) + 1);
     issues.push(
-      ...usageIssues(projects2, machine, libraryNames, {
+      ...usageIssues(readableRoots(projects2).readable, machine, libraryNames, {
         inProject: (root, skill) => inProject.get(root)?.get(skill) ?? 0,
         total: (skill) => total.get(skill) ?? 0,
+        asUsed: (key) => asUsed.get(key) ?? 0,
         days: args.days
       })
     );
@@ -3102,7 +3965,7 @@ async function doctor(args) {
           id,
           severity,
           title,
-          detail,
+          detail: detailWithGit({ detail, fix, choices }),
           fix: fix?.label,
           choices: choices?.map((c) => c.label),
           fixed: args.fix && fix ? fixed(fix) : void 0
@@ -3114,7 +3977,8 @@ async 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 (issue.choices) info(dim(`  your call: ${issue.choices.map((c, i) => `${i + 1}) ${c.label}`).join("  ")}  \u2192  skilllib apply ${issue.id} <n>`));
+    const spans = new Set(issue.at?.map((a) => a.root)).size > 1;
+    if (issue.choices) info(dim(`  your call: ${issue.choices.map((c, i) => `${i + 1}) ${c.label}`).join("  ")}  \u2192  skilllib apply ${issue.id} ${spans ? '"<choice>"' : "<n>"}`));
     if (args.fix && issue.fix) {
       const r = fixed(issue.fix);
       info(`  ${r.ok ? green("\u2713") : red("\u2717")} ${r.message}`);
@@ -3125,14 +3989,14 @@ async function doctor(args) {
 async function apply(args) {
   const [id, pick] = args.positional;
   if (!id) throw new Error("Usage: skilllib apply <issue-id> [choice]   (ids and choices: skilllib status --json or doctor --json)");
-  const found = [...statusIssues(findProjectRoot()), ...await allIssues(args, id.startsWith("unused:"))].filter((i) => i.id === id);
+  const found = [...statusIssues(findProjectRoot()), ...await allIssues(args, /^(plugin-)?unused:/.test(id))].filter((i) => i.id === id);
   if (!found.length) throw new Error(`No issue ${id} right now (it may be fixed already; for an unused:\u2026 issue, pass doctor's --days). See skilllib status --json or doctor --json`);
   const optionsOf = (i) => i.choices ?? (i.fix ? [i.fix] : []);
   const labels = (i) => optionsOf(i).map((c) => c.label).join("\0");
   const byLabel = pick === void 0 ? void 0 : found.find((i) => optionsOf(i).some((c) => c.label.toLowerCase() === pick.toLowerCase()));
   if (!byLabel && found.some((i) => labels(i) !== labels(found[0]))) {
     const all = [...new Set(found.flatMap((i) => optionsOf(i).map((c) => c.label)))];
-    throw new Error(`${found[0].title}: its choices differ between this repo and all your repos; pick one by label: ${all.map((l) => `"${l}"`).join("  ")}`);
+    throw new Error(`${found[0].title}: its choices here differ from doctor's (all your repos); pick one by label: ${all.map((l) => `"${l}"`).join("  ")}`);
   }
   const issue = byLabel ?? found[0];
   const options = optionsOf(issue);
@@ -3148,22 +4012,22 @@ async function apply(args) {
   else error(r.message);
 }
 async function usage(args) {
-  const summaries = summarize(await scanUsage(args.days), projectOfFactory(knownProjects()));
+  const summaries = summarize2(await scanUsage(args.days), projectOfFactory(knownProjects()));
+  const library = new Set(librarySkills().map((s) => s.name));
+  const unused = [...library].filter((name) => !summaries.some((u) => u.skill === name));
   if (args.json) {
-    const library2 = new Set(librarySkills().map((s) => s.name));
     return json("usage", {
       usageDays: args.days,
       source: "Claude Code transcripts",
-      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename9(p)), inLibrary: library2.has(s.skill) })),
-      unusedLibrarySkills: librarySkills().filter((l) => !summaries.some((u) => u.skill === l.name)).map((l) => l.name)
+      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename9(p)), inLibrary: library.has(s.skill) })),
+      unusedLibrarySkills: unused
     });
   }
   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(join14(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join15(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
@@ -3174,15 +4038,14 @@ async function usage(args) {
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
   );
-  const unused = librarySkills().filter((s) => !summaries.some((u) => u.skill === s.name));
   if (unused.length > 0) {
     info("");
-    warn(`Library skills unused in the last ${args.days} days: ${unused.map((s) => s.name).join(", ")}`);
+    warn(`Library skills unused in the last ${args.days} days: ${unused.join(", ")}`);
   }
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join14(libraryDir(), name) : "";
+  const dir = name ? join15(libraryDir(), name) : "";
   if (!name || !isSkillDir(dir)) {
     throw new Error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
   }
@@ -3194,14 +4057,14 @@ function show(args) {
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
-      projects: knownProjects().filter((p) => name in readManifest(p).skills).map((p) => basename9(p)),
-      skillMd: readFileSync9(join14(dir, "SKILL.md"), "utf-8")
+      projects: projectsUsing(name).map((p) => basename9(p)),
+      skillMd: readFileSync7(join15(dir, "SKILL.md"), "utf-8")
     });
   }
   info(`${name} ${dim(tildify(dir))}`);
   if (description) info(`
 ${description}`);
-  const using = knownProjects().filter((p) => name in readManifest(p).skills);
+  const using = projectsUsing(name);
   info(`
 Installed in: ${using.map((p) => tildify(p)).join(", ") || "no projects"}`);
 }
@@ -3223,26 +4086,35 @@ function harnessesCommand(args) {
 New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(enabled).length > 1 ? " (link)" : ""}.`));
 }
 function link(args) {
-  const roots = args.all ? visibleProjects() : [requireProject()];
+  const roots = projectsFor(args);
   for (const root of roots) {
-    if (args.allowTracked) allowTrackedLinks(root);
-    const res = linkAll(root);
+    const res = linkAll(root, { allowTracked: args.allowTracked });
     const label = args.all ? `${basename9(root)}: ` : "";
     if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
-    else if (!args.all && !res.blocked.length && !res.uncommitted.length) success("Every skill here is already usable by all your agents");
+    else if (!args.all && !res.blocked.length && !res.uncommitted.length && !res.inTheWay.length) {
+      const missing = projectStatus(root).filter((s) => s.state === "folder missing").map((s) => s.name);
+      if (missing.length) warn(`Nothing to link; ${missing.join(", ")} ${missing.length === 1 ? "isn't" : "aren't"} installed here (skilllib sync, or skilllib doctor says what's in the way)`);
+      else success("Every skill here is already usable by all your agents");
+    }
+    if (res.inTheWay.length) {
+      process.exitCode = 1;
+      error(`${label}some skills weren't linked everywhere: ${inTheWaySaid(root, res.inTheWay)}. Clear the way, then link again`);
+    }
     if (res.blocked.length) {
       process.exitCode = 1;
       error(`${label}git tracks ${res.blocked.join(", ")}, so ${res.linked.length ? "some skills weren't" : "nothing was"} linked there; re-run with --allow-tracked to link there too`);
     }
-    if (res.uncommitted.length)
+    if (res.uncommitted.length) {
+      process.exitCode = 1;
       warn(
         `${label}${res.uncommitted.join(", ")} ${res.uncommitted.length === 1 ? "isn't" : "aren't"} committed, so not linked into folders git tracks (teammates would get broken links); commit ${res.uncommitted.length === 1 ? "it" : "them"} first`
       );
+    }
   }
 }
 function globalCommand(args) {
   const [action, ...names] = args.positional;
-  const yours = machineSkills().filter((m) => m.movable && !m.broken);
+  const yours = yourGlobals().filter((m) => m.harnesses.length);
   if (action === "move") return moveGlobal(args, names, yours);
   if (action === "keep" || action === "unkeep") {
     const unknown = names.filter((n) => !yours.some((m) => m.name === n));
@@ -3267,7 +4139,7 @@ function repoRoot(repo) {
   if (named.length === 1) return named[0];
   if (named.length > 1) throw new Error(`Several projects are named ${repo}: ${named.map(tildify).join(", ")}. Pass its path.`);
   const path = expandHome(repo);
-  if (!existsSync13(path)) throw new Error(`No project ${repo} (pass its path, or see skilllib projects)`);
+  if (!existsSync14(path)) throw new Error(`No project ${repo} (pass its path, or see skilllib projects)`);
   const root = projectHere(path);
   if (root !== path) throw new Error(root ? `${tildify(path)} is inside ${tildify(root)}: pass the repo's top folder` : `${tildify(path)} isn't in a git repo`);
   return root;
@@ -3279,14 +4151,16 @@ function moveGlobal(args, names, yours) {
   const roots = [...new Set(args.to.map(repoRoot))];
   const skills = yours.filter((m) => names.includes(m.name));
   const moves = moveGlobalSkills(skills, roots, { allowTracked: args.allowTracked });
+  rememberProjects(roots);
   if (moves.some((m) => !m.moved)) process.exitCode = 1;
   if (args.json) {
     return json(
       "global move",
-      moves.map(({ name, moved, reason, changes }) => ({
+      moves.map(({ name, moved, reason, changes, left }) => ({
         skill: name,
         moved,
         ...reason ? { reason } : {},
+        ...left ? { left } : {},
         projects: changes.map(([root, c]) => ({ project: basename9(root), path: root, change: withDirs(root, [c])[0] }))
       }))
     );
@@ -3294,20 +4168,18 @@ function moveGlobal(args, names, yours) {
   for (const m of moves) {
     if (m.moved) success(`${m.name} now loads only in ${m.changes.map(([r]) => basename9(r)).join(", ")} (the global copy is in skilllib restore)`);
     else error(`${m.name}: ${m.reason}`);
-    for (const [root, c] of m.changes) {
-      if (c.blocked?.length) warn(`  ${basename9(root)}: git tracks ${c.blocked.join(", ")}, so no link there. Re-run with --allow-tracked to add it.`);
-      if (c.uncommitted?.length) warn(`  ${basename9(root)}: no link in ${c.uncommitted.join(", ")}: git tracks it but not the skill's copy, so the link would break for teammates. Commit the copy, then run skilllib link --allow-tracked.`);
-    }
+    for (const [root, c] of m.changes) warnHeldLinks(root, c, `in ${basename9(root)}`);
+    if (m.left) warn(`${m.name}: ${m.left.join(", ")} now point${m.left.length === 1 ? "s" : ""} at nothing (the repo's own copy serves that package): remove ${m.left.length === 1 ? "it" : "them"}`);
   }
   if (moves.some((m) => m.moved)) info(dim("Commit skilllib.json and the skill folders in each repo."));
 }
 function tidy(args) {
   const names = args.positional;
-  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve7(base, args.keep) : expandHome(args.keep)])) : {};
+  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve8(base, args.keep) : expandHome(args.keep)])) : {};
   if (args.keep && !names.length) {
     throw new Error("Usage: skilllib tidy <name>... --keep <folder>");
   }
-  const targets = args.global ? [null] : args.all ? visibleProjects() : [requireProject()];
+  const targets = args.global ? [null] : projectsFor(args);
   const problems = [];
   for (const name of names) {
     const where = targets.map((root) => ({ root, ...foldersOf(root, name) })).filter((w) => w.all.length);
@@ -3335,30 +4207,35 @@ function tidy(args) {
   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`);
+    const skippedNamed = names.length ? report.skipped.filter((x) => names.includes(x.name) && x.differs) : [];
+    if (skippedNamed.length) process.exitCode = 1;
+    if (!plans.length && !conflicts.length && !skippedNamed.length && !args.all) success(`${label}: nothing to tidy (no extra copies or links)`);
     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;
+      const wouldHold = args.allowGit ? [] : gitVisibleSteps(plan);
+      const result = args.dryRun ? { applied: plan.steps.filter((s) => !wouldHold.includes(s)), held: wouldHold } : applyTidy(plan, { git: args.allowGit ? "go" : "keep" });
+      if (result.applied.length) info(`${args.dryRun ? dim("would") : green("\u2713")} ${label} \xB7 ${plan.name}: ${result.applied.map((s) => describeStep(s, plan.root)).join(", ")}`);
+      for (const step of result.held) info(`${yellow("!")} ${label} \xB7 ${plan.name}: ${args.dryRun ? "would be held" : "held"} back, git would see it: ${describeStep(step, plan.root)}`);
+      held += result.held.length;
       changed += result.applied.length;
     }
-    if (args.keep && conflicts.length) process.exitCode = 1;
+    if (conflicts.length && (args.keep || names.length)) process.exitCode = 1;
     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 runs = copy.runs.map((id) => harness(id).name);
+        info(`    ${folderLabel(c.root, 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);
+      const pick = folderLabel(c.root, 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.`));
+  if (held) {
+    process.exitCode = 1;
+    info(dim(`${held} change${held === 1 ? "" : "s"} held back because git would see them. Re-run with --allow-git to make them.`));
+  }
 }
 function agentSkill(args) {
   const action = args.positional[0];
@@ -3378,6 +4255,7 @@ function agentSkill(args) {
     if (args.json) return json("agent-skill", { state: agentSkillState(), removed });
     return removed.length ? success(`Removed from ${removed.map((d) => tildify(d)).join(" and ")}`) : info("The skilllib skill isn't installed.");
   }
+  if (action) throw new Error("Usage: skilllib agent-skill [install|remove]");
   const state = agentSkillState();
   if (args.json) return json("agent-skill", { state, dirs: agentSkillDirs() });
   if (state === "installed") success(`Your agents can use skilllib ${dim(`(${agentSkillDirs().map((d) => tildify(d)).join(", ")})`)}`);
@@ -3386,21 +4264,29 @@ function agentSkill(args) {
 }
 
 export {
+  realPath,
   skilllibHome,
   PROJECT_SKILLS_DIR,
   HARNESSES,
   harness,
+  installDirs,
   readSkillInfo,
+  treeHash,
+  isDir,
   versionHistory,
   forgetLatest,
   latestVersion,
   projectHere,
   readManifest,
+  knownProjects,
+  rememberProjects,
+  readableRoots,
   setJsonMode,
   isJsonMode,
   json,
   error,
   tildify,
+  localStamp,
   readConfig,
   addRoot,
   removeRoot,
@@ -3419,50 +4305,51 @@ export {
   recordOrigin,
   librarySkills,
   librarySkillDir,
-  visibilityOf,
+  notWritable,
+  inTheWaySaid,
+  entryExists,
+  survives,
+  blindWithoutGlobal,
+  strandedLinks,
+  blindSaid,
+  trackBlocker,
   projectStatus,
   linkEverywhere,
   relinkDependency,
+  addRefusal,
   addSkill,
   removeSkill,
-  syncSkill,
   updateProject,
   importSkill,
   removeUntracked,
   projectsUsing,
   deleteLibrarySkill,
   deleteGlobal,
-  unloadGlobal,
-  linkGlobal,
   createSkill,
   listBackups,
+  movedTogether,
   restoreBackup,
   gitInfo,
   relativeTo,
-  claudePlugins,
   installedPlugins,
   cursorPlugins,
   forgetClaudeBinary,
   claudeBinary,
-  turnOffIn,
   setPluginOn,
   uninstallPlugin,
   updatePlugin,
   pluginBackups,
   restorePlugin,
-  cursorPluginSkills,
   agentSkillState,
   installAgentSkill,
   removeAgentSkill,
   refreshAgentSkill,
-  planProjectTidy,
-  planGlobalTidy,
-  gitVisibleSteps,
-  applyTidy,
-  describeStep,
-  copyLabel,
-  addedAt,
+  foldersOf,
+  runFix,
+  findIssues,
+  usageIssues,
   scanUsage,
+  skillOf,
   moveGlobalSkills,
   parseArgs,
   projectOfFactory,