skilllib 1.11.3 → 1.11.5

package/dist/{chunk-3XDWEHI4.js → chunk-TE2EDZ7L.js}

@@ -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");
@@ -81,6 +81,7 @@ function writeState(path, data) {
     throw err;
   }
 }
+var BUILD_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage"]);
 
 // src/output.ts
 var jsonMode = false;
@@ -103,8 +104,8 @@ 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, " ");
@@ -124,13 +125,8 @@ function localStamp(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 mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9 } from "path";
-
 // src/config.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { homedir as homedir2 } from "os";
 import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
@@ -246,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 = readFileSync2(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]);
@@ -255,21 +251,25 @@ 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 = statSync2(full, { throwIfNoEntry: false });
-    return !st ? [] : st.isDirectory() ? listFiles(full) : [full];
+    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, "en"));
   for (const file of files) {
@@ -280,10 +280,18 @@ function treeHash(dir) {
 function copySkill(from, to) {
   const source = realpathSync2(from);
   rmSync2(to, { recursive: true, force: true });
-  cpSync(source, to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) && existsSync2(src) });
+  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();
 }
 
@@ -357,12 +365,17 @@ function readManifest(root) {
   } 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,
@@ -375,7 +388,7 @@ function readManifest(root) {
           ]
         ];
       }
-      return [];
+      throw new Error(`${path} isn't a valid skilllib.json: ${name}'s pin has no hash`);
     })
   );
   return { ...data, skills };
@@ -406,7 +419,9 @@ 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));
@@ -446,7 +461,7 @@ function writeConfig(config) {
   writeState(configFile(), config);
 }
 function expandHome(path) {
-  return resolve4(path.replace(/^~(?=$|\/)/, homedir2()));
+  return resolve4(path.replace(/^~(?=$|[\\/])/, userHome()));
 }
 function addRoot(path) {
   const root = expandHome(path);
@@ -470,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)) {
@@ -522,10 +537,14 @@ 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 mkdirSync4, readdirSync as readdirSync4, renameSync as renameSync2, rmSync as rmSync3, symlinkSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename3, dirname as dirname3, join as join8, relative as relative2, sep as sep4 } 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 mkdirSync3, readdirSync as readdirSync3, readlinkSync } from "fs";
@@ -568,7 +587,7 @@ 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();
@@ -596,7 +615,7 @@ function globalFolderSkills(enabled) {
     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,
@@ -613,13 +632,14 @@ 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) => 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) => vendorSkill(path, "built-in", "Cursor", ["cursor"]));
@@ -636,7 +656,7 @@ function claudeAiSkills(enabled) {
     byReal.set(real, entry);
   }
   return [...byReal.values()].flatMap(
-    ({ dir, readers }) => readdirSync3(dir).filter((d) => !d.startsWith(".")).flatMap(
+    ({ 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))))
     )
   );
@@ -646,6 +666,8 @@ function installedPluginsJson() {
 }
 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,
@@ -678,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;
@@ -695,6 +717,7 @@ function machineSkills(enabled = enabledHarnesses()) {
     ...claudeAiSkills(enabled),
     ...pluginSkills(enabled),
     ...cursorBuiltInSkills(enabled),
+    ...codexBuiltInSkills(enabled),
     ...grokBuiltInSkills(enabled),
     ...systemSkills(enabled)
   ].sort(byKindAndName);
@@ -719,7 +742,9 @@ function recordOrigin(name, origin) {
 function originFor(dir) {
   const under = (path, folder) => path.startsWith((realpathOrNull(folder) ?? folder) + sep3);
   const real = realpathOrNull(dir) ?? dir;
-  if ([tmpdir(), "/tmp", "/var/tmp"].some((t) => under(real, t)) && !under(real, userHome())) return "";
+  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];
@@ -746,6 +771,62 @@ 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(dirname3(link2), target), link2);
@@ -759,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 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 ?? installDirs(enabledHarnesses())[0];
   const wanted = installDirs(enabledHarnesses(), primary);
