skilllib 1.11.6 → 1.12.0

package/dist/{chunk-TXQQQ73J.js → chunk-57EEPVXJ.js}

@@ -48,6 +48,13 @@ function readJson(path) {
     return null;
   }
 }
+function realNative(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return null;
+  }
+}
 function realpathOrNull(path) {
   try {
     return realpathSync(path);
@@ -126,7 +133,7 @@ function localStamp(ms) {
 }
 
 // src/config.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
@@ -225,8 +232,10 @@ function installDirs(enabled, keep) {
 }
 
 // src/project.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join5, resolve as resolve3 } from "path";
+import { execFileSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join5, resolve as resolve3 } from "path";
 
 // src/versions.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
@@ -356,8 +365,7 @@ function projectHere(from = process.cwd()) {
   const root = findProjectRoot(from);
   return isProjectCandidate(root) && (existsSync4(join5(root, ".git")) || existsSync4(join5(root, MANIFEST_FILE))) ? root : null;
 }
-function readManifest(root) {
-  const path = join5(root, MANIFEST_FILE);
+function readPins(path) {
   if (!existsSync4(path)) return { skills: {} };
   let data;
   try {
@@ -393,9 +401,141 @@ function readManifest(root) {
   );
   return { ...data, skills };
 }
+function readManifest(root) {
+  const shared = readPins(join5(root, MANIFEST_FILE));
+  const file = personalPinsFile(root);
+  const personal = file ? readPins(file).skills : {};
+  const mine = Object.fromEntries(Object.entries(personal).map(([name, dep]) => [name, { ...dep, personal: true }]));
+  return { ...shared, skills: { ...mine, ...shared.skills } };
+}
+var sorted = (skills) => Object.fromEntries(Object.entries(skills).sort(([a], [b]) => a.localeCompare(b, "en")));
 function writeManifest(root, manifest) {
-  const skills = Object.fromEntries(Object.entries(manifest.skills).sort(([a], [b]) => a.localeCompare(b, "en")));
-  writeState(join5(root, MANIFEST_FILE), { ...manifest, skills });
+  const shared = Object.fromEntries(Object.entries(manifest.skills).filter(([, d]) => !d.personal));
+  const mine = Object.fromEntries(Object.entries(manifest.skills).flatMap(([name, d]) => d.personal ? [[name, withoutMark(d)]] : []));
+  const path = join5(root, MANIFEST_FILE);
+  const onDisk = readPins(path).skills;
+  const leftEmpty = !Object.keys(shared).length && Object.keys(mine).length > 0 && existsSync4(path) && gitIn(root, ["ls-files", "--", MANIFEST_FILE]) === "";
+  if (leftEmpty) rmSync3(path, { force: true });
+  else if (existsSync4(path) || Object.keys(shared).length) writeChanged(path, { ...manifest, skills: sorted(shared) });
+  const file = personalPinsFile(root);
+  if (!file) {
+    if (Object.keys(mine).length) throw new Error(`${root} isn't the top folder of a git repo, so it can't have personal pins`);
+    return;
+  }
+  for (const [name, dep] of Object.entries(readPins(file).skills)) if (onDisk[name] && manifest.skills[name] && !manifest.skills[name].personal) mine[name] = dep;
+  if (Object.keys(mine).length) writeChanged(file, { ...pinsHeader(repoOf(root)), skills: sorted(mine) });
+  else rmSync3(file, { force: true });
+  excludePersonal(root, mine);
+}
+function writeChanged(path, data) {
+  try {
+    if (JSON.stringify(JSON.parse(readFileSync3(path, "utf-8"))) === JSON.stringify(data)) return;
+  } catch {
+  }
+  writeState(path, data);
+}
+function withoutMark(dep) {
+  const { personal: _, ...rest } = dep;
+  return rest;
+}
+function hasPins(root) {
+  if (existsSync4(join5(root, MANIFEST_FILE))) return true;
+  const file = personalPinsFile(root);
+  return !!file && existsSync4(file);
+}
+function personalPinsDir() {
+  return join5(skilllibHome(), "pins");
+}
+function gitIn(root, args) {
+  try {
+    return execFileSync("git", args, { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return null;
+  }
+}
+function normalizeRemote(url) {
+  let s = url.trim();
+  const scp = s.match(/^(?:[^/@:]+@)?([^/:\\]{2,}):(?!\/)(.*)$/);
+  if (scp) s = `${scp[1]}/${scp[2]}`;
+  else s = s.replace(/^[a-z+]+:\/\//i, "").replace(/^[^/@]+@/, "").replace(/^([^/:]+):\d+\//, "$1/");
+  s = s.replace(/\.git\/?$/, "").replace(/\/+$/, "");
+  return s.replace(/^[^/]*/, (host) => host.toLowerCase());
+}
+var repos = /* @__PURE__ */ new Map();
+var changedAt = (path) => statSync3(path, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+function repoOf(root) {
+  const real = realPath(root);
+  const hit = repos.get(real);
+  if (hit && (hit.config ? changedAt(hit.config) === hit.seen : !existsSync4(join5(root, ".git")))) return hit.repo;
+  const out2 = gitIn(root, ["rev-parse", "--show-prefix", "--git-common-dir"])?.split("\n");
+  if (!out2) {
+    repos.set(real, { repo: null, config: null, seen: 0 });
+    return null;
+  }
+  const common = realNative(resolve3(root, out2[1].trim())) ?? resolve3(root, out2[1].trim());
+  const folder = basename2(common) === ".git" ? dirname2(common) : common;
+  const config = join5(common, "config");
+  const seen = changedAt(config);
+  let repo = null;
+  if (out2[0] === "") {
+    const urls = (gitIn(root, ["config", "--get-regexp", "^remote\\..*\\.url$"]) ?? "").split("\n").filter(Boolean).map((l) => l.split(" "));
+    const url = (urls.find(([k]) => k === "remote.origin.url") ?? urls[0])?.[1];
+    const remote = url ? normalizeRemote(url) : void 0;
+    repo = { file: pinsFileFor(root, remote, folder), folder, common, ...remote ? { remote } : {}, root };
+  }
+  repos.set(real, { repo, config, seen });
+  return repo;
+}
+var firstCommit = (root) => gitIn(root, ["rev-list", "--max-parents=0", "HEAD"])?.split("\n")[0] || null;
+function pinsFileFor(root, remote, folder) {
+  const name = remote ?? `local-${basename2(folder)}`;
+  const slug = name.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  const file = join5(personalPinsDir(), `${slug}-${createHash2("sha1").update(remote ?? folder).digest("hex").slice(0, 8)}.json`);
+  if (existsSync4(file) || !existsSync4(personalPinsDir())) return file;
+  for (const other of readdirSync2(personalPinsDir()).filter((f) => f.endsWith(".json"))) {
+    const at = join5(personalPinsDir(), other);
+    const theirs = readJson(at);
+    if (theirs?.path === folder && (theirs.first ? theirs.first === firstCommit(root) : !theirs.remote)) {
+      renameSync2(at, file);
+      break;
+    }
+  }
+  return file;
+}
+var pinsHeader = (repo) => ((first) => ({ ...repo.remote ? { remote: repo.remote } : {}, path: repo.folder, ...first ? { first } : {} }))(firstCommit(repo.root));
+function personalPinsFile(root) {
+  return repoOf(root)?.file ?? null;
+}
+function personalPins(root) {
+  const file = personalPinsFile(root);
+  return file ? readPins(file).skills : {};
+}
+function dropPersonalPin(root, name) {
+  const file = personalPinsFile(root);
+  if (!file) return;
+  const { [name]: _, ...rest } = readPins(file).skills;
+  if (Object.keys(rest).length) writeChanged(file, { ...pinsHeader(repoOf(root)), skills: sorted(rest) });
+  else rmSync3(file, { force: true });
+  excludePersonal(root);
+}
+var EXCLUDE_START = "# skilllib: personal skills (kept by skilllib; don't edit)";
+var EXCLUDE_END = "# end skilllib";
+function excludePersonal(root, skills = Object.fromEntries(Object.entries(readManifest(root).skills).filter(([, d]) => d.personal))) {
+  const repo = repoOf(root);
+  if (!repo?.file) return;
+  const file = join5(repo.common, "info", "exclude");
+  const text = existsSync4(file) ? readFileSync3(file, "utf-8") : "";
+  const lines = text.split("\n");
+  const start = lines.indexOf(EXCLUDE_START);
+  const end = start === -1 ? -1 : lines.indexOf(EXCLUDE_END, start);
+  const rest = start === -1 ? lines : [...lines.slice(0, start), ...lines.slice(end === -1 ? start + 1 : end + 1)];
+  while (rest.length && rest[rest.length - 1] === "") rest.pop();
+  const paths = Object.entries(skills).flatMap(([name, d]) => [d.dir ?? PROJECT_SKILLS_DIR, ...d.links ?? []].map((dir) => `/${dir}/${name.replace(/[[\]*?\\]/g, "\\$&")}`));
+  const block = paths.length ? [EXCLUDE_START, ...[...new Set(paths)].sort(), EXCLUDE_END] : [];
+  const next = [...rest, ...rest.length && block.length ? [""] : [], ...block].join("\n") + (rest.length || block.length ? "\n" : "");
+  if (next === text) return;
+  mkdirSync3(dirname2(file), { recursive: true });
+  writeFileSync2(file, next);
 }
 function projectsFile() {
   return join5(skilllibHome(), "projects.json");
@@ -454,8 +594,9 @@ function configFile() {
   return join6(skilllibHome(), "config.json");
 }
 function readConfig() {
-  const data = readState(configFile()) ?? {};
-  return { ...data, roots: data.roots ?? [], hidden: data.hidden ?? [] };
+  const { agentsDirOk, ...data } = readState(configFile()) ?? {};
+  const allowTracked = [.../* @__PURE__ */ new Set([...data.allowTracked ?? [], ...agentsDirOk ?? []])].sort();
+  return { ...data, roots: data.roots ?? [], hidden: data.hidden ?? [], ...allowTracked.length ? { allowTracked } : {} };
 }
 function writeConfig(config) {
   writeState(configFile(), config);
@@ -466,7 +607,7 @@ function expandHome(path) {
 function addRoot(path) {
   const root = expandHome(path);
   if (!existsSync5(root)) throw new Error(`${tildify(root)} doesn't exist`);
-  if (!statSync3(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
+  if (!statSync4(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
   const config = readConfig();
   if (!config.roots.includes(root)) writeConfig({ ...config, roots: [...config.roots, root].sort() });
   return root;
@@ -495,7 +636,7 @@ function findProjects(dir, depth = 4) {
   }
   let entries = [];
   try {
-    entries = readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !SKIP_DIRS.has(d.name)).map((d) => join6(dir, d.name));
+    entries = readdirSync3(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !SKIP_DIRS.has(d.name)).map((d) => join6(dir, d.name));
   } catch {
     return [];
   }
@@ -521,7 +662,10 @@ function setHarnesses(ids) {
 }
 function allowTrackedLinks(root) {
   const config = readConfig();
-  writeConfig({ ...config, agentsDirOk: [.../* @__PURE__ */ new Set([...config.agentsDirOk ?? [], root])].sort() });
+  writeConfig({ ...config, allowTracked: [.../* @__PURE__ */ new Set([...config.allowTracked ?? [], root])].sort() });
+}
+function allowsTrackedLinks(root) {
+  return readConfig().allowTracked?.includes(root) ?? false;
 }
 function keptGlobal() {
   return new Set(readConfig().keepGlobal ?? []);
@@ -538,17 +682,17 @@ function setKeepGlobal(names, keep) {
 }
 
 // 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 { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } 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, 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";
+import { execFileSync as execFileSync2 } from "child_process";
+import { cpSync as cpSync2, existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync5, readFileSync as readFileSync4, readlinkSync as readlinkSync2, renameSync as renameSync3, rmSync as rmSync4, symlinkSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename4, 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";
-import { basename as basename2, join as join7, resolve as resolve5, sep as sep3 } from "path";
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readlinkSync } from "fs";
+import { basename as basename3, join as join7, resolve as resolve5, sep as sep3 } from "path";
 import { tmpdir } from "os";
 function skillsShLock() {
   return readJson(join7(userHome(), ".agents", ".skill-lock.json"))?.skills ?? {};
@@ -557,7 +701,7 @@ function projectSkillsLock(root) {
   return readJson(join7(root, "skills-lock.json"))?.skills ?? {};
 }
 function vendorSkill(path, kind, origin, harnesses) {
-  return { name: basename2(path), kind, origin, path, description: readSkillInfo(path).description, movable: false, broken: false, harnesses, links: [] };
+  return { name: basename3(path), kind, origin, path, description: readSkillInfo(path).description, movable: false, broken: false, harnesses, links: [] };
 }
 function harnessesReading(dir, enabled) {
   const real = realPath(dir);
@@ -588,7 +732,7 @@ function globalFolderSkills(enabled) {
   const agentsDir = join7(userHome(), ".agents", "skills");
   const entries = globalSkillDirs().flatMap((dir) => {
     if (!isDir(dir)) return [];
-    return readdirSync3(dir).filter((name) => !name.startsWith(".") && name !== "synced").flatMap((name) => {
+    return readdirSync4(dir).filter((name) => !name.startsWith(".") && name !== "synced").flatMap((name) => {
       const path = join7(dir, name);
       const isLink2 = lstatSync(path).isSymbolicLink();
       const broken = !existsSync6(join7(path, "SKILL.md"));
@@ -656,7 +800,7 @@ function claudeAiSkills(enabled) {
     byReal.set(real, entry);
   }
   return [...byReal.values()].flatMap(
-    ({ dir, readers }) => (isDir(dir) ? readdirSync3(dir) : []).filter((d) => !d.startsWith(".")).flatMap(
+    ({ dir, readers }) => (isDir(dir) ? readdirSync4(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))))
     )
   );
@@ -700,8 +844,8 @@ 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(".") && isDir(join7(syncedDir, b))).flatMap(
-    (bucket) => readdirSync3(join7(syncedDir, bucket), { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => {
+  const fromSynced = claude2 && existsSync6(syncedDir) ? readdirSync4(syncedDir).filter((b) => !b.startsWith(".") && isDir(join7(syncedDir, b))).flatMap(
+    (bucket) => readdirSync4(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;
       if (enabled[`${name}@synced`] === false) return [];
@@ -736,7 +880,7 @@ function libraryOrigins() {
 function recordOrigin(name, origin) {
   const origins = libraryOrigins();
   if (origins[name] === origin) return;
-  mkdirSync3(skilllibHome(), { recursive: true });
+  mkdirSync4(skilllibHome(), { recursive: true });
   writeState(originsFile(), { ...origins, [name]: origin });
 }
 function originFor(dir) {
@@ -749,14 +893,14 @@ function originFor(dir) {
   if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
   const project = dir.split(/[\\/]\.(?:claude|agents|grok|cursor|codex)[\\/]skills[\\/]/)[0];
   if (!project || project === dir) return dir;
-  const locked = projectSkillsLock(project)[basename2(dir)]?.source;
-  return locked ? `skills.sh: ${locked}` : `project: ${basename2(project)}`;
+  const locked = projectSkillsLock(project)[basename3(dir)]?.source;
+  return locked ? `skills.sh: ${locked}` : `project: ${basename3(project)}`;
 }
 
 // src/library.ts
 function librarySkills() {
   return skillDirsIn(libraryDir()).map((dir) => ({
-    name: basename3(dir),
+    name: basename4(dir),
     description: readSkillInfo(dir).description,
     dir
   }));
@@ -840,13 +984,6 @@ 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;
 }
@@ -854,10 +991,10 @@ 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);
+    const leaf = basename4(p);
     try {
       lstatSync2(join8(dir, leaf));
-      const names = readdirSync4(dir);
+      const names = readdirSync5(dir);
       return join8(dir, names.includes(leaf) ? leaf : names.find((n) => n.toLowerCase() === leaf.toLowerCase()) ?? leaf);
     } catch {
       return join8(dir, leaf);
@@ -925,11 +1062,11 @@ function blindWithoutGlobal(name, copies, roots, nestedOf = (root) => nestedEntr
   };
   return [...byWho.values()].filter((b) => !servedAbove(b));
 }
-function strandedLinks(name, copies, roots, label = basename3) {
+function strandedLinks(name, copies, roots, label = basename4) {
   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)));
+  const once = (p) => ((k) => seen.has(k) ? false : (seen.add(k), true))(join8(realNative(dirname3(p)) ?? dirname3(p), basename4(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))
@@ -942,7 +1079,7 @@ function strandedLinks(name, copies, roots, label = basename3) {
 function copiesDiffer(paths) {
   return new Set(paths.map((p) => treeHash(p)).filter((h) => h !== null)).size > 1;
 }
-function blindSaid(name, blind, label = basename3) {
+function blindSaid(name, blind, label = basename4) {
   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)}`] : []))];
@@ -955,14 +1092,14 @@ function blindSaid(name, blind, label = basename3) {
   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 repos2 = 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)))]) : []
+    ...repos2.length ? ((names) => [`give ${names.join(", ")} ${names.length === 1 ? "a copy of its own" : "their own copies"} (skilllib add, sync or link there)`])([...new Set(repos2.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)`;
 }
@@ -997,7 +1134,7 @@ function pinsSkill(root, name) {
 }
 function isGitTracked(root, dir) {
   try {
-    const out2 = execFileSync("git", ["ls-files", "--", dir], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    const out2 = execFileSync2("git", ["ls-files", "--", dir], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
     return out2.trim().length > 0;
   } catch {
     return false;
@@ -1024,7 +1161,8 @@ function projectStatus(root) {
       latest: latest?.version ?? null,
       location,
       path,
-      visibility: visibilityOf(root, name, enabled)
+      visibility: visibilityOf(root, name, enabled),
+      ...dep.personal ? { personal: true } : {}
     };
   });
   const seen = new Set(Object.keys(skills));
@@ -1033,7 +1171,7 @@ function projectStatus(root) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of ALL_PROJECT_DIRS.filter((d) => writableDir(root, d))) {
     for (const path of skillDirsIn(join8(root, dir))) {
-      const name = basename3(path);
+      const name = basename4(path);
       if (seen.has(name)) continue;
       byName.set(name, [...byName.get(name) ?? [], path]);
     }
@@ -1089,7 +1227,7 @@ function nestedEntries(root, { depth = PACKAGE_DEPTH, enabled = enabledHarnesses
   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 name = basename4(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)) }];
     })
@@ -1102,7 +1240,7 @@ function packageDirs(root, depth = PACKAGE_DEPTH) {
   const walk = (dir, left) => {
     let subs = [];
     try {
-      subs = readdirSync4(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !BUILD_DIRS.has(d.name)).map((d) => join8(dir, d.name));
+      subs = readdirSync5(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !BUILD_DIRS.has(d.name)).map((d) => join8(dir, d.name));
     } catch {
       return;
     }
@@ -1128,11 +1266,14 @@ function sharedByGit(root, location, name) {
   const copy = `${location}/${name}`;
   if (isGitTracked(root, copy)) return true;
   if (!isGitTracked(root, location)) return false;
+  return !gitIgnores(root, copy);
+}
+function gitIgnores(root, rel) {
   try {
-    execFileSync("git", ["check-ignore", "-q", "--no-index", "--", copy], { cwd: root, stdio: "ignore" });
-    return false;
-  } catch {
+    execFileSync2("git", ["check-ignore", "-q", "--no-index", "--", rel], { cwd: root, stdio: "ignore" });
     return true;
+  } catch {
+    return false;
   }
 }
 function linkEverywhere(root, name, location, { allowTracked = false, dryRun = false } = {}) {
@@ -1155,19 +1296,19 @@ function linkEverywhere(root, name, location, { allowTracked = false, dryRun = f
       stuck(`${dir}/${name}`);
       continue;
     }
-    if (isGitTracked(root, dir)) {
+    if (isGitTracked(root, dir) && !gitIgnores(root, `${dir}/${name}`)) {
       if (!(shared ??= sharedByGit(root, location, name))) {
         if (!result.uncommitted.includes(dir)) result.uncommitted.push(dir);
         continue;
       }
-      if (!allowTracked && !readConfig().agentsDirOk?.includes(root)) {
+      if (!allowTracked && !allowsTrackedLinks(root)) {
         if (!result.blocked.includes(dir)) result.blocked.push(dir);
         continue;
       }
     }
     if (!dryRun) {
       if (broken) unlinkSync(link2);
-      mkdirSync4(join8(root, dir), { recursive: true });
+      mkdirSync5(join8(root, dir), { recursive: true });
       linkDir(join8(root, location, name), link2);
     }
     result.created.push(dir);
@@ -1186,11 +1327,12 @@ function relinkDependency(root, name, { allowTracked = false } = {}) {
   const manifest = readManifest(root);
   const dep = manifest.skills[name];
   if (!dep) return { created: [], blocked: [], uncommitted: [], inTheWay: [] };
+  if (dep.personal) excludePersonal(root, { ...personalOf(manifest), [name]: { ...dep, links: [...ALL_PROJECT_DIRS] } });
   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])] };
     writeManifest(root, manifest);
-  }
+  } else if (dep.personal) excludePersonal(root);
   return result;
 }
 function linkAll(root, { allowTracked = false, names } = {}) {
@@ -1237,17 +1379,30 @@ 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 } = {}) {
+function addSkill(root, name, { force = false, version, allowTracked = false, personal } = {}) {
   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);
+  const before = personal !== void 0 && version === void 0 ? readManifest(root).skills[name] : void 0;
+  const moving = !!before && !!before.personal !== personal;
+  const keep = moving ? versionForHash(name, before.hash) : null;
+  if (moving && !keep) return { name, action: "skipped", reason: `your library has no copy of the version it pins, so its pin can't move as it is: skilllib update ${name} first` };
+  const target = keep ?? (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;
+  const mine = pinsWhere(root, recorded, personal);
+  if (typeof mine === "string") return { name, action: "skipped", reason: mine };
+  const committed = [primary, ...recorded?.links ?? []].find((d) => isGitTracked(root, `${d}/${name}`));
+  if (mine && !recorded?.personal && committed)
+    return { name, action: "skipped", reason: `${committed}/${name} is committed to git, so it can't be personal: remove it from git first (git rm -r --cached '${`${committed}/${name}`.replace(/'/g, "'\\''")}')` };
+  if (mine || recorded?.personal) {
+    const { [name]: _, ...others } = personalOf(manifest);
+    excludePersonal(root, mine ? { ...others, [name]: { version: target.version, hash: target.hash, dir: primary, links: wantedLinks } } : others);
+  }
   let backedUp;
   const copied = local !== target.hash || isLink(to);
   if (copied) {
-    mkdirSync4(join8(root, primary), { recursive: true });
+    mkdirSync5(join8(root, primary), { recursive: true });
     if (isLink(to)) unlinkSync(to);
     else if (local !== null && versionForHash(name, local) === null) backedUp = stash(to, "edit-backup");
     copySkill(versionDir(name, target.version), to);
@@ -1258,11 +1413,19 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
   const inTheWay = [];
   let shared;
   let relinked = false;
+  const toShared = !!recorded?.personal && !mine;
+  const heldBack = (dir) => {
+    if (!isGitTracked(root, dir) || gitIgnores(root, `${dir}/${name}`)) return false;
+    if (!(shared ??= sharedByGit(root, primary, name))) return uncommitted.push(dir), true;
+    if (!allowTracked && !allowsTrackedLinks(root)) return blocked.push(dir), true;
+    return false;
+  };
   for (const dir of wantedLinks) {
     const link2 = join8(root, dir, name);
     const slot = slotAt(link2, to);
     if (slot === "ok") {
-      links.push(dir);
+      if (toShared && isLink(link2) && heldBack(dir)) unlinkSync(link2);
+      else links.push(dir);
       continue;
     }
     if (slot === "taken") {
@@ -1270,18 +1433,9 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
       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);
-        continue;
-      }
-      if (!allowTracked && !readConfig().agentsDirOk?.includes(root)) {
-        blocked.push(dir);
-        continue;
-      }
-    }
+    if ((toShared || !recorded?.links?.includes(dir)) && heldBack(dir)) continue;
     if (isLink(link2)) unlinkSync(link2);
-    mkdirSync4(join8(root, dir), { recursive: true });
+    mkdirSync5(join8(root, dir), { recursive: true });
     linkDir(to, link2);
     links.push(dir);
     relinked = true;
@@ -1290,9 +1444,11 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
     version: target.version,
     hash: target.hash,
     ...primary !== PROJECT_SKILLS_DIR ? { dir: primary } : {},
-    ...links.length ? { links } : {}
+    ...links.length ? { links } : {},
+    ...mine ? { personal: true } : {}
   };
   writeManifest(root, manifest);
+  const moved = recorded && !!recorded.personal !== mine ? mine ? "personal" : "shared" : void 0;
   const from = recorded ? versionForHash(name, recorded.hash)?.version ?? recorded.version : void 0;
   return {
     name,
@@ -1308,9 +1464,16 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
     ...blocked.length ? { blocked } : {},
     ...uncommitted.length ? { uncommitted } : {},
     ...inTheWay.length ? { inTheWay } : {},
-    ...backedUp ? { backedUp } : {}
+    ...backedUp ? { backedUp } : {},
+    ...moved ? { moved } : {}
   };
 }
+function pinsWhere(root, recorded, personal) {
+  const want = personal ?? (recorded ? !!recorded.personal : !existsSync7(join8(root, MANIFEST_FILE)));
+  if (!want || personalPinsFile(root)) return want;
+  return personal ? "only the top folder of a git repo can have personal pins" : false;
+}
+var personalOf = (manifest) => Object.fromEntries(Object.entries(manifest.skills).filter(([, d]) => d.personal));
 function removeSkill(root, name, { force = false } = {}) {
   const manifest = readManifest(root);
   const recorded = manifest.skills[name];
@@ -1352,13 +1515,14 @@ function removeSkill(root, name, { force = false } = {}) {
     };
   unlinkOwn();
   const backedUp = local !== null && !inLibrary ? stash(dir, "edit-backup") : void 0;
-  if (!backedUp) rmSync3(dir, { recursive: true, force: true });
+  if (!backedUp) rmSync4(dir, { recursive: true, force: true });
   delete manifest.skills[name];
   writeManifest(root, manifest);
   const left = [...leftLinks, ...takenLinks];
   return { name, action: "removed", ...left.length ? { reason: left.join("; ") } : {}, ...backedUp ? { backedUp } : {} };
 }
 function syncProject(root, { force = false, names } = {}) {
+  excludePersonal(root);
   return Object.keys(readManifest(root).skills).filter((name) => !names || names.includes(name)).flatMap((name) => syncSkill(root, name, { force }));
 }
 function syncSkill(root, name, { force = false } = {}) {
@@ -1374,7 +1538,7 @@ function syncSkill(root, name, { force = false } = {}) {
   if (typeof version === "string") return [{ name, action: "skipped", reason: version }];
   if (local !== null && local !== dep.hash && versionForHash(name, local) === null && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
   const backedUp = local !== null && versionForHash(name, local) === null ? stash(copy, "edit-backup") : void 0;
-  mkdirSync4(dirname3(copy), { recursive: true });
+  mkdirSync5(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;
@@ -1396,7 +1560,7 @@ function relinkPinned(root, name, dep) {
     if (realpathOrNull(link2) === realpathOrNull(to)) continue;
     if (isLink(link2)) unlinkSync(link2);
     else if (entryExists(link2)) return { name, action: "skipped", reason: `${dir}/${name} is in the way of its link: move it, then sync` };
-    mkdirSync4(join8(root, dir), { recursive: true });
+    mkdirSync5(join8(root, dir), { recursive: true });
     linkDir(to, link2);
   }
   return { name, action: "relinked", to: versionForHash(name, dep.hash)?.version ?? dep.version };
@@ -1426,13 +1590,13 @@ function updateProject(root, names, { force = false, allowTracked = false } = {}
   });
 }
 function importSkill(dir, { force = false } = {}) {
-  const name = basename3(dir);
+  const name = basename4(dir);
   const to = librarySkillDir(name);
   const existing = treeHash(to);
   const incoming = treeHash(dir);
   if (existing === incoming) return { name, status: "unchanged" };
   if (existing !== null && !force) return { name, status: "exists" };
-  mkdirSync4(libraryDir(), { recursive: true });
+  mkdirSync5(libraryDir(), { recursive: true });
   const origin = existing !== null && libraryOrigins()[name] ? null : originFor(dir);
   if (existing !== null) {
     forgetLatest(name);
@@ -1452,21 +1616,21 @@ function readBackupIndex(bucket) {
 }
 function move(from, to) {
   try {
-    renameSync2(from, to);
+    renameSync3(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
     cpSync2(from, to, { recursive: true, verbatimSymlinks: true });
-    rmSync3(from, { recursive: true, force: true });
+    rmSync4(from, { recursive: true, force: true });
   }
 }
 function stash(dir, bucket) {
   let at = Date.now();
-  const entryAt = (ms) => `${basename3(dir)}-${new Date(ms).toISOString().replace(/[:.]/g, "-")}`;
+  const entryAt = (ms) => `${basename4(dir)}-${new Date(ms).toISOString().replace(/[:.]/g, "-")}`;
   while (entryExists(join8(skilllibHome(), bucket, entryAt(at)))) at++;
   const entry = entryAt(at);
   const target = join8(skilllibHome(), bucket, entry);
   const index = readBackupIndex(bucket);
-  mkdirSync4(join8(skilllibHome(), bucket), { recursive: true });
+  mkdirSync5(join8(skilllibHome(), bucket), { recursive: true });
   move(dir, target);
   writeState(backupIndexFile(bucket), { ...index, [entry]: dir });
   return target;
@@ -1483,7 +1647,7 @@ function projectsUsing(name) {
 }
 function deleteLibrarySkill(name) {
   const using = projectsUsing(name);
-  if (using.length > 0) return { ok: false, reason: `still installed in ${using.map((p) => basename3(p)).join(", ")}` };
+  if (using.length > 0) return { ok: false, reason: `still installed in ${using.map((p) => basename4(p)).join(", ")}` };
   const dir = librarySkillDir(name);
   if (!existsSync7(dir)) return { ok: false, reason: "not in the library" };
   forgetLatest(name);
@@ -1493,7 +1657,7 @@ function deleteGlobal(path, links = []) {
   return unloadGlobal(path, links, { requireLibrary: false });
 }
 function unloadGlobal(path, links = [], { requireLibrary = true } = {}) {
-  const name = basename3(path);
+  const name = basename4(path);
   if (!entryExists(path) || name === "synced") return { ok: false, reason: "not a global skill" };
   const broken = !existsSync7(join8(path, "SKILL.md"));
   if (requireLibrary && !broken && latestVersion(name) === null) return { ok: false, reason: "import it into the library first" };
@@ -1503,7 +1667,7 @@ function unloadGlobal(path, links = [], { requireLibrary = true } = {}) {
   return { ok: true, movedTo };
 }
 function linkGlobal(path, agents) {
-  const name = basename3(path);
+  const name = basename4(path);
   const linked = [];
   const skipped = [];
   for (const dir of new Set(agents.map((id) => harness(id).globalDirs()[0]))) {
@@ -1513,7 +1677,7 @@ function linkGlobal(path, agents) {
       if (realpathOrNull(link2) !== realpathOrNull(path)) skipped.push(link2);
       continue;
     }
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
     linkDir(realpathOrNull(path) ?? path, join8(realpathOrNull(dir) ?? dir, name));
     linked.push(link2);
   }
@@ -1523,8 +1687,8 @@ function createSkill(name, description) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) return { ok: false, reason: "use lowercase letters, digits and dashes" };
   const dir = librarySkillDir(name);
   if (existsSync7(dir)) return { ok: false, reason: `${name} already exists` };
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync2(
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync3(
     join8(dir, "SKILL.md"),
     // JSON strings are valid YAML: a description with ": " or "#" stays one value.
     `---
@@ -1545,7 +1709,7 @@ function listBackups() {
     const dir = join8(skilllibHome(), kind);
     if (!existsSync7(dir)) return [];
     const index = readBackupIndex(kind);
-    return readdirSync4(dir).flatMap((entry) => {
+    return readdirSync5(dir).flatMap((entry) => {
       const match = entry.match(/^(.*)-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-\d{3}Z$/);
       if (!match) return [];
       const name = match[1];
@@ -1568,9 +1732,9 @@ function restoreBackup(backup) {
   const to = backup.from;
   if (!to) return { ok: false, reason: `skilllib doesn't know where it came from; its files are in ${tildify(backup.path)}` };
   if (backup.kind === "tidy-backup" && isLink(to)) unlinkSync(to);
-  if (backup.kind === "edit-backup" && !isLink(to) && versionForHash(backup.name, treeHash(to) ?? "") !== null) rmSync3(to, { recursive: true, force: true });
+  if (backup.kind === "edit-backup" && !isLink(to) && versionForHash(backup.name, treeHash(to) ?? "") !== null) rmSync4(to, { recursive: true, force: true });
   if (entryExists(to)) return { ok: false, reason: `${backup.name} already exists there` };
-  mkdirSync4(join8(to, ".."), { recursive: true });
+  mkdirSync5(join8(to, ".."), { recursive: true });
   move(backup.path, to);
   forgetLatest(backup.name);
   return { ok: true, to };
@@ -1606,13 +1770,13 @@ function installAgentSkill(enabled = enabledHarnesses()) {
   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");
+  mkdirSync6(primary, { recursive: true });
+  writeFileSync4(join9(primary, "SKILL.md"), shippedSkill());
+  writeFileSync4(join9(primary, OWN_SKILL_MARKER), "Installed by skilllib. `skilllib agent-skill remove` removes it.\n");
   for (const link2 of links) {
-    if (entryExists(link2) && !isLink(link2) && isOurs(link2)) rmSync4(link2, { recursive: true, force: true });
+    if (entryExists(link2) && !isLink(link2) && isOurs(link2)) rmSync5(link2, { recursive: true, force: true });
     if (entryExists(link2)) continue;
-    mkdirSync5(join9(link2, ".."), { recursive: true });
+    mkdirSync6(join9(link2, ".."), { recursive: true });
     linkDir(primary, link2);
   }
   return { ok: true, dirs: [primary, ...links] };
@@ -1623,7 +1787,7 @@ function removeAgentSkill() {
   for (const d of removed) {
     if (!entryExists(d)) continue;
     if (lstatSync3(d).isSymbolicLink()) unlinkSync2(d);
-    else rmSync4(d, { recursive: true, force: true });
+    else rmSync5(d, { recursive: true, force: true });
   }
   return removed;
 }
@@ -1637,18 +1801,18 @@ function refreshAgentSkill() {
 // src/commands.ts
 import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
 import { parseArgs as parseFlags } from "util";
-import { basename as basename9, join as join15, resolve as resolve8, sep as sep8 } from "path";
+import { basename as basename10, 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, realpathSync as realpathSync4 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync9, realpathSync as realpathSync3 } 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 });
+    return execFileSync3("git", args, { cwd: root, encoding: "utf-8", input, stdio: ["pipe", "pipe", "ignore"], maxBuffer: 16 * 1024 * 1024 });
   } catch (err) {
     const out2 = err.stdout;
     return typeof out2 === "string" ? out2 : null;
@@ -1657,14 +1821,14 @@ function git(root, args, input) {
 function gitInfo(root, extraDirs = []) {
   let inRepo;
   try {
-    inRepo = execFileSync2("git", ["rev-parse", "--show-prefix"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    inRepo = execFileSync3("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);
+      return realpathSync3.native(p);
     } catch {
       return p;
     }
@@ -1703,23 +1867,23 @@ function relativeTo(root, path) {
 }
 
 // src/here.ts
-import { readdirSync as readdirSync8 } from "fs";
-import { basename as basename7 } from "path";
+import { readdirSync as readdirSync9 } from "fs";
+import { basename as basename8 } from "path";
 
 // src/health.ts
-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";
+import { existsSync as existsSync12, lstatSync as lstatSync4, readdirSync as readdirSync8 } from "fs";
+import { basename as basename7, 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 readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join11, resolve as resolve7 } from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync6, readFileSync as readFileSync6, statSync as statSync5, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename5, 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("."));
+    return readdirSync6(path).some((f) => !f.startsWith("."));
   } catch {
     return false;
   }
@@ -1810,23 +1974,23 @@ function installedPlugins() {
     return root ? [{ id, scope: "user", synced: false, agent: "claude-code", on: true, settingsOnly: true, root, ...describe(root) }] : [];
   });
   const syncedDir = join11(plugins, "synced");
-  const dirs = (p) => existsSync10(p) ? readdirSync5(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => join11(p, d.name)) : [];
+  const dirs = (p) => existsSync10(p) ? readdirSync6(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => join11(p, d.name)) : [];
   const fromSynced = dirs(syncedDir).flatMap(dirs).map((root) => {
-    const id = `${readJson(join11(root, ".claude-plugin", "plugin.json"))?.name ?? basename4(root)}@synced`;
+    const id = `${readJson(join11(root, ".claude-plugin", "plugin.json"))?.name ?? basename5(root)}@synced`;
     return { id, scope: null, synced: true, agent: "claude-code", on: user[id] !== false, root, ...describe(root) };
   });
   return [...fromMarketplaces, ...fromSettings, ...fromSynced];
 }
 function cursorPlugins() {
   const cache = join11(userHome(), ".cursor", "plugins", "cache");
-  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync4(join11(p, d)).isDirectory()) : [];
+  const dirs = (p) => existsSync10(p) ? readdirSync6(p).filter((d) => !d.startsWith(".") && statSync5(join11(p, d)).isDirectory()) : [];
   return dirs(cache).flatMap(
     (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
       const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
-      const root = versions.sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs)[0];
+      const root = versions.sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs)[0];
       if (!root) return [];
       const about = describe(root);
-      return [{ id: `${plugin}@${marketplace}`, scope: null, synced: false, agent: "cursor", on: null, root, ...about, version: about.version ?? basename4(root) }];
+      return [{ id: `${plugin}@${marketplace}`, scope: null, synced: false, agent: "cursor", on: null, root, ...about, version: about.version ?? basename5(root) }];
     })
   );
 }
@@ -1840,7 +2004,7 @@ function claudeBinary() {
     const candidates = ["claude", join11(userHome(), ".local", "bin", "claude"), join11(userHome(), ".claude", "local", "claude")];
     const found = candidates.find((bin) => {
       try {
-        return execFileSync3(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e4, encoding: "utf-8" }).includes("Claude Code");
+        return execFileSync4(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e4, encoding: "utf-8" }).includes("Claude Code");
       } catch {
         return false;
       }
@@ -1854,7 +2018,7 @@ function claude(args, cwd, bin = claudeBinary()) {
   if (!bin) return { ok: false, reason: `Claude Code's CLI didn't run (tried \`claude\` on your PATH and ~/.local/bin/claude); run \`claude ${args.join(" ")}\` yourself` };
   const slow = args[1] === "install" || args[1] === "update";
   try {
-    const out2 = execFileSync3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: slow ? 12e4 : 2e4, encoding: "utf-8" });
+    const out2 = execFileSync4(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: slow ? 12e4 : 2e4, encoding: "utf-8" });
     return { ok: true, out: out2 };
   } catch (err) {
     const e = err;
@@ -1870,7 +2034,7 @@ function setPluginIn(file, id, on) {
 }
 function ignoreLocalSettings(root) {
   const file = ".claude/settings.local.json";
-  const git2 = (...args) => execFileSync3("git", args, { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  const git2 = (...args) => execFileSync4("git", args, { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   try {
     git2("rev-parse", "--git-dir");
   } catch {
@@ -1889,8 +2053,8 @@ function ignoreLocalSettings(root) {
   try {
     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}
+    mkdirSync7(dirname4(exclude), { recursive: true });
+    writeFileSync5(exclude, `${before}${before && !before.endsWith("\n") ? "\n" : ""}/${git2("rev-parse", "--show-prefix")}${file}
 `);
     return ", which git now ignores via .git/info/exclude";
   } catch {
@@ -1898,7 +2062,7 @@ function ignoreLocalSettings(root) {
   }
 }
 function turnOffIn(plugin, root) {
-  const done = `${plugin.id} turned off in ${basename4(root)}; other repos keep it`;
+  const done = `${plugin.id} turned off in ${basename5(root)}; other repos keep it`;
   const bin = plugin.synced || plugin.settingsOnly ? null : claudeBinary();
   if (!bin) {
     const r2 = setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false);
@@ -1917,7 +2081,7 @@ function settingsFileOf(p) {
   return join11(p.projectPath, ".claude", p.scope === "local" ? "settings.local.json" : "settings.json");
 }
 function whereOf(p) {
-  return p.projectPath ? ` in ${basename4(p.projectPath)} (${p.scope})` : "";
+  return p.projectPath ? ` in ${basename5(p.projectPath)} (${p.scope})` : "";
 }
 function setPluginOn(p, on) {
   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" : "";
@@ -1931,7 +2095,7 @@ function setPluginOn(p, on) {
   }
   const r = setPluginIn(settingsFileOf(p), p.id, on);
   if (!r.ok) return { ok: false, message: `${p.id}: ${r.reason}` };
-  if (p.scope === "local" && p.projectPath) return { ...done, message: done.message + ignoreLocalSettings(p.projectPath) };
+  if (p.scope === "local" && p.projectPath) return { ...done, message: `${done.message}; it's in .claude/settings.local.json${ignoreLocalSettings(p.projectPath)}` };
   return done;
 }
 function uninstallPlugin(p) {
@@ -1966,31 +2130,20 @@ function removePlugin(plugin, how) {
   if (plugin.settingsOnly && how === "delete") return { ok: false, message: `${plugin.id} isn't installed, only turned on in your settings: turn it off instead` };
   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)` };
-  }
-  const wasOn = enabledPlugins(plugin.projectPath)[plugin.id] === true;
+  const uninstall = how === "delete" && !plugin.synced;
+  if (uninstall && !claudeBinary()) return { ok: false, message: `${plugin.id}: nothing changed; Claude Code's CLI didn't run (tried \`claude\` on your PATH and ~/.local/bin/claude)` };
   const yours = new Set(machineSkills().filter((m) => m.movable).map((m) => m.name));
-  const imported = plugin.skills.filter((dir) => !yours.has(basename4(dir)) && latestVersion(basename4(dir)) === null).map((dir) => importSkill(dir).name);
-  const scope = plugin.scope ? ["--scope", plugin.scope] : [];
-  const r = viaSettings ? (
-    // Synced and settings-only plugins aren't installed, so `claude plugin` can't touch them: their switch is enabledPlugins.
-    setPluginIn(join11(claudeDir(), "settings.json"), plugin.id, false)
-  ) : (
-    // --keep-data, as uninstallPlugin: its saved data stays, so a restore brings it back as it was.
-    claude(["plugin", how === "delete" ? "uninstall" : "disable", plugin.id, ...how === "delete" ? ["--keep-data"] : [], ...scope], plugin.projectPath)
-  );
+  const imported = plugin.skills.filter((dir) => !yours.has(basename5(dir)) && latestVersion(basename5(dir)) === null).map((dir) => importSkill(dir).name);
   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);
-  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}` };
+  const r = uninstall ? uninstallPlugin(plugin) : setPluginOn(plugin, false);
+  if (!r.ok) return { ok: false, message: `${r.message}${saved}` };
+  const others = uninstall ? (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 ${basename5(e.projectPath)}` : ""}`).join(", ")} stays` : "";
+  return { ok: true, message: uninstall ? `${plugin.id} removed (${plugin.scope ?? "user"} install)${saved}${left}` : `${r.message}${saved}` };
 }
 function recordRemovedPlugin(id, scope, projectPath, on = true) {
   const list2 = readState(removedFile()) ?? [];
-  mkdirSync6(skilllibHome(), { recursive: true });
+  mkdirSync7(skilllibHome(), { recursive: true });
   writeState(removedFile(), [...list2, { id, scope, ...projectPath ? { projectPath } : {}, on, at: (/* @__PURE__ */ new Date()).toISOString() }]);
 }
 function pluginBackups() {
@@ -2013,16 +2166,16 @@ function restorePlugin(backup) {
   const wasOff = records.filter(same).pop()?.on === false;
   const off = wasOff ? claude(["plugin", "disable", backup.from, "--scope", scope], projectPath) : null;
   writeState(removedFile(), records.filter((x) => !same(x)));
-  const where = `Claude Code plugins (${scope}${projectPath ? ` in ${basename4(projectPath)}` : ""}${wasOff ? off?.ok ? ", off as it was" : ", but it's on: turn it off from Plugins" : ""})`;
+  const where = `Claude Code plugins (${scope}${projectPath ? ` in ${basename5(projectPath)}` : ""}${wasOff ? off?.ok ? ", off as it was" : ", but it's on: turn it off from Plugins" : ""})`;
   return { ok: true, to: where };
 }
 function cursorPluginSkills(plugins = cursorPlugins()) {
-  return plugins.flatMap((p) => p.skills.map((path) => ({ name: basename4(path), plugin: pluginNameOf(p.id), path })));
+  return plugins.flatMap((p) => p.skills.map((path) => ({ name: basename5(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 sep6 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync7, unlinkSync as unlinkSync3 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join12, sep as sep6 } from "path";
 function entriesOf(dirs, name) {
   return dirs.flatMap((dir) => {
     const path = join12(dir, name);
@@ -2044,7 +2197,7 @@ function namesIn(dirs) {
   const names = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
     if (!isDir(dir)) continue;
-    for (const name of readdirSync6(dir)) if (!name.startsWith(".") && name !== "synced") names.add(name);
+    for (const name of readdirSync7(dir)) if (!name.startsWith(".") && name !== "synced") names.add(name);
   }
   return [...names].sort();
 }
@@ -2057,7 +2210,7 @@ function globalTidyDirs() {
 function runsFrom(id, dirsWithCopy, readsOf) {
   const reads = readsOf(id).filter((d) => dirsWithCopy.includes(d));
   if (id === "codex") return reads;
-  const pick = (d) => CURSOR_PICKS.indexOf(basename5(dirname5(d)));
+  const pick = (d) => CURSOR_PICKS.indexOf(basename6(dirname5(d)));
   return id === "cursor" ? [...reads].sort((a, b) => pick(a) - pick(b)).slice(0, 1) : reads.slice(0, 1);
 }
 function conflictOf(name, root, reals, enabled, readsOf) {
@@ -2168,7 +2321,7 @@ function gitVisibleSteps(plan, git2 = plan.root ? gitInfo(plan.root) : null) {
   if (!plan.root || !git2) return [];
   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)));
+  const recordsLink = (s) => !!dep && !dep.personal && (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" } = {}) {
@@ -2181,7 +2334,7 @@ function applyTidy(plan, { git: git2 = "keep" } = {}) {
       if (isLink(step.path)) unlinkSync3(step.path);
     } else stash(step.path, "tidy-backup");
     if (step.kind === "link" || step.kind === "replace") {
-      mkdirSync7(dirname5(step.path), { recursive: true });
+      mkdirSync8(dirname5(step.path), { recursive: true });
       linkDir(step.target, step.path);
     }
     applied.push(step);
@@ -2244,7 +2397,7 @@ function track(root, name) {
   if (c.action === "skipped") throw new Error(`${name}: ${c.reason}`);
   return c;
 }
-var installedIn = (p) => p.projectPath ? ` in ${basename6(p.projectPath)}` : "";
+var installedIn = (p) => p.projectPath ? ` in ${basename7(p.projectPath)}` : "";
 var installId = (p) => `${p.projectPath ? `${p.projectPath}:` : ""}${p.id}`;
 function summarize(where, verb, changes) {
   const done = changes.filter((c) => c.action !== "skipped");
@@ -2266,7 +2419,7 @@ var gitNote = (root, paths) => {
 };
 var agentNames = (ids) => ids.map((id) => harness(id).name).join(", ");
 function conflictIssue(c) {
-  const where = c.root ? basename6(c.root) : "your global folders";
+  const where = c.root ? basename7(c.root) : "your global folders";
   const winners = c.managed ? c.copies.filter((x) => x.dir === c.managed) : c.copies;
   const planFor = (dir) => (c.root ? planProjectTidy(c.root, { keep: { [c.name]: dir } }) : planGlobalTidy({ keep: { [c.name]: dir } })).plans.find((p) => p.name === c.name);
   const keep = (dir, git2) => () => {
@@ -2300,7 +2453,7 @@ function applyAll(plans, git2) {
   return { skills: results.filter((r) => r.applied.length).length, held: results.reduce((n, r) => n + r.held.length, 0) };
 }
 function brokenLinksIn(root, opened) {
-  const where = basename6(root);
+  const where = basename7(root);
   const tidyDirs = repoTidyDirs(root);
   const hasCopy = (name) => tidyDirs.some((d) => !isLink(join13(root, d, name)) && existsSync12(join13(root, d, name, "SKILL.md")));
   const mends = (project, dir, name) => {
@@ -2332,7 +2485,7 @@ function brokenLinksIn(root, opened) {
   return folders2.flatMap(({ dir, top, own, real }) => {
     const folder = join13(root, dir);
     if (!isDir(folder) || notWritable(root, dir)) return [];
-    return readdirSync7(folder).flatMap((name) => {
+    return readdirSync8(folder).flatMap((name) => {
       const path = join13(folder, name);
       if (!isLink(path) || isDir(path) || top && (dir !== GROK_SKILLS_DIR && hasCopy(name) || syncMends(dir, name))) return [];
       const remove2 = {
@@ -2371,24 +2524,24 @@ function grokDiffers(projects2, machine, statusOf) {
   const issue = (root, name, grokCopy, other) => ({
     id: `grok-differs:${root ?? "global"}:${name}`,
     severity: "suggestion",
-    title: `${name}${root ? ` in ${basename6(root)}` : ""}: Grok runs a different copy`,
+    title: `${name}${root ? ` in ${basename7(root)}` : ""}: Grok runs a different copy`,
     detail: `Grok reads ${grokCopy} first; your other agents run ${other}, and the two differ. skilllib doesn't change Grok's folder: update or remove that copy there to make them match.`,
     at: rows(root, [name])
   });
   const grokGlobal = join13(grokDir(), "skills");
   const global = skillDirsIn(grokGlobal).filter((path) => !isLink(path)).flatMap((path) => {
-    const name = basename6(path);
+    const name = basename7(path);
     const other = machine.find((m) => m.name === name && m.movable && !m.broken && m.harnesses.some((id) => id !== "grok") && realPath(dirname6(m.path)) !== realPath(grokGlobal));
     return other && treeHash(other.path) !== treeHash(path) ? [issue(null, name, tildify(path), tildify(other.path))] : [];
   });
-  const repos = projects2.flatMap(
+  const repos2 = projects2.flatMap(
     (root) => skillDirsIn(join13(root, GROK_SKILLS_DIR)).filter((path) => !isLink(path)).flatMap((path) => {
-      const name = basename6(path);
+      const name = basename7(path);
       const other = statusOf(root).find((s) => s.name === name && !s.path.startsWith(join13(root, GROK_SKILLS_DIR)));
       return other && treeHash(other.path) !== treeHash(path) ? [issue(root, name, `${GROK_SKILLS_DIR}/${name}`, relativeTo(root, other.path))] : [];
     })
   );
-  return [...global, ...repos];
+  return [...global, ...repos2];
 }
 function findIssues(roots, machine, libraryNames, statusOf = projectStatus, loadedIn = (root) => skillsLoadedIn(root, machine), nestedOf = nestedSkills) {
   gitMemo = /* @__PURE__ */ new Map();
@@ -2396,8 +2549,8 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   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.`,
+    title: `${basename7(root)}: skilllib.json can't be read`,
+    detail: `${reason}. Until it's fixed, skilllib leaves ${basename7(root)} out.`,
     at: [{ root, skill: "" }]
   }));
   const statuses = new Map(projects2.map((root) => [root, statusOf(root)]));
@@ -2448,7 +2601,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   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), ...knownProjects().flatMap((p) => Object.keys(pinsIn(p)))]);
   const repoChoices = (plugin, root, names) => {
-    const where = basename6(root);
+    const where = basename7(root);
     const copies = statuses.get(root).filter((s) => names.includes(s.name));
     const allManaged = names.every((n) => copies.some((c) => c.name === n && removesClean(root, c)));
     const committed = gitNote(root, copies.map((s) => s.path)) !== "";
@@ -2474,7 +2627,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   };
   const machinePlugins = claudePlugins(machine);
   for (const plugin of machinePlugins) {
-    const names = plugin.skills.map((p) => basename6(p));
+    const names = plugin.skills.map((p) => basename7(p));
     const inRepos = projects2.filter((root) => pluginAgentsIn(plugin, root).has("claude-code")).map((root) => [root, namesIn2(root).filter((n) => names.includes(n))]).filter(([, d]) => d.length);
     const cursorRepos = enabledHarnesses().includes("claude-code") ? projects2.filter((root) => !pluginAgentsIn(plugin, root).has("claude-code") && pluginAgentsIn(plugin, root).has("cursor")).map((root) => [root, namesIn2(root, "cursor").filter((n) => names.includes(n))]).filter(([, d]) => d.length) : [];
     const claudeYours = /* @__PURE__ */ new Set([...globalYours, ...inRepos.flatMap(([, d]) => d)]);
@@ -2491,7 +2644,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
     const off = { label: `Turn the plugin ${plugin.id} off`, hint: "stays installed", run: () => orThrow(removePlugin(plugin, "off")) };
     const bothLoad = dupes.filter((n) => loadedYours.has(n));
     const claudeBoth = dupes.filter((n) => claudeYours.has(n));
-    const cursorWheres = cursorRepos.map(([root]) => basename6(root));
+    const cursorWheres = cursorRepos.map(([root]) => basename7(root));
     const notInstalled = dupes.filter((n) => !installedYours.has(n));
     issues.push({
       id: `plugin:${plugin.id}`,
@@ -2505,7 +2658,7 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
         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(", ")}.` : ""
+        inRepos.length ? `Or keep it and turn it off only in ${inRepos.map(([root]) => basename7(root)).join(", ")}.` : ""
       ].filter(Boolean).join(" "),
       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.
@@ -2528,10 +2681,10 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
     }
   const machinePluginSkills = new Set(machinePlugins.flatMap((p) => p.skills));
   for (const root of projects2) {
-    const where = basename6(root);
+    const where = basename7(root);
     const repoOnly = loadedHere.get(root).filter((m) => m.kind === "plugin" && !machinePluginSkills.has(m.path));
     for (const plugin of enabledHarnesses().includes("claude-code") ? claudePlugins(repoOnly, root) : []) {
-      const names = plugin.skills.map((p) => basename6(p));
+      const names = plugin.skills.map((p) => basename7(p));
       const inRepo = namesIn2(root).filter((n) => names.includes(n));
       const dupes = names.filter((n) => inRepo.includes(n) || globalYours.has(n));
       if (!dupes.length) continue;
@@ -2621,385 +2774,8 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   const alsoGlobal = /* @__PURE__ */ new Map();
   const globalCopies = loaded.filter((m) => m.kind !== "plugin");
   const alsoLoadedGlobally = (s) => globalCopies.some((m) => m.name === s.name && m.harnesses.some((id) => s.visibility.some((v) => v.id === id && v.paths > 0)));
-  for (const root of projects2) {
-    const where = basename6(root);
-    const status2 = statuses.get(root);
-    issues.push(...brokenLinksIn(root, openedProjects));
-    const pins = readManifest(root).skills;
-    const blockedFor = /* @__PURE__ */ new Map();
-    const untrackable = (s) => {
-      if (!blockedFor.has(s.name)) blockedFor.set(s.name, trackBlocker(root, s.name));
-      return blockedFor.get(s.name);
-    };
-    const blockers = new Map(status2.filter((s) => s.managed).flatMap((s) => ((b) => b ? [[s.name, b]] : [])(syncBlocker(root, s.name, pins[s.name]))));
-    for (const [name, blocker] of blockers)
-      issues.push({
-        id: `stuck:${root}:${name}`,
-        severity: "problem",
-        title: `${name} in ${where}: sync can't put it back as skilllib.json pins it`,
-        // What to do depends on what's there: a folder that links out of the repo is a setup of yours, and a pin
-        // your library has no version of can't come back by sync anyway.
-        detail: `${blocker.said}, so sync can't put it back there.${blocker.outside ? " skilllib only installs inside the repo: point that folder back into the repo, or remove the skill here (skilllib remove)." : versionForHash(name, pins[name]?.hash ?? "") !== null ? " Move it out of the way, then run skilllib sync." : " Move it out of the way; your library has no copy of the pinned version either."}`,
-        at: rows(root, [name])
-      });
-    const unstuck = status2.filter((s) => !blockers.has(s.name));
-    const missing = unstuck.filter((s) => s.state === "folder missing" && s.latest !== null);
-    const knownPin = (s) => versionForHash(s.name, pins[s.name]?.hash ?? "") !== null;
-    const restorable = missing.filter(knownPin);
-    for (const s of unstuck.filter((m) => (m.state === "folder missing" || m.state === "out of sync") && m.latest !== null && !knownPin(m)))
-      issues.push({
-        id: `pin:${root}:${s.name}`,
-        severity: "problem",
-        title: `${s.name}: the version ${where}'s skilllib.json pins isn't in your library`,
-        detail: `${s.state === "folder missing" ? "The folder is missing, and no" : "The copy is another version, and no"} version in Your skills has the content it pins (pinned from another library?). ${untrackable(s) ? `${untrackable(s)}, so skilllib can't install it here.` : `Install your newest v${s.latest}; ${where}'s skilllib.json then pins it.`}`,
-        at: rows(root, [s.name]),
-        // It changes what the shared skilllib.json pins: a choice, never run by `doctor --fix`.
-        ...untrackable(s) ? {} : { choices: [{ label: `Install your newest (v${s.latest})`, hint: `${where}'s skilllib.json pins it`, run: () => `${s.name}: installed v${track(root, s.name).to}` }] }
-      });
-    if (restorable.length > 0) {
-      issues.push({
-        id: `sync:${root}`,
-        severity: "problem",
-        title: `${where}: ${plural(restorable.length, "skill")} in skilllib.json not installed`,
-        detail: `${restorable.map((s) => s.name).join(", ")}: the folder is missing`,
-        at: rows(root, restorable.map((s) => s.name)),
-        fix: {
-          label: "Sync the project",
-          // 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) }))
-        }
-      });
-    }
-    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 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: [
-          {
-            label: "Remove it from skilllib.json",
-            hint: `${where} stops pinning it`,
-            run: () => {
-              const r = removeSkill(root, s.name);
-              if (r.action !== "removed") throw new Error(`${s.name}: ${r.reason}`);
-              return `${s.name}: removed from ${where}'s skilllib.json`;
-            }
-          }
-        ]
-      });
-    const behind = unstuck.filter((s) => s.state === "update available" && !untrackable(s));
-    if (behind.length > 0)
-      issues.push({
-        id: `update:${root}`,
-        severity: "suggestion",
-        title: `${where}: ${plural(behind.length, "skill")} out of date`,
-        detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
-        at: rows(root, behind.map((s) => s.name)),
-        // It changes what the repo pins and the copies its agents load (often committed): a choice, never `doctor --fix`.
-        choices: [
-          {
-            label: "Update to the newest versions",
-            hint: 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 = 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);
-        if (!r.skills) throw new Error(`${where}: nothing tidied${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`);
-        return `${where}: tidied ${plural(r.skills, "skill")}${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`;
-      };
-      issues.push({
-        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(", ")}.` : 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: [
-            // "Keep git as it is" only when it leaves something to do.
-            ...visible2.length < tidy2.plans.reduce((n, p) => n + p.steps.length, 0) ? [{ label: "Tidy, but keep git as it is", hint: `skips the ${plural(visible2.length, "change")} git would see`, run: run("keep") }] : [],
-            { label: "Tidy everything", hint: `${plural(visible2.length, "change")} will show in git status`, run: run("go") }
-          ]
-        } : { fix: { label: "Tidy", run: run("go") } }
-      });
-    }
-    issues.push(...tidy2.conflicts.map(conflictIssue));
-    for (const s of tidy2.skipped.filter((x) => x.differs))
-      issues.push({
-        id: `linkdiffers:${root}:${s.name}`,
-        severity: "problem",
-        title: `${s.name} in ${where}: the copies differ`,
-        detail: `${s.reason}, with other content than the copy beside it: your agents run different versions. Make them the same, or remove the link; skilllib doesn't change a link to another copy.`,
-        at: rows(root, [s.name])
-      });
-    const loadsGlobally = (name, id) => {
-      const here = status2.find((s) => s.name === name);
-      return globalCopies.some((m) => m.name === name && m.harnesses.includes(id) && (!here || treeHash(m.path) === treeHash(here.path)));
-    };
-    const blindHere = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0 && !loadsGlobally(s.name, v.id))).map((s) => ({ s, would: linkEverywhere(root, s.name, s.location, { dryRun: true }) }));
-    const enabledIds = enabledHarnesses();
-    const notFolders = /* @__PURE__ */ new Set();
-    for (const dir of new Set(enabledIds.map((id) => harness(id).projectDirs[0]))) {
-      const blocker = notWritable(root, dir);
-      if (!blocker || notFolders.has(blocker)) continue;
-      notFolders.add(blocker);
-      const who = agentNames(enabledIds.filter((id) => notWritable(root, harness(id).projectDirs[0]) === blocker));
-      const out2 = linksOut(root, blocker);
-      issues.push({
-        id: `notdir:${root}:${blocker}`,
-        severity: out2 ? "suggestion" : "problem",
-        title: out2 ? `${where}: ${blocker} links out of the repo` : `${where}: ${blocker} isn't a folder`,
-        detail: out2 ? `${blockerSaid(root, blocker)}. ${who} ${who.includes(",") || who.includes(" and ") ? "load" : "loads"} what's there, but skilllib treats it as outside ${where}: it adds, links and removes nothing there.` : `${blockerSaid(root, blocker)}: ${who} can't load skills from ${where}, and skilllib adds none there. Move it out of the way, then run skilllib link.`,
-        at: [{ root, skill: "" }]
-        // the repo itself: its row in Places
-      });
-    }
-    for (const { s, would } of blindHere) {
-      const way = would.inTheWay.filter((p) => !notFolders.has(p));
-      if (!way.length || blockers.has(s.name)) continue;
-      issues.push({
-        id: `intheway:${root}:${s.name}`,
-        severity: "problem",
-        title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it here`,
-        detail: `${inTheWaySaid(root, way)}. skilllib won't link past what's there: clear the way, then run skilllib link.`,
-        at: rows(root, [s.name])
-      });
-    }
-    for (const { s, would } of blindHere.filter(({ would: w }) => !w.created.length && !w.blocked.length && w.uncommitted.length))
-      issues.push({
-        id: `uncommitted:${root}:${s.name}`,
-        severity: "suggestion",
-        title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it until it's committed`,
-        detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`).`,
-        at: rows(root, [s.name])
-      });
-    const partial = blindHere.filter(({ would }) => would.created.length || would.blocked.length).map(({ s }) => s);
-    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, 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) {
-          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.` : ""}${manifestShared ? " The new links are recorded in skilllib.json, which git tracks." : ""}`,
-        at: rows(root, partial.map((s) => s.name)),
-        ...manifestShared && !tracked.length ? { choices: [{ label: "Add the links", hint: "git will see skilllib.json change", run: run(false) }] } : tracked.length ? {
-          choices: [
-            // Only when some link goes where git doesn't track: otherwise this one would link nothing.
-            ...blindHere.some(({ would }) => would.created.length) ? [{ label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) }] : [],
-            { label: "Add links everywhere", hint: `remembered for ${where}; git will see them`, run: run(true) }
-          ]
-        } : { fix: { label: "Add the links", run: run(false) } }
-      });
-    }
-    const differing = new Set(tidy2.conflicts.map((c) => c.name));
-    const git2 = 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) || 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: ${why}.`,
-          at: rows(root, [s.name]),
-          choices: [
-            {
-              label: "Copy into the library",
-              hint: `${where}'s copy stays as it is`,
-              run: () => {
-                intoLibrary(s.path);
-                return `${s.name} copied into your library; ${where}'s copy stays as it is`;
-              }
-            }
-          ]
-        });
-      } else if (s.state === "local only") {
-        issues.push({
-          id: `local:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name} in ${where} isn't in your library`,
-          detail: "Import it into the library to reuse it in other projects and keep it backed up. The repo then tracks it in skilllib.json.",
-          at: rows(root, [s.name]),
-          choices: [
-            {
-              label: "Import into the library",
-              // 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);
-                return `${s.name} imported and tracked in ${where}`;
-              }
-            }
-          ]
-        });
-      } else if (s.state === "untracked copy of library skill" && !committed(s) && !untrackable(s)) {
-        issues.push({
-          id: `adopt:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name} in ${where} isn't tracked`,
-          detail: "It's identical to the library copy; track it (in skilllib.json) so future library changes reach it.",
-          at: rows(root, [s.name]),
-          choices: [{ label: "Track it", hint: `adds it to ${where}'s skilllib.json`, run: () => `${track(root, s.name).name} tracked in ${where}` }]
-        });
-      } else if (s.state === "untracked, differs from library" || s.state === "repo skill, differs from library") {
-        const teams = s.state.startsWith("repo skill") || committed(s) || !!untrackable(s);
-        const whose = s.state.startsWith("repo skill") || committed(s) ? "It's the team's copy (committed, or in the repo's own .agents/skills 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 ? `${whose}, and no version in Your skills matches it. Update your library from it if it's the one to keep; ${where}'s copy stays as it is.` : `No version in Your skills matches it. Update your library from it (${where} then tracks it), or replace it with your library's.`,
-          at: rows(root, [s.name]),
-          choices: [
-            {
-              label: "Update your library from it",
-              hint: teams ? `a new version in Your skills; ${where}'s copy stays as it is` : `a new version in Your skills; ${where} then tracks it`,
-              run: () => {
-                intoLibrary(s.path, true);
-                if (teams) return `${s.name}: your library has ${where}'s copy; ${where}'s copy stays as it is`;
-                const c = track(root, s.name);
-                return `${s.name}: your library has ${where}'s copy as v${c.to}; ${where} tracks it`;
-              }
-            },
-            ...teams ? [] : [
-              {
-                label: "Replace it with your library's",
-                hint: "this copy is restorable with skilllib restore",
-                run: () => {
-                  const c = addSkill(root, s.name, { force: true });
-                  if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
-                  return `${s.name} in ${where} is your library's v${c.to} now; the old copy is restorable with skilllib restore`;
-                }
-              }
-            ]
-          ]
-        });
-      } else if (s.state === "from npx skills" && !((committed(s) || untrackable(s)) && versionForHash(s.name, treeHash(s.path) ?? "") !== null)) {
-        const teams = committed(s) || !!untrackable(s);
-        issues.push({
-          id: `npx:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name} in ${where} came from npx skills, not your library`,
-          detail: `Installed with \`npx skills add\`${s.source ? ` (${s.source})` : ""}. Import it into your library to reuse it in other projects and keep it backed up${teams ? `; ${where}'s copy stays as it is (${committed(s) ? "committed" : `${untrackable(s)}, so skilllib can't track it here`})` : `; ${where} then tracks it in skilllib.json`}.`,
-          at: rows(root, [s.name]),
-          choices: [
-            {
-              label: "Import it into your library",
-              hint: teams ? `${where}'s copy stays as it is` : `${where} then tracks it`,
-              run: () => {
-                intoLibrary(s.path);
-                if (teams) return `${s.name} copied into your library; ${where}'s copy stays as it is`;
-                track(root, s.name);
-                return `${s.name} imported and tracked in ${where}`;
-              }
-            }
-          ]
-        });
-      }
-      if (s.state === "not in library")
-        issues.push({
-          id: `not-in-lib:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name} in ${where} is tracked, but no longer in your library`,
-          detail: `${where}'s skilllib.json pins it, but your library has no copy: if the folder goes, sync can't restore it, and your other repos can't add it. Copy ${where}'s copy back into the library.`,
-          at: rows(root, [s.name]),
-          choices: [
-            {
-              label: "Copy it back into your library",
-              hint: `${where}'s copy stays as it is`,
-              run: () => {
-                intoLibrary(s.path);
-                return `${s.name} copied back into your library`;
-              }
-            }
-          ]
-        });
-      if (s.state === "edited locally" || s.state === "edited locally, update available") {
-        const newer2 = s.state !== "edited locally";
-        const pinned = s.version ? `v${s.version}` : "the library version";
-        issues.push({
-          id: `edited:${root}:${s.name}`,
-          severity: "suggestion",
-          title: `${s.name} in ${where} has local edits`,
-          detail: `It no longer matches ${pinned} from Your skills${newer2 ? `, and v${s.latest} is out` : ""}. ${untrackable(s) ? `${untrackable(s)}, so skilllib can't re-pin or discard them here; copy them into Your skills to keep them for your other repos.` : "Save the edits as a new version so your other repos can get them, or discard them. Keeping them is fine too: skilllib never overwrites edits."}`,
-          at: rows(root, [s.name]),
-          choices: untrackable(s) ? [
-            {
-              label: "Copy the edits into Your skills",
-              hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : "a new version there"}; ${where}'s copy and pin stay as they are (skilllib sync there would put the pinned version back)`,
-              run: () => {
-                intoLibrary(s.path, true);
-                return `${s.name}: the edits are in Your skills as v${latestVersion(s.name)?.version}; ${where} stays as it is`;
-              }
-            }
-          ] : [
-            {
-              label: "Save as a new version in Your skills",
-              hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`}${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
-              run: () => {
-                importSkill(s.path, { force: true });
-                const c = addSkill(root, s.name);
-                if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
-                return `${s.name}: saved as v${c.to}; ${where} uses it`;
-              }
-            },
-            {
-              label: "Discard the edits",
-              hint: `back to ${pinned}; the edited copy is restorable 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}`);
-                return `${s.name}: edits discarded, back to v${c.to}`;
-              }
-            }
-          ]
-        });
-      }
-      if (alsoLoadedGlobally(s)) alsoGlobal.set(s.name, [...alsoGlobal.get(s.name) ?? [], { root, managed: s.managed }]);
-    }
-  }
+  const ctx = { issues, statuses, openedProjects, globalCopies, alsoLoadedGlobally, alsoGlobal };
+  for (const root of projects2) repoIssues(root, ctx);
   for (const root of projects2) {
     for (const n of nested.get(root)) {
       const copies = alsoGlobal.get(n.name) ?? [];
@@ -3012,23 +2788,23 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   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 wheres = copies.map((c) => basename7(c.root)).join(", ");
     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 repoOwn = copies.filter((c) => !c.managed).map((c) => basename7(c.root));
     const at = [...copies.flatMap((c) => rows(c.root, [name])), ...rows(null, [name])];
     if (kept.has(name)) {
       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(", ");
+      const removeWheres = extra.map((r) => basename7(r)).join(", ");
       issues.push({
         id: `twice:${name}`,
         severity: "suggestion",
         title: `${name}: in ${wheres}, and you keep it 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.` : "",
+          needed.length ? `In ${needed.map((r) => `${basename7(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,
@@ -3039,8 +2815,8 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
             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 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})`);
+              const removed = results.filter(([, c]) => c.action === "removed").map(([r]) => basename7(r));
+              const kept2 = results.filter(([, c]) => c.action !== "removed").map(([r, c]) => `${basename7(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`;
             }
@@ -3101,6 +2877,404 @@ function findIssues(roots, machine, libraryNames, statusOf = projectStatus, load
   }
   return issues;
 }
+function repoIssues(root, ctx) {
+  const where = basename7(root);
+  const status2 = ctx.statuses.get(root);
+  ctx.issues.push(...brokenLinksIn(root, ctx.openedProjects));
+  const pins = readManifest(root).skills;
+  const shadowed = Object.keys(personalPins(root)).filter((name) => pins[name] && !pins[name].personal);
+  if (shadowed.length)
+    ctx.issues.push({
+      id: `shadowed:${root}`,
+      severity: "suggestion",
+      title: `${where}: ${plural(shadowed.length, "skill")} pinned in both skilllib.json and your personal pins`,
+      detail: `${shadowed.join(", ")}: ${where}'s skilllib.json pins ${shadowed.length === 1 ? "it" : "them"} for the team, and that pin wins. Your personal pin does nothing.`,
+      at: rows(root, shadowed),
+      choices: [
+        {
+          label: "Drop the personal pins",
+          hint: "skilllib.json's pins stay; nothing that loads changes",
+          run: () => {
+            for (const name of shadowed) dropPersonalPin(root, name);
+            return `${where}: ${shadowed.join(", ")} now pinned only in skilllib.json`;
+          }
+        }
+      ]
+    });
+  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)
+    ctx.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)))
+    ctx.issues.push({
+      id: `pin:${root}:${s.name}`,
+      severity: "problem",
+      title: `${s.name}: the version ${where}'s skilllib.json pins isn't in your library`,
+      detail: `${s.state === "folder missing" ? "The folder is missing, and no" : "The copy is another version, and no"} version in Your skills has the content it pins (pinned from another library?). ${untrackable(s) ? `${untrackable(s)}, so skilllib can't install it here.` : `Install your newest v${s.latest}; ${where}'s skilllib.json then pins it.`}`,
+      at: rows(root, [s.name]),
+      // It changes what the shared skilllib.json pins: a choice, never run by `doctor --fix`.
+      ...untrackable(s) ? {} : { choices: [{ label: `Install your newest (v${s.latest})`, hint: `${where}'s skilllib.json pins it`, run: () => `${s.name}: installed v${track(root, s.name).to}` }] }
+    });
+  if (restorable.length > 0) {
+    ctx.issues.push({
+      id: `sync:${root}`,
+      severity: "problem",
+      title: `${where}: ${plural(restorable.length, "skill")} pinned but not installed`,
+      detail: `${restorable.map((s) => s.name).join(", ")}: the folder is missing`,
+      at: rows(root, restorable.map((s) => s.name)),
+      fix: {
+        label: "Sync the project",
+        // 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) }))
+      }
+    });
+  }
+  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) }))
+    };
+    ctx.issues.push({
+      id: `out-of-sync:${root}`,
+      severity: "suggestion",
+      title: `${where}: ${plural(drifted.length, "skill")} not at the pinned version`,
+      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))
+    ctx.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 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: [
+        {
+          label: "Remove it from skilllib.json",
+          hint: `${where} stops pinning it`,
+          run: () => {
+            const r = removeSkill(root, s.name);
+            if (r.action !== "removed") throw new Error(`${s.name}: ${r.reason}`);
+            return `${s.name}: removed from ${where}'s skilllib.json`;
+          }
+        }
+      ]
+    });
+  const behind = unstuck.filter((s) => s.state === "update available" && !untrackable(s));
+  if (behind.length > 0)
+    ctx.issues.push({
+      id: `update:${root}`,
+      severity: "suggestion",
+      title: `${where}: ${plural(behind.length, "skill")} out of date`,
+      detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
+      at: rows(root, behind.map((s) => s.name)),
+      // It changes what the repo pins and the copies its agents load (often committed): a choice, never `doctor --fix`.
+      choices: [
+        {
+          label: "Update to the newest versions",
+          hint: 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 = 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);
+      if (!r.skills) throw new Error(`${where}: nothing tidied${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`);
+      return `${where}: tidied ${plural(r.skills, "skill")}${r.held ? `; left ${plural(r.held, "change")} git would see` : ""}`;
+    };
+    ctx.issues.push({
+      id: `tidy:${root}`,
+      severity: "suggestion",
+      title: `${where}: ${plural(tidy2.plans.length, "skill")} with extra copies or links`,
+      detail: tidy2.plans.map((p) => `${p.name}: ${p.steps.map((s) => describeStep(s, root)).join(", ")}`).join(" \xB7 ") + (visible2.length ? `. Git would see ${plural(visible2.length, "of these change")}: ${visible2.join(", ")}.` : 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: [
+          // "Keep git as it is" only when it leaves something to do.
+          ...visible2.length < tidy2.plans.reduce((n, p) => n + p.steps.length, 0) ? [{ label: "Tidy, but keep git as it is", hint: `skips the ${plural(visible2.length, "change")} git would see`, run: run("keep") }] : [],
+          { label: "Tidy everything", hint: `${plural(visible2.length, "change")} will show in git status`, run: run("go") }
+        ]
+      } : { fix: { label: "Tidy", run: run("go") } }
+    });
+  }
+  ctx.issues.push(...tidy2.conflicts.map(conflictIssue));
+  for (const s of tidy2.skipped.filter((x) => x.differs))
+    ctx.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 ctx.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);
+    ctx.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;
+    ctx.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))
+    ctx.issues.push({
+      id: `uncommitted:${root}:${s.name}`,
+      severity: "suggestion",
+      title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it until it's committed`,
+      detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`).`,
+      at: rows(root, [s.name])
+    });
+  const partial = blindHere.filter(({ would }) => would.created.length || would.blocked.length).map(({ s }) => s);
+  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, 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) {
+        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}`;
+    };
+    ctx.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.` : ""}${manifestShared ? " The new links are recorded in skilllib.json, which git tracks." : ""}`,
+      at: rows(root, partial.map((s) => s.name)),
+      ...manifestShared && !tracked.length ? { choices: [{ label: "Add the links", hint: "git will see skilllib.json change", run: run(false) }] } : tracked.length ? {
+        choices: [
+          // Only when some link goes where git doesn't track: otherwise this one would link nothing.
+          ...blindHere.some(({ would }) => would.created.length) ? [{ label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) }] : [],
+          { label: "Add links everywhere", hint: `remembered for ${where}; git will see them`, run: run(true) }
+        ]
+      } : { fix: { label: "Add the links", run: run(false) } }
+    });
+  }
+  const differing = new Set(tidy2.conflicts.map((c) => c.name));
+  const git2 = 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) || untrackable(s))) {
+      const why = committed(s) ? "it's the team's (committed)" : `${untrackable(s)}, so skilllib can't track it here`;
+      ctx.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: ${why}.`,
+        at: rows(root, [s.name]),
+        choices: [
+          {
+            label: "Copy into the library",
+            hint: `${where}'s copy stays as it is`,
+            run: () => {
+              intoLibrary(s.path);
+              return `${s.name} copied into your library; ${where}'s copy stays as it is`;
+            }
+          }
+        ]
+      });
+    } else if (s.state === "local only") {
+      ctx.issues.push({
+        id: `local:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} isn't in your library`,
+        detail: "Import it into the library to reuse it in other projects and keep it backed up. The repo then tracks it in skilllib.json.",
+        at: rows(root, [s.name]),
+        choices: [
+          {
+            label: "Import into the library",
+            // 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);
+              return `${s.name} imported and tracked in ${where}`;
+            }
+          }
+        ]
+      });
+    } else if (s.state === "untracked copy of library skill" && !committed(s) && !untrackable(s)) {
+      ctx.issues.push({
+        id: `adopt:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} isn't tracked`,
+        detail: "It's identical to the library copy; track it (in skilllib.json) so future library changes reach it.",
+        at: rows(root, [s.name]),
+        choices: [{ label: "Track it", hint: `adds it to ${where}'s skilllib.json`, run: () => `${track(root, s.name).name} tracked in ${where}` }]
+      });
+    } else if (s.state === "untracked, differs from library" || s.state === "repo skill, differs from library") {
+      const teams = s.state.startsWith("repo skill") || committed(s) || !!untrackable(s);
+      const whose = s.state.startsWith("repo skill") || committed(s) ? "It's the team's copy (committed, or in the repo's own .agents/skills or .grok/skills)" : `${untrackable(s)}, so skilllib can't track it here`;
+      ctx.issues.push({
+        id: `differs:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} differs from your library`,
+        detail: teams ? `${whose}, and no version in Your skills matches it. Update your library from it if it's the one to keep; ${where}'s copy stays as it is.` : `No version in Your skills matches it. Update your library from it (${where} then tracks it), or replace it with your library's.`,
+        at: rows(root, [s.name]),
+        choices: [
+          {
+            label: "Update your library from it",
+            hint: teams ? `a new version in Your skills; ${where}'s copy stays as it is` : `a new version in Your skills; ${where} then tracks it`,
+            run: () => {
+              intoLibrary(s.path, true);
+              if (teams) return `${s.name}: your library has ${where}'s copy; ${where}'s copy stays as it is`;
+              const c = track(root, s.name);
+              return `${s.name}: your library has ${where}'s copy as v${c.to}; ${where} tracks it`;
+            }
+          },
+          ...teams ? [] : [
+            {
+              label: "Replace it with your library's",
+              hint: "this copy is restorable with skilllib restore",
+              run: () => {
+                const c = addSkill(root, s.name, { force: true });
+                if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
+                return `${s.name} in ${where} is your library's v${c.to} now; the old copy is restorable with skilllib restore`;
+              }
+            }
+          ]
+        ]
+      });
+    } else if (s.state === "from npx skills" && !((committed(s) || untrackable(s)) && versionForHash(s.name, treeHash(s.path) ?? "") !== null)) {
+      const teams = committed(s) || !!untrackable(s);
+      ctx.issues.push({
+        id: `npx:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} came from npx skills, not your library`,
+        detail: `Installed with \`npx skills add\`${s.source ? ` (${s.source})` : ""}. Import it into your library to reuse it in other projects and keep it backed up${teams ? `; ${where}'s copy stays as it is (${committed(s) ? "committed" : `${untrackable(s)}, so skilllib can't track it here`})` : `; ${where} then tracks it in skilllib.json`}.`,
+        at: rows(root, [s.name]),
+        choices: [
+          {
+            label: "Import it into your library",
+            hint: teams ? `${where}'s copy stays as it is` : `${where} then tracks it`,
+            run: () => {
+              intoLibrary(s.path);
+              if (teams) return `${s.name} copied into your library; ${where}'s copy stays as it is`;
+              track(root, s.name);
+              return `${s.name} imported and tracked in ${where}`;
+            }
+          }
+        ]
+      });
+    }
+    if (s.state === "not in library")
+      ctx.issues.push({
+        id: `not-in-lib:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} is tracked, but no longer in your library`,
+        detail: `${where}'s skilllib.json pins it, but your library has no copy: if the folder goes, sync can't restore it, and your other repos can't add it. Copy ${where}'s copy back into the library.`,
+        at: rows(root, [s.name]),
+        choices: [
+          {
+            label: "Copy it back into your library",
+            hint: `${where}'s copy stays as it is`,
+            run: () => {
+              intoLibrary(s.path);
+              return `${s.name} copied back into your library`;
+            }
+          }
+        ]
+      });
+    if (s.state === "edited locally" || s.state === "edited locally, update available") {
+      const newer2 = s.state !== "edited locally";
+      const pinned = s.version ? `v${s.version}` : "the library version";
+      ctx.issues.push({
+        id: `edited:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where} has local edits`,
+        detail: `It no longer matches ${pinned} from Your skills${newer2 ? `, and v${s.latest} is out` : ""}. ${untrackable(s) ? `${untrackable(s)}, so skilllib can't re-pin or discard them here; copy them into Your skills to keep them for your other repos.` : "Save the edits as a new version so your other repos can get them, or discard them. Keeping them is fine too: skilllib never overwrites edits."}`,
+        at: rows(root, [s.name]),
+        choices: untrackable(s) ? [
+          {
+            label: "Copy the edits into Your skills",
+            hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : "a new version there"}; ${where}'s copy and pin stay as they are (skilllib sync there would put the pinned version back)`,
+            run: () => {
+              intoLibrary(s.path, true);
+              return `${s.name}: the edits are in Your skills as v${latestVersion(s.name)?.version}; ${where} stays as it is`;
+            }
+          }
+        ] : [
+          {
+            label: "Save as a new version in Your skills",
+            hint: `${newer2 ? `becomes v${s.latest + 1}; v${s.latest}'s changes aren't merged in` : `becomes v${(s.latest ?? 0) + 1}; ${where} uses it`}${gitNote(root, [join13(root, MANIFEST_FILE)])}`,
+            run: () => {
+              importSkill(s.path, { force: true });
+              const c = addSkill(root, s.name);
+              if (c.action === "skipped") throw new Error(`${s.name}: ${c.reason}`);
+              return `${s.name}: saved as v${c.to}; ${where} uses it`;
+            }
+          },
+          {
+            label: "Discard the edits",
+            hint: `back to ${pinned}; the edited copy is restorable 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}`);
+              return `${s.name}: edits discarded, back to v${c.to}`;
+            }
+          }
+        ]
+      });
+    }
+    if (ctx.alsoLoadedGlobally(s)) ctx.alsoGlobal.set(s.name, [...ctx.alsoGlobal.get(s.name) ?? [], { root, managed: s.managed }]);
+  }
+}
 function addedAt(path) {
   try {
     const st = lstatSync4(path);
@@ -3115,7 +3289,7 @@ function usageIssues(projects2, machine, libraryNames, uses, statusOf = projectS
   const issues = [];
   const since = Date.now() - uses.days * 24 * 60 * 60 * 1e3;
   for (const root of projects2) {
-    const where = basename6(root);
+    const where = basename7(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) => removesClean(root, s));
@@ -3143,15 +3317,15 @@ 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 = pluginNameOf(p.id);
-      if (p.skills.some((path) => uses.asUsed(`${name}:${basename6(path)}`) > 0)) continue;
+      if (p.skills.some((path) => uses.asUsed(`${name}:${basename7(path)}`) > 0)) continue;
       issues.push({
         id: `plugin-unused:${installId(p)}`,
         severity: "suggestion",
         title: `${p.id}${installedIn(p)}: its skills weren't used in ${plural(uses.days, "day")}`,
-        detail: `No Claude Code session used ${p.skills.map((path) => `/${name}:${basename6(path)}`).join(", ")}. Each one's name and description still takes context in every session.${p.extras.length ? ` It also brings ${p.extras.join(", ")}: turning it off pauses those too.` : ""}`,
+        detail: `No Claude Code session used ${p.skills.map((path) => `/${name}:${basename7(path)}`).join(", ")}. Each one's name and description still takes context in every session.${p.extras.length ? ` It also brings ${p.extras.join(", ")}: turning it off pauses those too.` : ""}`,
         choices: [
-          { label: `Turn the plugin ${p.id} off`, hint: p.scope === "project" ? `stays installed; edits ${basename6(p.projectPath ?? "the repo")}'s committed .claude/settings.json` : "stays installed", run: () => orThrow(setPluginOn(p, false)) },
-          ...p.synced || p.settingsOnly ? [] : [{ label: `Uninstall the plugin ${p.id}`, hint: `its data stays; restorable with skilllib restore${p.scope === "project" ? `; edits ${basename6(p.projectPath ?? "the repo")}'s committed .claude/settings.json` : ""}`, run: () => orThrow(uninstallPlugin(p)) }]
+          { label: `Turn the plugin ${p.id} off`, hint: p.scope === "project" ? `stays installed; edits ${basename7(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 ${basename7(p.projectPath ?? "the repo")}'s committed .claude/settings.json` : ""}`, run: () => orThrow(uninstallPlugin(p)) }]
         ],
         plugin: p.id,
         pluginAt: p.projectPath ?? null
@@ -3204,7 +3378,7 @@ function globalFrom(kind, origin, path) {
 }
 function topLevel(root) {
   try {
-    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);
+    return readdirSync9(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 [];
   }
@@ -3231,7 +3405,8 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
         state: usual ? void 0 : s.state,
         latest: behind ? s.latest : void 0,
         git: gitState,
-        agents: sameSet(loadedBy, agents) ? void 0 : loadedBy
+        agents: sameSet(loadedBy, agents) ? void 0 : loadedBy,
+        personal: s.personal ? true : void 0
       };
       return [JSON.stringify(attrs), s.name, () => ({ ...attrs, skills: [] })];
     })
@@ -3281,7 +3456,7 @@ function firstSentence(description) {
   return sentence.length > 200 ? sentence.slice(0, 199).trimEnd() + "\u2026" : sentence;
 }
 function libraryFor(currentProject) {
-  const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: pinsIn(p) }));
+  const manifests = visibleProjects().map((p) => ({ name: basename8(p), skills: pinsIn(p) }));
   const here = currentProject ? new Set(projectStatus(currentProject).map((s) => s.name)) : null;
   const all = librarySkills();
   const describe2 = (s) => {
@@ -3293,7 +3468,7 @@ function libraryFor(currentProject) {
 }
 
 // src/usage.ts
-import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync9, statSync as statSync5 } from "fs";
+import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync10, statSync as statSync6 } from "fs";
 import { join as join14 } from "path";
 import { createInterface } from "readline";
 var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
@@ -3378,17 +3553,17 @@ function transcriptFiles(sinceMs) {
   if (!existsSync13(base)) return [];
   const list2 = (dir) => {
     try {
-      return readdirSync9(dir);
+      return readdirSync10(dir);
     } catch {
       return [];
     }
   };
   return list2(base).flatMap((project) => {
     const dir = join14(base, project);
-    if (!statSync5(dir, { throwIfNoEntry: false })?.isDirectory()) return [];
+    if (!statSync6(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);
+        const st = statSync6(f);
         return st.isFile() && st.mtimeMs >= sinceMs;
       } catch {
         return false;
@@ -3441,11 +3616,11 @@ function usesByProject(uses, projectOf) {
 }
 
 // src/move.ts
-import { basename as basename8 } from "path";
+import { basename as basename9 } from "path";
 function moveGlobalSkills(skills, roots, {
   group,
   allowTracked = false,
-  label = basename8,
+  label = basename9,
   allowTrackedHint = "re-run with --allow-tracked"
 } = {}) {
   const byName = /* @__PURE__ */ new Map();
@@ -3493,6 +3668,8 @@ var FLAGS = {
   json: { type: "boolean" },
   "dry-run": { type: "boolean" },
   "allow-git": { type: "boolean" },
+  personal: { type: "boolean" },
+  shared: { type: "boolean" },
   days: { type: "string" },
   keep: { type: "string" },
   to: { type: "string", multiple: true }
@@ -3500,6 +3677,7 @@ var FLAGS = {
 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 });
+  if (v.personal && v.shared) throw new Error("--personal and --shared don't go together: a pin is in one place");
   const days = Number(v.days ?? USAGE_DAYS);
   if (!Number.isInteger(days) || days <= 0) throw new Error(`--days takes a whole number of days, like --days 30 (got ${v.days})`);
   return {
@@ -3513,6 +3691,7 @@ function parseArgs(argv) {
     days,
     dryRun: !!v["dry-run"],
     allowGit: !!v["allow-git"],
+    ...v.personal || v.shared ? { personal: !!v.personal } : {},
     ...v.keep ? { keep: v.keep } : {},
     to: (v.to ?? []).flatMap((t) => t.split(",").filter(Boolean))
   };
@@ -3527,7 +3706,7 @@ function withDirs(root, changes) {
   const { skills } = readManifest(root);
   return changes.map((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;
+    return dep ? { ...c, dirs: [dep.dir ?? PROJECT_SKILLS_DIR, ...(dep.links ?? []).filter((d) => !c.inTheWay?.includes(`${d}/${c.name}`))], ...dep.personal ? { personal: true } : {} } : c;
   });
 }
 var incomplete = (c) => c.action === "skipped" || !!c.blocked?.length || !!c.uncommitted?.length || !!c.inTheWay?.length;
@@ -3546,7 +3725,7 @@ function printChanges(root, changes, args) {
     else {
       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)}`);
+      info(`  ${icon} ${c.name}${versions} ${dim(c.action)}${c.moved ? dim(c.moved === "personal" ? ", now in your personal pins" : ", now in skilllib.json") : ""}`);
       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`));
@@ -3557,10 +3736,10 @@ function printChanges(root, changes, args) {
 ${done} done, ${skipped} skipped`));
 }
 function projectOfFactory(projects2) {
-  const sorted = [...projects2].sort((a, b) => b.length - a.length);
+  const sorted2 = [...projects2].sort((a, b) => b.length - a.length);
   return (cwd) => {
     if (!cwd) return null;
-    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep8));
+    const known = sorted2.find((p) => cwd === p || cwd.startsWith(p + sep8));
     if (known) return known;
     const repo = cwd.split(`${sep8}.claude${sep8}worktrees${sep8}`)[0];
     return isProjectCandidate(repo) ? repo : null;
@@ -3576,7 +3755,7 @@ var projectsFor = (args) => {
   if (!args.all) return [requireProject()];
   const { readable, unreadable } = readableRoots(visibleProjects());
   for (const u of unreadable) {
-    error(`${basename9(u.root)}: ${u.reason}`);
+    error(`${basename10(u.root)}: ${u.reason}`);
     process.exitCode = 1;
   }
   return readable;
@@ -3610,7 +3789,7 @@ async function status(args) {
   const root = requireProject();
   const skills = projectStatus(root);
   const nested = nestedSkills(root);
-  info(`${basename9(root)} ${dim(tildify(root))}
+  info(`${basename10(root)} ${dim(tildify(root))}
 `);
   if (skills.length === 0 && nested.length === 0) info("No skills in this project yet. Add one from your library with: skilllib add <name>");
   const usage2 = await usageBySkill(args.days, root);
@@ -3683,7 +3862,7 @@ async function list(args) {
     const installs = /* @__PURE__ */ new Map();
     for (const project of visibleProjects()) {
       for (const name of Object.keys(pinsIn(project))) {
-        installs.set(name, [...installs.get(name) ?? [], basename9(project)]);
+        installs.set(name, [...installs.get(name) ?? [], basename10(project)]);
       }
     }
     const usage2 = await usageBySkill(args.days);
@@ -3726,7 +3905,7 @@ function teamStateIn(root, extraDirs = []) {
 function projects(args) {
   const { readable: roots, unreadable } = readableRoots(visibleProjects());
   for (const u of unreadable) {
-    error(`${basename9(u.root)}: ${u.reason}`);
+    error(`${basename10(u.root)}: ${u.reason}`);
     process.exitCode = 1;
   }
   if (args.json) {
@@ -3735,7 +3914,7 @@ function projects(args) {
       roots.map((root) => {
         const teamState = teamStateIn(root);
         return {
-          name: basename9(root),
+          name: basename10(root),
           path: root,
           skills: projectStatus(root).map((s) => ({ name: s.name, managed: s.managed, state: teamState(s), version: s.version, latest: s.latest }))
         };
@@ -3753,7 +3932,7 @@ function projects(args) {
       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),
+        Project: basename10(root),
         Path: dim(tildify(root)),
         Skills: skills.map((s) => s.name).join(", ") || dim("none"),
         "Local only": String(skills.filter((s) => teamState(s) === "local only").length),
@@ -3764,10 +3943,15 @@ function projects(args) {
 }
 function add(args) {
   if (args.positional.length === 0) {
-    throw new Error("Usage: skilllib add <skill-name>... [--force]");
+    throw new Error("Usage: skilllib add <skill-name>... [--force] [--personal|--shared]");
   }
   const root = requireProject();
-  printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force, allowTracked: args.allowTracked })), args);
+  const changes = args.positional.map((name) => addSkill(root, name, { force: args.force, allowTracked: args.allowTracked, personal: args.personal }));
+  printChanges(root, changes, args);
+  const pins = readManifest(root).skills;
+  const done = changes.filter((c) => c.action !== "skipped" && pins[c.name]);
+  if (!args.json && done.some((c) => pins[c.name].personal))
+    info(dim(`Pinned in your personal pins (${tildify(personalPinsDir())}) and kept out of git. --shared pins in skilllib.json for the team.`));
   rememberProjects([root]);
 }
 function remove(args) {
@@ -3783,11 +3967,11 @@ function changeEach(args, change, nothing) {
     const changes = change(root);
     if (changes.some(incomplete)) process.exitCode = 1;
     if (!args.json) {
-      if (args.all) info(`${basename9(root)} ${dim(tildify(root))}`);
+      if (args.all) info(`${basename10(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) nothing(root);
       else printChanges(root, changes, args);
     }
-    return { project: basename9(root), path: root, changes: withDirs(root, changes) };
+    return { project: basename10(root), path: root, changes: withDirs(root, changes) };
   });
   if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
   return roots;
@@ -3797,7 +3981,7 @@ function sync(args) {
   const roots = changeEach(
     args,
     (root) => syncProject(root, { force: args.force }),
-    (root) => existsSync14(join15(root, MANIFEST_FILE)) ? success("Installed versions match skilllib.json") : info(dim("No skilllib.json: nothing to sync"))
+    (root) => hasPins(root) ? success("Installed versions match what's pinned") : info(dim("No skilllib.json or personal pins: nothing to sync"))
   );
   if (!args.all) rememberProjects(roots);
 }
@@ -3818,7 +4002,7 @@ function update(args) {
 function outdated(args) {
   const roots = projectsFor(args);
   const behind = roots.flatMap(
-    (root) => projectStatus(root).filter((s) => s.state.endsWith("update available") && s.latest !== null && s.version !== null).map((s) => ({ project: basename9(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
+    (root) => projectStatus(root).filter((s) => s.state.endsWith("update available") && s.latest !== null && s.version !== null).map((s) => ({ project: basename10(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
   if (args.json) return json("outdated", behind);
   const rows2 = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
@@ -3853,7 +4037,7 @@ function importSkills(args) {
     const dep = projectHere(root) === root ? readManifest(root).skills[name] : void 0;
     if (dep && realpathOrNull(join15(root, dep.dir ?? PROJECT_SKILLS_DIR, name)) === realpathOrNull(dir) && dep.hash !== treeHash(dir)) {
       const change = addSkill(root, name);
-      if (change.action !== "skipped") info(dim(`  ${basename9(root)} now depends on ${name} v${change.to}`));
+      if (change.action !== "skipped") info(dim(`  ${basename10(root)} now depends on ${name} v${change.to}`));
     }
   }
   if (args.json) json("import", results);
@@ -3869,14 +4053,14 @@ function scan(args) {
   const library = new Set(librarySkills().map((s) => s.name));
   const skillNames = (root) => [
     // 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)])
+    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.filter((d) => !notWritable(root, d)).flatMap((d) => skillDirsIn(join15(root, d))).map((d) => basename10(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
 `);
   table(
     withSkills.map((root) => ({
-      Project: basename9(root),
+      Project: basename10(root),
       Path: dim(tildify(root)),
       Skills: skillNames(root).map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
@@ -4046,7 +4230,7 @@ async function usage(args) {
     return json("usage", {
       usageDays: args.days,
       source: "Claude Code transcripts",
-      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename9(p)), inLibrary: library.has(s.skill) })),
+      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename10(p)), inLibrary: library.has(s.skill) })),
       unusedLibrarySkills: unused
     });
   }
@@ -4060,7 +4244,7 @@ async function usage(args) {
     summaries.map((s) => ({
       Skill: s.skill,
       Uses: String(s.uses),
-      Projects: [...s.projects].map((p) => basename9(p)).join(", ") || dim("-"),
+      Projects: [...s.projects].map((p) => basename10(p)).join(", ") || dim("-"),
       "Last used": lastUsed(s),
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
@@ -4084,7 +4268,7 @@ function show(args) {
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
-      projects: projectsUsing(name).map((p) => basename9(p)),
+      projects: projectsUsing(name).map((p) => basename10(p)),
       skillMd: readFileSync7(join15(dir, "SKILL.md"), "utf-8")
     });
   }
@@ -4116,7 +4300,7 @@ function link(args) {
   const roots = projectsFor(args);
   for (const root of roots) {
     const res = linkAll(root, { allowTracked: args.allowTracked });
-    const label = args.all ? `${basename9(root)}: ` : "";
+    const label = args.all ? `${basename10(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 && !res.inTheWay.length) {
       const missing = projectStatus(root).filter((s) => s.state === "folder missing").map((s) => s.name);
@@ -4162,7 +4346,7 @@ ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <na
 }
 function repoRoot(repo) {
   const looksLikePath = /[\\/]/.test(repo) || repo.startsWith(".") || repo.startsWith("~");
-  const named = looksLikePath ? [] : visibleProjects().filter((p) => basename9(p) === repo);
+  const named = looksLikePath ? [] : visibleProjects().filter((p) => basename10(p) === repo);
   if (named.length === 1) return named[0];
   if (named.length > 1) throw new Error(`Several projects are named ${repo}: ${named.map(tildify).join(", ")}. Pass its path.`);
   const path = expandHome(repo);
@@ -4188,17 +4372,18 @@ function moveGlobal(args, names, yours) {
         moved,
         ...reason ? { reason } : {},
         ...left ? { left } : {},
-        projects: changes.map(([root, c]) => ({ project: basename9(root), path: root, change: withDirs(root, [c])[0] }))
+        projects: changes.map(([root, c]) => ({ project: basename10(root), path: root, change: withDirs(root, [c])[0] }))
       }))
     );
   }
   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)`);
+    if (m.moved) success(`${m.name} now loads only in ${m.changes.map(([r]) => basename10(r)).join(", ")} (the global copy is in skilllib restore)`);
     else error(`${m.name}: ${m.reason}`);
-    for (const [root, c] of m.changes) warnHeldLinks(root, c, `in ${basename9(root)}`);
+    for (const [root, c] of m.changes) warnHeldLinks(root, c, `in ${basename10(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."));
+  const toCommit = [...new Set(moves.filter((m) => m.moved).flatMap((m) => m.changes.map(([r]) => r)))].filter((r) => existsSync14(join15(r, MANIFEST_FILE)));
+  if (toCommit.length) info(dim(`Commit skilllib.json and the skill folders in ${toCommit.map((r) => basename10(r)).join(", ")}.`));
 }
 function tidy(args) {
   const names = args.positional;
@@ -4211,13 +4396,13 @@ function tidy(args) {
   for (const name of names) {
     const where = targets.map((root) => ({ root, ...foldersOf(root, name) })).filter((w) => w.all.length);
     if (!where.length) {
-      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename9(targets[0])}`}`);
+      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename10(targets[0])}`}`);
       continue;
     }
     if (!args.keep) continue;
     for (const { root, real } of where) {
       if (real.includes(keepFor(root)[name])) continue;
-      const label = root ? `${basename9(root)} \xB7 ` : "";
+      const label = root ? `${basename10(root)} \xB7 ` : "";
       problems.push(
         `${label}${name}: no copy in ${args.keep}; ${real.length ? `pick one of: ${real.map((d) => folderLabel(root, d)).join(", ")}` : "it has no real copy to keep"}`
       );
@@ -4227,7 +4412,7 @@ function tidy(args) {
     throw new Error(problems.join("\n"));
   }
   const reports = targets.map(
-    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename9(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
+    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename10(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
   );
   let held = 0;
   let changed = 0;