-  return [primary, .../* @__PURE__ */ new Set([...dep?.links ?? [], ...wanted.filter((d) => d !== 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 {
@@ -779,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,
@@ -799,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;
@@ -840,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(sep4).join("/");
-        for (const path of skillDirsIn(join8(sub, skillsDir))) {
-          if (isLink(path) && (realpathOrNull(path) ?? "").startsWith((realpathOrNull(root) ?? root) + sep4)) 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}`;
@@ -888,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);
@@ -906,6 +1166,7 @@ function linkEverywhere(root, name, location, { allowTracked = false, dryRun = f
       }
     }
     if (!dryRun) {
+      if (broken) unlinkSync(link2);
       mkdirSync4(join8(root, dir), { recursive: true });
       linkDir(join8(root, location, name), link2);
     }
@@ -913,15 +1174,10 @@ function linkEverywhere(root, name, location, { allowTracked = false, dryRun = f
   }
   return result;
 }
-function unlinkEverywhere(root, name, removing) {
-  const gone = removing ? realpathOrNull(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 = realpathOrNull(link2);
-      if (target !== null && target !== gone) return false;
-    }
+    if (!isLink(link2) || realpathOrNull(link2) !== null) return false;
     unlinkSync(link2);
     return true;
   });
@@ -929,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])] };
@@ -937,39 +1193,60 @@ 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 && !recorded && local !== target.hash && isGitTracked(root, `${primary}/${name}`))
-    return { name, action: "skipped", 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` };
-  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 withoutForceHint(reason) {
+  return reason.replace(/ \(use --force[^)]*\)$/, "");
+}
+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)) {
+  const copied = local !== target.hash || isLink(to);
+  if (copied) {
     mkdirSync4(join8(root, primary), { recursive: true });
     if (isLink(to)) unlinkSync(to);
     else if (local !== null && versionForHash(name, local) === null) backedUp = stash(to, "edit-backup");
@@ -978,14 +1255,21 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
   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) && realpathOrNull(link2) === realpathOrNull(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);
@@ -996,9 +1280,11 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
         continue;
       }
     }
+    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,
@@ -1007,13 +1293,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 } : {}
   };
 }
@@ -1021,37 +1315,79 @@ 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 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 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", 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);
-  }
+  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 copy = join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name);
   const local = treeHash(copy);
-  const linksOk = (dep.links ?? []).every((d) => realpathOrNull(join8(root, d, name)) === realpathOrNull(copy));
-  if (local === dep.hash && linksOk) return [];
+  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)];
-  if (local !== null && local !== dep.hash && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
   const version = pinnedVersion(name, dep);
   if (typeof version === "string") return [{ name, action: "skipped", reason: version }];
-  const change = addSkill(root, name, { force: true, version });
-  return [{ ...change, action: local === null ? "installed" : change.action }];
+  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);
@@ -1063,7 +1399,7 @@ function relinkPinned(root, name, dep) {
     mkdirSync4(join8(root, dir), { recursive: true });
     linkDir(to, link2);
   }
-  return { name, action: "relinked", to: dep.version };
+  return { name, action: "relinked", to: versionForHash(name, dep.hash)?.version ?? dep.version };
 }
 function pinnedVersion(name, dep) {
   if (!latestVersion(name)) return `not in your library (${tildify(libraryDir())}); import it, or set SKILLLIB_HOME to the library that has it`;
@@ -1074,20 +1410,18 @@ function discardEdits(root, name) {
   if (!dep) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
   const version = pinnedVersion(name, dep);
   if (typeof version === "string") return { name, action: "skipped", reason: version };
-  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 });
 }
-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] : [];
   });
 }
@@ -1100,6 +1434,10 @@ function importSkill(dir, { force = false } = {}) {
   if (existing !== null && !force) return { name, status: "exists" };
   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);
@@ -1134,11 +1472,14 @@ function stash(dir, bucket) {
   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 pinsIn(p));
+  return knownProjects().filter((p) => pinsSkill(p, name));
 }
 function deleteLibrarySkill(name) {
   const using = projectsUsing(name);
@@ -1173,7 +1514,7 @@ function linkGlobal(path, agents) {
       continue;
     }
     mkdirSync4(dir, { recursive: true });
-    linkDir(path, link2);
+    linkDir(realpathOrNull(path) ?? path, join8(realpathOrNull(dir) ?? dir, name));
     linked.push(link2);
   }
   return { linked, skipped };
@@ -1185,9 +1526,10 @@ function createSkill(name, description) {
   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}
@@ -1212,6 +1554,11 @@ function listBackups() {
     });
   }).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";
   if (!backup.from) return "unknown";
@@ -1222,12 +1569,7 @@ function restoreBackup(backup) {
   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) rmSync3(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` };
+  if (entryExists(to)) return { ok: false, reason: `${backup.name} already exists there` };
   mkdirSync4(join8(to, ".."), { recursive: true });
   move(backup.path, to);
   forgetLatest(backup.name);
@@ -1237,45 +1579,39 @@ function restoreBackup(backup) {
 // src/agentSkill.ts
 var AGENT_SKILL_NAME = "skilllib";
 function shippedSkill() {
-  return readFileSync4(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 readFileSync4(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);
   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;
+    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);
   }
@@ -1283,9 +1619,9 @@ function installAgentSkill(enabled = enabledHarnesses()) {
 }
 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 (!entryExists2(d)) continue;
+    if (!entryExists(d)) continue;
     if (lstatSync3(d).isSymbolicLink()) unlinkSync2(d);
     else rmSync4(d, { recursive: true, force: true });
   }
@@ -1299,14 +1635,17 @@ function refreshAgentSkill() {
 }
 
 // src/commands.ts
-import { existsSync as existsSync14, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
 import { parseArgs as parseFlags } from "util";
-import { basename as basename9, join as join15, resolve as resolve7, sep as sep6 } 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 isShared(state) {
+  return state === "committed" || state === "changed";
+}
 function git(root, args, input) {
   try {
     return execFileSync2("git", args, { cwd: root, encoding: "utf-8", input, stdio: ["pipe", "pipe", "ignore"], maxBuffer: 16 * 1024 * 1024 });
@@ -1316,11 +1655,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)) {
@@ -1332,7 +1692,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";
     }
@@ -1347,13 +1707,16 @@ import { readdirSync as readdirSync8 } from "fs";
 import { basename as basename7 } from "path";
 
 // src/health.ts
-import { existsSync as existsSync12, lstatSync as lstatSync4, readdirSync as readdirSync7, unlinkSync as unlinkSync4 } from "fs";
-import { basename as basename6, dirname as dirname6, join as join13 } 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 mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join11, resolve as resolve6 } from "path";
+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 pluginNameOf(id) {
+  return id.split("@")[0];
+}
 function nonEmptyDir(path) {
   try {
     return readdirSync5(path).some((f) => !f.startsWith("."));
@@ -1383,6 +1746,8 @@ function claudePlugins(machine, root) {
       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(dirname4(dirname4(skills[0])))
     };
@@ -1522,8 +1887,8 @@ function ignoreLocalSettings(root) {
   } catch {
   }
   try {
-    const exclude = resolve6(root, git2("rev-parse", "--git-path", "info/exclude"));
-    const before = existsSync10(exclude) ? readFileSync5(exclude, "utf-8") : "";
+    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}
 `);
@@ -1534,7 +1899,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}` };
@@ -1542,6 +1907,10 @@ function turnOffIn(plugin, root) {
   const r = claude(["plugin", "disable", plugin.id, "--scope", "local"], root, bin);
   return r.ok ? { ok: true, message: done } : { ok: false, message: `${plugin.id}: ${r.reason}` };
 }
+function unplaced(p, verb) {
+  if (!p.scope || p.scope === "user" || p.projectPath) return null;
+  return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin ${verb} ${p.id} --scope ${p.scope}\` there` };
+}
 function settingsFileOf(p) {
   if (p.synced || !p.scope || p.scope === "user") return join11(claudeDir(), "settings.json");
   if (!p.projectPath) return null;
@@ -1551,8 +1920,10 @@ function whereOf(p) {
   return p.projectPath ? ` in ${basename4(p.projectPath)} (${p.scope})` : "";
 }
 function setPluginOn(p, on) {
-  const done = { ok: true, message: `${p.id} is ${on ? "on" : "off"}${whereOf(p)}${p.synced ? "" : "; Claude Code picks it up in its next session"}` };
-  if (p.scope && p.scope !== "user" && !p.projectPath) return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin ${on ? "enable" : "disable"} ${p.id} --scope ${p.scope}\` there` };
+  const 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}` };
+  const lost = unplaced(p, on ? "enable" : "disable");
+  if (lost) return lost;
   const bin = p.synced || p.settingsOnly ? null : claudeBinary();
   if (bin) {
     const r2 = claude(["plugin", on ? "enable" : "disable", p.id, ...p.scope ? ["--scope", p.scope] : []], p.projectPath, bin);
@@ -1560,12 +1931,14 @@ 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` };
   if (p.settingsOnly) return { ok: false, message: `${p.id} isn't installed, only turned on in your settings: turn it off instead` };
-  if (p.scope && p.scope !== "user" && !p.projectPath) return { ok: false, message: `${p.id}: skilllib doesn't know which project it's installed in; run \`claude plugin uninstall ${p.id} --scope ${p.scope}\` there` };
+  const lost = unplaced(p, "uninstall");
+  if (lost) return lost;
   const wasOn = enabledPlugins(p.projectPath)[p.id] === true;
   const r = claude(["plugin", "uninstall", p.id, "--keep-data", "--scope", p.scope ?? "user"], p.projectPath);
   if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}` };
@@ -1590,10 +1963,10 @@ function removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
 }
 function removePlugin(plugin, how) {
-  if (plugin.scope && plugin.scope !== "user" && !plugin.projectPath) {
-    return { ok: false, message: `${plugin.id}: installed for one project; run \`claude plugin ${how === "delete" ? "uninstall" : "disable"} ${plugin.id} --scope ${plugin.scope}\` there` };
-  }
-  const viaSettings = plugin.synced || !claudeBinary() && how === "off" && !plugin.projectPath;
+  if (plugin.settingsOnly && how === "delete") return { ok: false, message: `${plugin.id} isn't installed, only turned on in your settings: turn it off instead` };
+  const lost = unplaced(plugin, how === "delete" ? "uninstall" : "disable");
+  if (lost) return lost;
+  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)` };
   }
@@ -1602,7 +1975,7 @@ function removePlugin(plugin, how) {
   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 = viaSettings ? (
-    // Synced plugins aren't installed, so `claude plugin` can't touch them: their switch is enabledPlugins.
+    // 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)
   ) : (
     // --keep-data, as uninstallPlugin: its saved data stays, so a restore brings it back as it was.
@@ -1611,7 +1984,9 @@ function removePlugin(plugin, how) {
   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, wasOn);
-  return { ok: true, message: `${plugin.id} ${how === "delete" && !plugin.synced ? "removed" : "turned off"}${saved}` };
+  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 = readState(removedFile()) ?? [];
@@ -1642,12 +2017,12 @@ function restorePlugin(backup) {
   return { ok: true, to: where };
 }
 function cursorPluginSkills(plugins = cursorPlugins()) {
-  return plugins.flatMap((p) => p.skills.map((path) => ({ name: basename4(path), plugin: p.id.split("@")[0], path })));
+  return plugins.flatMap((p) => p.skills.map((path) => ({ name: basename4(path), plugin: pluginNameOf(p.id), path })));
 }
 
 // src/tidy.ts
 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 sep5 } from "path";
+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);
@@ -1665,12 +2040,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);
@@ -1697,11 +2073,13 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   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 + sep5).startsWith(realpathOrNull(root) + sep5));
+  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, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull(o.path) === realpathOrNull(e.path)) === i);
@@ -1719,7 +2097,7 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
       if (git2 === void 0) git2 = gitInfo(root);
       const planned = installDirs(enabled).map(abs);
       const fromSkillsSh = name in skillsLock;
-      const rank = (e) => (git2 && ["committed", "changed"].includes(git2.of(rel(e.path))) ? 0 : 1e3) + (fromSkillsSh && e.dir === abs(AGENTS_SKILLS_DIR) ? 0 : 100) + (planned.includes(e.dir) ? planned.indexOf(e.dir) : 50);
+      const rank = (e) => (isShared(git2?.of(rel(e.path))) ? 0 : 1e3) + (fromSkillsSh && e.dir === abs(AGENTS_SKILLS_DIR) ? 0 : 100) + (planned.includes(e.dir) ? planned.indexOf(e.dir) : 50);
       primary = [...reals].sort((a, b) => rank(a) - rank(b))[0];
     }
     if (!primary) continue;
@@ -1727,6 +2105,11 @@ 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) {
@@ -1734,11 +2117,12 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
       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 && !dep && isShared((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 && !chosen && isShared((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 });
       }
     }
@@ -1778,13 +2162,13 @@ 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) => isShared(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) : [];
+function applyTidy(plan, { git: git2 = "keep" } = {}) {
+  const held = git2 === "keep" ? gitVisibleSteps(plan) : [];
   const applied = [];
   for (const step of plan.steps) {
     if (held.includes(step) || !entryExists(step.path) || "target" in step && !entryExists(step.target)) continue;
@@ -1822,18 +2206,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() };
@@ -1865,6 +2250,16 @@ function summarize(where, verb, changes) {
 }
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 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) => isShared(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";
@@ -1874,21 +2269,23 @@ function conflictIssue(c) {
     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 ${copyLabel(c, dir)} copy${r.held.length ? `; held back ${plural(r.held.length, "change")} git would see` : ""}`;
+    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 with skilllib restore (Settings \u203A Backups in the app).`,
+    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);
+      if (!plan?.steps.length) return [];
       const visible2 = plan ? gitVisibleSteps(plan).map((s) => describeStep(s, c.root)) : [];
-      const label = `Keep the ${copyLabel(c, x.dir)} copy`;
+      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 [
-        { label: `${label}, but keep git as it is`, hint: `skips what git would see: ${visible2.join(", ")}`, run: keep(x.dir, "keep") },
+        // "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") }
       ];
     })
@@ -1898,34 +2295,68 @@ 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 brokenLinksIn(root) {
+function brokenLinksIn(root, opened) {
   const where = basename6(root);
-  const tidied = ALL_PROJECT_DIRS.filter((d) => d !== GROK_SKILLS_DIR);
-  const hasCopy = (name) => tidied.some((d) => !isLink(join13(root, d, name)) && existsSync12(join13(root, d, name, "SKILL.md")));
+  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;
-  return ALL_PROJECT_DIRS.flatMap((dir) => {
+  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 (!existsSync12(folder)) return [];
+    if (!isDir(folder) || notWritable(root, dir)) return [];
     return readdirSync7(folder).flatMap((name) => {
       const path = join13(folder, name);
-      if (!isLink(path) || existsSync12(path) || dir !== GROK_SKILLS_DIR && hasCopy(name)) return [];
+      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: () => {
-          unlinkSync4(path);
-          return `Removed the broken link ${dir}/${name} in ${where}`;
+          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)`;
         }
       };
-      git2 ??= gitInfo(root);
-      const tracked = ["committed", "changed"].includes(git2?.of(relativeTo(root, path)) ?? "");
+      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 = isShared(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 a folder that no longer exists, so it loads nothing.${tracked ? " Git tracks the link, so removing it shows in git status." : ""}`,
+          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]),
-          ...tracked ? { choices: [remove2] } : { fix: remove2 }
+          // 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] }
         }
       ];
     });
@@ -1956,32 +2387,37 @@ function grokDiffers(projects2, machine, statusOf) {
   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: []
+    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.path}`,
       severity: "problem",
       title: `${skill.name}: broken link in ${tildify(dirname6(skill.path))}`,
-      detail: "It points at a folder that no longer exists, so it loads nothing.",
+      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]),
-      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}`;
-        }
-      }
+      ...reaches === "folder" ? { choices: [remove2] } : { fix: remove2 }
     });
   }
   const loaded = machine.filter((m) => !m.broken);
@@ -2006,18 +2442,21 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   ];
   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);
@@ -2039,7 +2478,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
     const dupes = names.filter((n) => libraryNames.has(n) || loadedYours.has(n));
     if (!dupes.length) continue;
     const others = plugin.skills.length - dupes.length;
-    const pluginName = plugin.id.split("@")[0];
+    const pluginName = pluginNameOf(plugin.id);
     const remove2 = {
       label: `Remove the plugin ${plugin.id}`,
       hint: plugin.extras.length ? `also removes its ${plugin.extras.join(", ")}` : "restorable with skilllib restore",
@@ -2058,12 +2497,13 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         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
@@ -2086,7 +2526,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   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));
@@ -2095,7 +2535,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         id: `plugin:${root}:${plugin.id}`,
         severity: "problem",
         title: `${dupes.join(", ")}: also in the Claude Code plugin ${plugin.id}, on in ${where}`,
-        detail: `${where}'s Claude Code settings turn the plugin on, so Claude Code loads both there (the plugin's as /${plugin.id.split("@")[0]}:${dupes[0]}). Your skill wins.`,
+        detail: `${where}'s Claude Code settings turn the plugin on, so Claude Code loads both there (the plugin's as /${pluginNameOf(plugin.id)}:${dupes[0]}). Your skill wins.`,
         choices: repoChoices(plugin, root, inRepo),
         at: rows(root, dupes),
         plugin: plugin.id
@@ -2180,19 +2620,37 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   for (const root of projects2) {
     const where = basename6(root);
     const status2 = statuses.get(root);
-    issues.push(...brokenLinksIn(root));
+    issues.push(...brokenLinksIn(root, openedProjects));
     const pins = readManifest(root).skills;
-    const missing = status2.filter((s) => s.state === "folder missing" && s.latest !== null);
-    const restorable = missing.filter((s) => versionForHash(s.name, pins[s.name]?.hash ?? "") !== null);
-    for (const s of missing.filter((m) => !restorable.includes(m)))
+    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: `The folder is missing, and no version in Your skills has the content it pins (pinned from another library?). Install your newest v${s.latest}; ${where}'s skilllib.json then pins it.`,
+        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`.
-        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}` }]
+        ...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({
@@ -2203,16 +2661,35 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         at: rows(root, restorable.map((s) => s.name)),
         fix: {
           label: "Sync the project",
-          run: () => summarize(where, "restored", syncProject(root))
+          // 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) => isShared(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: [
@@ -2227,7 +2704,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
           }
         ]
       });
-    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}`,
@@ -2235,14 +2712,18 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         title: `${where}: ${plural(behind.length, "skill")} out of date`,
         detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
         at: rows(root, behind.map((s) => s.name)),
-        fix: {
-          label: "Update to the newest versions",
-          run: () => summarize(where, "updated", updateProject(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: isShared(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);
@@ -2253,7 +2734,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         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 with skilllib restore."),
+        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: [
@@ -2265,8 +2746,47 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
       });
     }
     issues.push(...tidy2.conflicts.map(conflictIssue));
-    const loadsGlobally = (name, id) => globalCopies.some((m) => m.name === name && m.harnesses.includes(id));
+    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}`,
@@ -2279,20 +2799,25 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
     if (partial.length) {
       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) && isShared(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}`);
+        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(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.` : ""}`,
+        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)),
-        ...tracked.length ? {
+        ...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) }] : [],
@@ -2302,16 +2827,17 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
       });
     }
     const differing = new Set(tidy2.conflicts.map((c) => c.name));
-    const git2 = gitInfo(root);
-    const committed = (s) => ["committed", "changed"].includes(git2?.of(relativeTo(root, s.path)) ?? "");
-    for (const s of status2) {
+    const git2 = gitOf(root);
+    const committed = (s) => isShared(git2?.of(relativeTo(root, s.path)));
+    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: [
             {
@@ -2334,7 +2860,8 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
           choices: [
             {
               label: "Import into the library",
-              hint: "copies it into Your skills",
+              // Tracking it writes skilllib.json.
+              hint: `copies it into Your skills${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
               run: () => {
                 intoLibrary(s.path);
                 track(root, s.name);
@@ -2343,7 +2870,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
             }
           ]
         });
-      } 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",
@@ -2353,12 +2880,13 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
           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);
+        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 or .grok/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 ? `It's the team's copy (committed, or in the repo's own .agents/skills), 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.`,
+          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: [
             {
@@ -2384,13 +2912,13 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
             ]
           ]
         });
-      } else if (s.state === "from npx skills") {
-        const teams = committed(s);
+      } 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)` : `; ${where} then tracks it in skilllib.json`}.`,
+          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: [
             {
@@ -2431,12 +2959,21 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
           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.`,
+          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: [
+          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);
@@ -2446,7 +2983,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
             },
             {
               label: "Discard the edits",
-              hint: `back to ${pinned}; the edited copy is restorable with skilllib restore`,
+              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}`);
@@ -2465,26 +3002,42 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
       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.` : ""}`,
+        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: removable.length ? [
+        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));
-              if (!removed.length) throw new Error(`${name}: removed from no project (local edits?)`);
+              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`;
             }
           }
@@ -2492,26 +3045,31 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
       });
       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 (skilllib global keep)." : `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 with skilllib restore",
           run: () => {
-            const blind = copies.filter((c) => !c.nested).flatMap((c) => visibilityOf(c.root, name).flatMap((v) => v.paths === 0 ? [`${harness(v.id).name} in ${basename6(c.root)}`] : []));
-            if (blind.length) throw new Error(`${name}: ${blind.join(", ")} only see the global copy; link the repo copies first (skilllib link)`);
+            const now = blindWithoutGlobal(name, doomed, everyRepo);
+            if (now.length) throw new Error(`${name}: ${blindSaid(name, now)}`);
             if (!libraryNames.has(name)) importSkill(movable.path);
+            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`;
+            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
@@ -2548,6 +3106,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;
@@ -2555,23 +3114,23 @@ 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);
-            if (!removed.length) throw new Error(`${where}: removed nothing; kept ${kept.join(", ")} (local edits)`);
-            return `${where}: removed ${removed.join(", ")}${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
@@ -2579,16 +3138,16 @@ function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectS
   }
   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];
+      const name = pluginNameOf(p.id);
       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 ${uses.days} days`,
+        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: "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", run: () => orThrow(uninstallPlugin(p)) }]
+          { 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
@@ -2603,7 +3162,7 @@ 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),
@@ -2636,13 +3195,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 readdirSync8(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 [];
   }
@@ -2660,11 +3218,11 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
       const loadedBy = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
       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 repo = !s.managed && (s.state.startsWith("repo skill") || isShared(gitState));
       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,
@@ -2674,7 +3232,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;
@@ -2688,7 +3253,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);
@@ -2807,29 +3372,48 @@ function usesFromTranscriptLine(line) {
 function transcriptFiles(sinceMs) {
   const base = join14(claudeDir(), "projects");
   if (!existsSync13(base)) return [];
-  return readdirSync9(base).flatMap((project) => {
+  const list2 = (dir) => {
+    try {
+      return readdirSync9(dir);
+    } catch {
+      return [];
+    }
+  };
+  return list2(base).flatMap((project) => {
     const dir = join14(base, project);
-    if (!statSync5(dir).isDirectory()) return [];
-    return readdirSync9(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => statSync5(f).mtimeMs >= sinceMs);
+    if (!statSync5(dir, { throwIfNoEntry: false })?.isDirectory()) return [];
+    return list2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => {
+      try {
+        const st = statSync5(f);
+        return st.isFile() && st.mtimeMs >= sinceMs;
+      } catch {
+        return false;
+      }
+    });
   });
 }
 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()];
 }
+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;
@@ -2845,7 +3429,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;
@@ -2857,28 +3442,39 @@ function moveGlobalSkills(skills, roots, {
   group,
   allowTracked = false,
   label = basename8,
-  allowBlind = false
+  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)} (${withoutForceHint(b)})`] : [])(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");
-    const why = (reason = "") => reason.replace(/ \(use --force to replace it\)$/, ": move or remove it there first");
-    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`, changes };
-    const held = changes.filter(([, c]) => c.blocked?.length || c.uncommitted?.length);
-    const blind = held.flatMap(([root]) => visibilityOf(root, name).flatMap((v) => v.paths === 0 ? [`${harness(v.id).name} in ${label(root)}`] : []));
-    if (blind.length && !allowBlind) {
-      const next = held.some(([, c]) => c.uncommitted?.length) ? "commit the skill's copy in the repo, then run skilllib link --allow-tracked there" : "re-run with --allow-tracked";
-      return { name, moved: false, reason: `added, but ${blind.join(", ")} couldn't see it (git tracks the folder its link goes in), so it still loads globally; ${next}`, changes };
+    const why = (reason = "") => withoutForceHint(reason) === reason ? reason : `${withoutForceHint(reason)}: 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 } : {} };
   });
 }
 
@@ -2897,6 +3493,7 @@ var FLAGS = {
   keep: { type: "string" },
   to: { type: "string", multiple: true }
 };
+var VALUE_FLAGS = Object.entries(FLAGS).flatMap(([name, f]) => f.type === "string" ? [`--${name}`] : []);
 function parseArgs(argv) {
   const { values: v, positionals } = parseFlags({ args: argv, options: FLAGS, allowPositionals: true, strict: true });
   const days = Number(v.days ?? USAGE_DAYS);
@@ -2925,26 +3522,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" || c.action === "relinked" ? 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;
-function warnHeldLinks(c, where = "here") {
+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(incomplete)) process.exitCode = 1;
   if (args.json) return json("changes", withDirs(root, changes));
   for (const c of changes) {
-    warnHeldLinks(c);
+    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" ? "+" : c.action === "relinked" ? "\u21E2" : "\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`));
   }
@@ -2957,9 +3556,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 + sep6));
+    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep8));
     if (known) return known;
-    const repo = cwd.split(`${sep6}.claude${sep6}worktrees${sep6}`)[0];
+    const repo = cwd.split(`${sep8}.claude${sep8}worktrees${sep8}`)[0];
     return isProjectCandidate(repo) ? repo : null;
   };
 }
@@ -2983,6 +3582,8 @@ function requireProject() {
   const root = projectHere();
   if (root) return root;
   if (!isProjectCandidate(findProjectRoot())) {
+    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.`);
   }
@@ -2996,7 +3597,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();
@@ -3035,17 +3639,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"));
@@ -3084,14 +3690,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(yourGlobals().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`);
@@ -3105,7 +3711,7 @@ 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 committed = (path) => isShared(git2?.of(relativeTo(root, path)));
   const asRepo = {
     "local only": "repo skill",
     "untracked copy of library skill": "repo skill, in library",
@@ -3139,13 +3745,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`)
       };
     })
@@ -3156,8 +3763,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) {
@@ -3170,7 +3776,6 @@ function remove(args) {
 function changeEach(args, change, nothing) {
   const roots = projectsFor(args);
   const results = roots.map((root) => {
-    if (args.allowTracked) allowTrackedLinks(root);
     const changes = change(root);
     if (changes.some(incomplete)) process.exitCode = 1;
     if (!args.json) {
@@ -3197,7 +3802,7 @@ function update(args) {
   changeEach(
     args,
     (root) => {
-      const changes = updateProject(root, names, { force: args.force });
+      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" });
       }
@@ -3220,7 +3825,7 @@ function outdated(args) {
 }
 function importSkills(args) {
   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) => resolve7(p));
+  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");
   }
@@ -3240,7 +3845,7 @@ function importSkills(args) {
       continue;
     }
     success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
-    const root = resolve7(dir, "..", "..", "..");
+    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);
@@ -3259,7 +3864,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(join15(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
@@ -3277,47 +3883,42 @@ ${yellow("Yellow")} skills aren't in your library yet (\`skilllib import <skill-
 function folders(args) {
   const [action, ...paths] = args.positional;
   if (action && !["add", "remove", "rm"].includes(action)) throw new Error("Usage: skilllib folders [add|remove <folder>...]");
-  let failed = false;
+  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`);
-        failed = true;
-      }
+      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;
@@ -3341,16 +3942,13 @@ function restore(args) {
   }
   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 at = (b) => Date.parse(b.path.slice(-24).replace(/^(.{13})-(\d\d)-(\d\d)-(\d{3})Z$/, "$1:$2:$3.$4Z"));
-  const together = newest.kind === "plugin" ? [newest] : backups.filter((b) => b.name === name && b.kind === newest.kind && Math.abs(at(b) - at(newest)) <= 2e3);
-  for (const backup of together) {
+  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 {
-      error(`Can't restore ${name}: ${r.reason}`);
-      process.exitCode = 1;
-    }
+    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();
@@ -3390,7 +3988,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
@@ -3402,7 +4000,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}`);
@@ -3420,7 +4019,7 @@ async function apply(args) {
   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);
@@ -3481,14 +4080,14 @@ function show(args) {
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
-      projects: knownProjects().filter((p) => name in pinsIn(p)).map((p) => basename9(p)),
-      skillMd: readFileSync6(join15(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 pinsIn(p));
+  const using = projectsUsing(name);
   info(`
 Installed in: ${using.map((p) => tildify(p)).join(", ") || "no projects"}`);
 }
@@ -3512,25 +4111,33 @@ New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(
 function link(args) {
   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) process.exitCode = 1;
-    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 = yourGlobals();
+  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));
@@ -3572,10 +4179,11 @@ function moveGlobal(args, names, yours) {
   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] }))
       }))
     );
@@ -3583,13 +4191,14 @@ 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) warnHeldLinks(c, `in ${basename9(root)}`);
+    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>");
   }
@@ -3621,7 +4230,9 @@ 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}: nothing to tidy (no extra copies or links)`);
+    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 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" });
@@ -3630,21 +4241,25 @@ function tidy(args) {
       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) => harness(id).name);
-        info(`    ${copyLabel(c, copy.dir)}${runs.length ? dim(`  run by ${runs.join(", ")}`) : ""}${c.managed === copy.dir ? dim("  (skilllib's copy)") : ""}`);
+        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.`));
+  else if (changed) info(dim(`
+Replaced copies are in ${tildify(join15(skilllibHome(), "tidy-backup"))}; \`skilllib restore\` puts them back.`));
+  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];
@@ -3673,17 +4288,22 @@ 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,
@@ -3709,10 +4329,19 @@ export {
   recordOrigin,
   librarySkills,
   librarySkillDir,
-  visibilityOf,
+  notWritable,
+  inTheWaySaid,
+  entryExists,
+  survives,
+  blindWithoutGlobal,
+  strandedLinks,
+  blindSaid,
+  trackBlocker,
   projectStatus,
   linkEverywhere,
   relinkDependency,
+  withoutForceHint,
+  addRefusal,
   addSkill,
   removeSkill,
   updateProject,
@@ -3723,7 +4352,9 @@ export {
   deleteGlobal,
   createSkill,
   listBackups,
+  movedTogether,
   restoreBackup,
+  isShared,
   gitInfo,
   relativeTo,
   installedPlugins,
@@ -3744,7 +4375,9 @@ export {
   findIssues,
   usageIssues,
   scanUsage,
+  skillOf,
   moveGlobalSkills,
+  VALUE_FLAGS,
   parseArgs,
   projectOfFactory,
   status,