skilllib 1.6.0 → 1.7.0

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

@@ -1,6 +1,41 @@
 // src/output.ts
-import { sep } from "path";
+import { resolve as resolve2, sep } from "path";
+
+// src/paths.ts
+import { realpathSync } from "fs";
 import { homedir } from "os";
+import { join, resolve } from "path";
+function userHome() {
+  return process.env.HOME || homedir();
+}
+function realPath(path) {
+  try {
+    return realpathSync(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function skilllibHome() {
+  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
+}
+function libraryDir() {
+  return join(skilllibHome(), "library");
+}
+function claudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
+}
+function codexHome() {
+  return process.env.CODEX_HOME?.trim() || join(userHome(), ".codex");
+}
+function codexSystemDir() {
+  return process.env.SKILLLIB_CODEX_SYSTEM_DIR ?? "/etc/codex/skills";
+}
+var PROJECT_SKILLS_DIR = ".claude/skills";
+var AGENTS_SKILLS_DIR = ".agents/skills";
+var MANIFEST_FILE = "skilllib.json";
+var OWN_SKILL_MARKER = ".managed-by-skilllib";
+
+// src/output.ts
 var jsonMode = false;
 function setJsonMode(on) {
   jsonMode = on;
@@ -19,8 +54,9 @@ var success = (msg) => out(`${green("\u2713")} ${msg}`);
 var warn = (msg) => out(`${yellow("!")} ${msg}`);
 var error = (msg) => console.error(`${red("\u2717")} ${msg}`);
 function tildify(path) {
-  const home2 = homedir();
-  return path === home2 || path.startsWith(home2 + sep) ? "~" + path.slice(home2.length) : path;
+  for (const home2 of /* @__PURE__ */ new Set([resolve2(userHome()), realPath(userHome())]))
+    if (path === home2 || path.startsWith(home2 + sep)) return ("~" + path.slice(home2.length)).replace(/\\/g, "/");
+  return path;
 }
 function truncate(s, max) {
   const line = s.replace(/\s+/g, " ");
@@ -41,35 +77,9 @@ import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirS
 import { join as join9 } from "path";
 
 // src/config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join6, resolve as resolve2 } from "path";
-
-// src/paths.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join } from "path";
-function userHome() {
-  return process.env.HOME || homedir2();
-}
-function skilllibHome() {
-  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
-}
-function libraryDir() {
-  return join(skilllibHome(), "library");
-}
-function claudeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
-}
-function codexHome() {
-  return process.env.CODEX_HOME?.trim() || join(userHome(), ".codex");
-}
-function codexSystemDir() {
-  return process.env.SKILLLIB_CODEX_SYSTEM_DIR ?? "/etc/codex/skills";
-}
-var PROJECT_SKILLS_DIR = ".claude/skills";
-var AGENTS_SKILLS_DIR = ".agents/skills";
-var MANIFEST_FILE = "skilllib.json";
-var OWN_SKILL_MARKER = ".managed-by-skilllib";
+import { join as join6, resolve as resolve4 } from "path";
 
 // src/harnesses.ts
 import { existsSync } from "fs";
@@ -155,8 +165,7 @@ function installDirs(enabled, keep) {
 
 // src/project.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname, join as join5, resolve } from "path";
+import { dirname, join as join5, resolve as resolve3 } from "path";
 
 // src/versions.ts
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
@@ -164,7 +173,7 @@ import { join as join4 } from "path";
 
 // src/skills.ts
 import { createHash } from "crypto";
-import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "fs";
+import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync as realpathSync2, rmSync, statSync } from "fs";
 import { basename, join as join3, relative, sep as sep2 } from "path";
 import { parse as parseYaml } from "yaml";
 var IGNORED = /* @__PURE__ */ new Set([".DS_Store", ".git", "node_modules"]);
@@ -204,7 +213,7 @@ function treeHash(dir) {
 }
 function copySkill(from, to) {
   rmSync(to, { recursive: true, force: true });
-  cpSync(realpathSync(from), to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) });
+  cpSync(realpathSync2(from), to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) });
 }
 function skillDirsIn(dir) {
   if (!existsSync2(dir)) return [];
@@ -263,19 +272,17 @@ function getVersion(name, version) {
 
 // src/project.ts
 function findProjectRoot(from = process.cwd()) {
-  let dir = resolve(from);
+  let dir = resolve3(from);
   while (true) {
     if (existsSync4(join5(dir, MANIFEST_FILE)) || existsSync4(join5(dir, ".git"))) return dir;
     const parent = dirname(dir);
-    if (parent === dir) return resolve(from);
+    if (parent === dir) return resolve3(from);
     dir = parent;
   }
 }
-function projectSkillsDir(root) {
-  return join5(root, PROJECT_SKILLS_DIR);
-}
-function agentsSkillsDir(root) {
-  return join5(root, AGENTS_SKILLS_DIR);
+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);
@@ -315,14 +322,23 @@ function knownProjects() {
   const path = projectsFile();
   if (!existsSync4(path)) return [];
   const list2 = JSON.parse(readFileSync3(path, "utf-8"));
-  return list2.filter((p) => existsSync4(p) && isProjectCandidate(p));
+  return onePerFolder(list2.filter((p) => existsSync4(p) && isProjectCandidate(p)));
+}
+function onePerFolder(paths) {
+  const byReal = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const real = realPath(p);
+    const seen = byReal.get(real);
+    if (seen === void 0 || seen === real && p !== real) byReal.set(real, p);
+  }
+  return [...new Set(byReal.values())];
 }
 function isProjectCandidate(root) {
-  return resolve(root) !== homedir3();
+  return realPath(root) !== realPath(userHome());
 }
 function rememberProjects(roots) {
-  const incoming = roots.map((r) => resolve(r)).filter(isProjectCandidate);
-  const all = [.../* @__PURE__ */ new Set([...knownProjects(), ...incoming])].sort();
+  const incoming = roots.map((r) => resolve3(r)).filter(isProjectCandidate);
+  const all = onePerFolder([...knownProjects(), ...incoming]).sort();
   mkdirSync2(skilllibHome(), { recursive: true });
   writeFileSync2(projectsFile(), JSON.stringify(all, null, 2) + "\n");
 }
@@ -344,10 +360,12 @@ function writeConfig(config) {
   writeFileSync3(configFile(), JSON.stringify(config, null, 2) + "\n");
 }
 function expandHome(path) {
-  return resolve2(path.replace(/^~(?=$|\/)/, homedir4()));
+  return resolve4(path.replace(/^~(?=$|\/)/, homedir2()));
 }
 function addRoot(path) {
   const root = expandHome(path);
+  if (!existsSync5(root)) throw new Error(`${tildify(root)} doesn't exist`);
+  if (!statSync2(root).isDirectory()) throw new Error(`${tildify(root)} isn't a folder`);
   const config = readConfig();
   if (!config.roots.includes(root)) writeConfig({ ...config, roots: [...config.roots, root].sort() });
   return root;
@@ -361,8 +379,10 @@ function removeRoot(path) {
 }
 function setHidden(project, hidden) {
   const config = readConfig();
+  if (config.hidden.includes(project) === hidden) return false;
   const rest = config.hidden.filter((h) => h !== project);
   writeConfig({ ...config, hidden: hidden ? [...rest, project].sort() : rest });
+  return true;
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "vendor", "target", "Library", "Applications", "Pictures", "Music", "Movies"]);
 function findProjects(dir, depth = 4) {
@@ -386,8 +406,8 @@ function discoverProjects() {
   return visibleProjects();
 }
 function visibleProjects() {
-  const hidden = new Set(readConfig().hidden);
-  return knownProjects().filter((p) => !hidden.has(p));
+  const hidden = new Set(readConfig().hidden.map(realPath));
+  return knownProjects().filter((p) => !hidden.has(realPath(p)));
 }
 function enabledHarnesses() {
   return readConfig().harnesses ?? HARNESSES.filter((h) => h.installed()).map((h) => h.id);
@@ -418,12 +438,12 @@ function setKeepGlobal(names, keep) {
 
 // src/library.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync3, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync4, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
 import { basename as basename3, dirname as dirname2, join as join8, relative as relative2, sep as sep3 } from "path";
 
 // src/sources.ts
-import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2, join as join7, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync3, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, join as join7, resolve as resolve5 } from "path";
 function readJson(path) {
   try {
     return JSON.parse(readFileSync5(path, "utf-8"));
@@ -432,24 +452,36 @@ function readJson(path) {
   }
 }
 function skillsShLock() {
-  return readJson(join7(resolve3(claudeDir(), ".."), ".agents", ".skill-lock.json"))?.skills ?? {};
+  return readJson(join7(userHome(), ".agents", ".skill-lock.json"))?.skills ?? {};
 }
 function projectSkillsLock(root) {
   return readJson(join7(root, "skills-lock.json"))?.skills ?? {};
 }
 function realpathOrNull(path) {
   try {
-    return realpathSync2(path);
+    return realpathSync3(path);
   } catch {
     return null;
   }
 }
 function harnessesReading(dir, enabled) {
-  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().includes(dir));
+  const real = realPath(dir);
+  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().some((d) => realPath(d) === real));
 }
 var systemDirs = () => [codexSystemDir()];
 function globalSkillDirs() {
-  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => !systemDirs().includes(d));
+  const seen = /* @__PURE__ */ new Set();
+  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => {
+    if (systemDirs().includes(d)) return false;
+    const real = realPath(d);
+    if (seen.has(real)) return false;
+    seen.add(real);
+    return true;
+  });
+}
+function globalDirAs(dir) {
+  const real = realPath(dir);
+  return globalSkillDirs().find((d) => realPath(d) === real) ?? dir;
 }
 function systemSkills(enabled) {
   return systemDirs().flatMap(
@@ -492,7 +524,7 @@ function globalFolderSkills(enabled) {
     const inAgents = e.dir === agentsDir || target_.includes(".agents/skills");
     const locked = lock[e.name]?.source;
     if (existsSync6(join7(e.path, OWN_SKILL_MARKER))) {
-      skills.push({ name: e.name, kind: "built-in", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
+      skills.push({ name: e.name, kind: "skilllib", origin: "skilllib", path: e.path, description: readSkillInfo(e.path).description, movable: false, broken: false, harnesses: harnessesReading(e.dir, enabled), links: [] });
       continue;
     }
     skills.push({
@@ -516,8 +548,7 @@ function globalFolderSkills(enabled) {
   return skills;
 }
 function tildify2(p) {
-  const shown = p.startsWith(userHome()) ? "~" + p.slice(userHome().length) : p;
-  return shown.replace(/\\/g, "/");
+  return tildify(p).replace(/\\/g, "/");
 }
 function cursorBuiltInSkills(enabled) {
   if (!enabled.includes("cursor")) return [];
@@ -637,7 +668,7 @@ function recordOrigin(name, origin) {
   writeFileSync4(originsFile(), JSON.stringify({ ...origins, [name]: origin }, null, 2) + "\n");
 }
 function originFor(dir) {
-  const match = machineSkills().find((s) => resolve3(s.path) === resolve3(dir));
+  const match = machineSkills().find((s) => resolve5(s.path) === resolve5(dir));
   if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
   const project = dir.split(/[\\/]\.(?:claude|agents)[\\/]skills[\\/]/)[0];
   if (!project || project === dir) return dir;
@@ -658,7 +689,7 @@ function librarySkillDir(name) {
 }
 function realpathOrNull2(path) {
   try {
-    return realpathSync3(path);
+    return realpathSync4(path);
   } catch {
     return null;
   }
@@ -797,20 +828,40 @@ function nestedSkills(root, { depth = 3, enabled = enabledHarnesses() } = {}) {
   walk(root, depth);
   return found.sort((a, b) => a.location.localeCompare(b.location) || a.name.localeCompare(b.name));
 }
-function linkEverywhere(root, name, location, { allowTracked = false } = {}) {
+function sharedByGit(root, location, name) {
+  const copy = `${location}/${name}`;
+  if (isGitTracked(root, copy)) return true;
+  if (!isGitTracked(root, location)) return false;
+  try {
+    execFileSync("git", ["check-ignore", "-q", "--no-index", "--", copy], { cwd: root, stdio: "ignore" });
+    return false;
+  } catch {
+    return true;
+  }
+}
+function linkEverywhere(root, name, location, { allowTracked = false, dryRun = false } = {}) {
   const enabled = enabledHarnesses();
-  const result = { created: [], blocked: [] };
+  const result = { created: [], blocked: [], uncommitted: [] };
+  let shared;
   for (const id of enabled) {
     if (visibilityOf(root, name, [id])[0].paths > 0) continue;
     const dir = harness(id).projectDirs[0];
     const link2 = join8(root, dir, name);
-    if (entryExists(link2)) continue;
-    if (!allowTracked && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
-      result.blocked.push(dir);
-      continue;
+    if (entryExists(link2) || Object.values(result).some((dirs) => dirs.includes(dir))) continue;
+    if (isGitTracked(root, dir)) {
+      if (!(shared ??= sharedByGit(root, location, name))) {
+        if (!result.uncommitted.includes(dir)) result.uncommitted.push(dir);
+        continue;
+      }
+      if (!allowTracked && !readConfig().agentsDirOk?.includes(root)) {
+        if (!result.blocked.includes(dir)) result.blocked.push(dir);
+        continue;
+      }
+    }
+    if (!dryRun) {
+      mkdirSync5(join8(root, dir), { recursive: true });
+      linkDir(join8(root, location, name), link2);
     }
-    mkdirSync5(join8(root, dir), { recursive: true });
-    linkDir(join8(root, location, name), link2);
     result.created.push(dir);
   }
   return result;
@@ -826,7 +877,7 @@ function unlinkEverywhere(root, name) {
 function relinkDependency(root, name, { allowTracked = false } = {}) {
   const manifest = readManifest(root);
   const dep = manifest.skills[name];
-  if (!dep) return { created: [], blocked: [] };
+  if (!dep) return { created: [], blocked: [], uncommitted: [] };
   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])] };
@@ -837,13 +888,15 @@ function relinkDependency(root, name, { allowTracked = false } = {}) {
 function linkAll(root, { allowTracked = false } = {}) {
   const linked = [];
   const blocked = /* @__PURE__ */ new Set();
+  const uncommitted = [];
   for (const skill of projectStatus(root)) {
     if (!skill.visibility.some((v) => v.paths === 0) || skill.state === "folder missing") continue;
     const res = skill.managed ? relinkDependency(root, skill.name, { allowTracked }) : linkEverywhere(root, skill.name, skill.location, { allowTracked });
     if (res.created.length) linked.push({ name: skill.name, into: res.created });
     for (const dir of res.blocked) blocked.add(dir);
+    if (res.uncommitted.length) uncommitted.push(skill.name);
   }
-  return { linked, blocked: [...blocked] };
+  return { linked, blocked: [...blocked], uncommitted };
 }
 function addSkill(root, name, { force = false, version, allowTracked = false } = {}) {
   const target = version === void 0 ? latestVersion(name) : getVersion(name, version);
@@ -861,13 +914,17 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
       reason: recorded ? "has local edits (use --force to overwrite, or save them to the library first)" : `${primary}/${name} already exists with different content (use --force to replace it)`
     };
   }
+  let backedUp;
   if (local !== target.hash || isLink(to)) {
     mkdirSync5(join8(root, primary), { recursive: true });
     if (isLink(to)) unlinkSync(to);
+    else if (local !== null && !knownContent) backedUp = stash(to, "edit-backup");
     copySkill(versionDir(name, target.version), to);
   }
   const links = [];
   const blocked = [];
+  const uncommitted = [];
+  let shared;
   for (const dir of linkDirs) {
     const link2 = join8(root, dir, name);
     if (isLink(link2) && realpathOrNull2(link2) === realpathOrNull2(to)) {
@@ -875,9 +932,15 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
       continue;
     }
     if (entryExists(link2)) continue;
-    if (!allowTracked && !recorded?.links?.includes(dir) && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
-      blocked.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;
+      }
     }
     mkdirSync5(join8(root, dir), { recursive: true });
     linkDir(to, link2);
@@ -892,10 +955,12 @@ function addSkill(root, name, { force = false, version, allowTracked = false } =
   writeManifest(root, manifest);
   return {
     name,
-    action: recorded || local !== null ? "updated" : "installed",
+    action: !recorded && local === null ? "installed" : backedUp && recorded?.version === target.version ? "reset" : "updated",
     ...recorded ? { from: recorded.version } : {},
     to: target.version,
-    ...blocked.length ? { blocked } : {}
+    ...blocked.length ? { blocked } : {},
+    ...uncommitted.length ? { uncommitted } : {},
+    ...backedUp ? { backedUp } : {}
   };
 }
 function removeSkill(root, name, { force = false } = {}) {
@@ -904,17 +969,17 @@ function removeSkill(root, name, { force = false } = {}) {
   if (!recorded) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
   const dir = join8(root, recorded.dir ?? PROJECT_SKILLS_DIR, name);
   const local = treeHash(dir);
-  if (local !== null && local !== recorded.hash && !versionForHash(name, local) && !force) {
-    return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
-  }
+  const edited = local !== null && local !== recorded.hash && !versionForHash(name, local);
+  if (edited && !force) return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
   for (const linkDir2 of recorded.links ?? []) {
     const link2 = join8(root, linkDir2, name);
     if (isLink(link2)) unlinkSync(link2);
   }
-  rmSync2(dir, { recursive: true, force: true });
+  const backedUp = edited ? stash(dir, "edit-backup") : void 0;
+  if (!backedUp) rmSync2(dir, { recursive: true, force: true });
   delete manifest.skills[name];
   writeManifest(root, manifest);
-  return { name, action: "removed" };
+  return { name, action: "removed", ...backedUp ? { backedUp } : {} };
 }
 function syncProject(root, { force = false } = {}) {
   const { skills } = readManifest(root);
@@ -925,7 +990,8 @@ function syncProject(root, { force = false } = {}) {
     const pinned = dep.version > 0 && getVersion(name, dep.version) ? dep.version : void 0;
     if (local !== null && local !== dep.hash && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
     const change = addSkill(root, name, { force: true, version: pinned });
-    return change.action === "skipped" ? [change] : [{ ...change, action: local === null ? "installed" : "updated" }];
+    if (change.action === "skipped") return [{ ...change, reason: `not in your library (${tildify(libraryDir())}); import it, or set SKILLLIB_HOME to the library that has it` }];
+    return [{ ...change, action: local === null ? "installed" : change.action }];
   });
 }
 function discardEdits(root, name) {
@@ -944,6 +1010,7 @@ function updateProject(root, names, { force = false } = {}) {
     const dep = skills[name];
     const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
     if (dep.hash === latest.hash && local === latest.hash) return [];
+    if (dep.hash === latest.hash && local !== null && !force) return [];
     const change = addSkill(root, name, { force });
     return change.action === "skipped" || change.from !== change.to || local !== latest.hash ? [change] : [];
   });
@@ -1038,12 +1105,12 @@ function createSkill(name, description) {
     join8(dir, "SKILL.md"),
     `---
 name: ${name}
-description: ${description || "Describe when Claude should use this skill."}
+description: ${description || "Describe when an agent should use this skill."}
 ---
 
 # ${name}
 
-Instructions for Claude go here.
+Instructions for the agent go here.
 `
   );
   forgetLatest(name);
@@ -1061,7 +1128,11 @@ function listBackups() {
       const from = index[entry] ?? (kind === "trash" ? librarySkillDir(name) : join8(claudeDir(), "skills", name));
       return [{ name, kind, path: join8(dir, entry), movedAt: `${match[2]} ${match[3]}:${match[4]}`, from }];
     });
-  }).sort((a, b) => b.movedAt.localeCompare(a.movedAt));
+  }).sort((a, b) => b.path.slice(-24).localeCompare(a.path.slice(-24)));
+}
+function backupFrom(backup) {
+  if (backup.kind === "plugin") return "Claude Code plugin";
+  return backup.from === librarySkillDir(backup.name) ? "library (deleted)" : tildify(dirname2(backup.from));
 }
 function restoreBackup(backup) {
   const to = backup.from;
@@ -1114,7 +1185,7 @@ function installAgentSkill(enabled = enabledHarnesses()) {
   const [primary, ...links] = agentSkillDirs(enabled);
   if (!primary) return { ok: false, reason: "no agents chosen yet (skilllib harnesses <id>...)" };
   const foreign = [primary, ...links].find((d) => entryExists2(d) && !isOurs(d) && !isDangling(d));
-  if (foreign) return { ok: false, reason: `${foreign} already exists and isn't skilllib's` };
+  if (foreign) return { ok: false, reason: `${tildify(foreign)} already exists and isn't skilllib's` };
   for (const d of [primary, ...links]) if (isDangling(d)) unlinkSync2(d);
   mkdirSync6(primary, { recursive: true });
   writeFileSync6(join9(primary, "SKILL.md"), shippedSkill());
@@ -1143,12 +1214,8 @@ function refreshAgentSkill() {
 }
 
 // src/commands.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
-import { basename as basename8, dirname as dirname5, join as join15, resolve as resolve4, sep as sep5 } from "path";
-
-// src/here.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { basename as basename7, join as join13 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { basename as basename8, join as join14, resolve as resolve7, sep as sep5 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -1162,9 +1229,9 @@ function git(root, args, input) {
     return typeof out2 === "string" ? out2 : null;
   }
 }
-function gitInfo(root) {
+function gitInfo(root, extraDirs = []) {
   if (!existsSync9(join10(root, ".git"))) return null;
-  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE].filter((d) => existsSync9(join10(root, d)));
+  const dirs = [...ALL_PROJECT_DIRS, MANIFEST_FILE, ...extraDirs].filter((d) => existsSync9(join10(root, d)));
   if (dirs.length === 0) return { of: () => "new" };
   const tracked = (git(root, ["ls-files", "-z", "--", ...dirs]) ?? "").split("\0").filter(Boolean);
   const dirty = (git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...dirs]) ?? "").split("\0").filter(Boolean).map((entry) => entry.slice(3));
@@ -1189,14 +1256,18 @@ function relativeTo(root, path) {
   return relative3(root, path).split("\\").join("/");
 }
 
+// src/here.ts
+import { readdirSync as readdirSync7 } from "fs";
+import { basename as basename7 } from "path";
+
 // src/health.ts
 import { lstatSync as lstatSync4 } from "fs";
-import { basename as basename6 } from "path";
+import { basename as basename6, dirname as dirname5 } from "path";
 
 // src/plugins.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join11 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename4, dirname as dirname3, join as join11, resolve as resolve6 } from "path";
 function readJson2(path) {
   try {
     return JSON.parse(readFileSync8(path, "utf-8"));
@@ -1249,8 +1320,7 @@ function claudeBinary() {
     }
   }) ?? null;
 }
-function claude(args, cwd) {
-  const bin = claudeBinary();
+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` };
   try {
     execFileSync3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 12e4, encoding: "utf-8" });
@@ -1271,9 +1341,44 @@ function setPluginIn(file, id, on) {
 function turnOffSynced(id) {
   return setPluginIn(join11(claudeDir(), "settings.json"), id, false);
 }
+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();
+  try {
+    git2("rev-parse", "--git-dir");
+  } catch {
+    return "";
+  }
+  try {
+    git2("ls-files", "--error-unmatch", "--", file);
+    return "; git tracks that file, so this shows in git status";
+  } catch {
+  }
+  try {
+    git2("check-ignore", "-q", "--", file);
+    return ", which git ignores";
+  } catch {
+  }
+  try {
+    const exclude = resolve6(root, git2("rev-parse", "--git-path", "info/exclude"));
+    const before = existsSync10(exclude) ? readFileSync8(exclude, "utf-8") : "";
+    mkdirSync7(dirname3(exclude), { recursive: true });
+    writeFileSync7(exclude, `${before}${before && !before.endsWith("\n") ? "\n" : ""}/${git2("rev-parse", "--show-prefix")}${file}
+`);
+    return ", which git now ignores via .git/info/exclude";
+  } catch {
+    return "; git doesn't ignore that file yet: it's local only, don't commit it";
+  }
+}
 function turnOffIn(plugin, root) {
-  const r = plugin.synced ? setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false) : claude(["plugin", "disable", plugin.id, "--scope", "local"], root);
-  return r.ok ? { ok: true, message: `${plugin.id} turned off in ${basename4(root)}; other repos keep it` } : { ok: false, message: `${plugin.id}: ${r.reason}` };
+  const done = `${plugin.id} turned off in ${basename4(root)}; other repos keep it`;
+  const bin = plugin.synced ? null : claudeBinary();
+  if (!bin) {
+    const r2 = setPluginIn(join11(root, ".claude", "settings.local.json"), plugin.id, false);
+    return r2.ok ? { ok: true, message: `${done} (in .claude/settings.local.json${ignoreLocalSettings(root)})` } : { ok: false, message: `${plugin.id}: ${r2.reason}` };
+  }
+  const r = claude(["plugin", "disable", plugin.id, "--scope", "local"], root, bin);
+  return r.ok ? { ok: true, message: done } : { ok: false, message: `${plugin.id}: ${r.reason}` };
 }
 function removedFile() {
   return join11(skilllibHome(), "plugin-backup.json");
@@ -1315,11 +1420,11 @@ function restorePlugin(backup) {
 }
 function cursorPluginSkills() {
   const cache = join11(userHome(), ".cursor", "plugins", "cache");
-  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync2(join11(p, d)).isDirectory()) : [];
+  const dirs = (p) => existsSync10(p) ? readdirSync5(p).filter((d) => !d.startsWith(".") && statSync3(join11(p, d)).isDirectory()) : [];
   return dirs(cache).flatMap(
     (marketplace) => dirs(join11(cache, marketplace)).flatMap((plugin) => {
       const versions = dirs(join11(cache, marketplace, plugin)).map((v) => join11(cache, marketplace, plugin, v));
-      const newest = versions.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
+      const newest = versions.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
       return newest ? skillDirsIn(join11(newest, "skills")).map((path) => ({ name: basename4(path), plugin, path })) : [];
     })
   );
@@ -1388,7 +1493,7 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
     if (dep) {
       primary = reals.find((r) => rel(r.dir) === (dep.dir ?? PROJECT_SKILLS_DIR));
       if (!primary) continue;
-    } else if (chosen) {
+    } else if (chosen && reals.some((r) => r.dir === chosen)) {
       primary = reals.find((r) => r.dir === chosen);
     } else {
       if (git2 === void 0) git2 = gitInfo(root);
@@ -1412,7 +1517,8 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
           if (!needed) steps.push({ kind: "unlink", path: e.path });
         } else steps.push(needed ? { kind: "link", path: e.path, target: primary.path } : { kind: "unlink", path: e.path });
       } else {
-        steps.push(needed ? { kind: "replace", path: e.path, target: primary.path } : { kind: "remove", path: e.path });
+        const differs = e.hash !== primary.hash ? { differs: true } : {};
+        steps.push(needed ? { kind: "replace", path: e.path, target: primary.path, ...differs } : { kind: "remove", path: e.path, ...differs });
       }
     }
     if (steps.length) report.plans.push({ name, root, primary: primary.path, steps });
@@ -1420,7 +1526,7 @@ function planProjectTidy(root, { keep = {}, enabled = enabledHarnesses() } = {})
   return report;
 }
 function globalReadsOf(id) {
-  return HARNESSES.find((h) => h.id === id).globalDirs();
+  return HARNESSES.find((h) => h.id === id).globalDirs().map(globalDirAs);
 }
 function isSkillsDirPlugin(path) {
   return existsSync11(join12(path, ".claude-plugin", "plugin.json"));
@@ -1435,15 +1541,16 @@ function planGlobalTidy({ keep = {}, enabled = enabledHarnesses() } = {}) {
       report.skipped.push({ name, reason: "a Claude Code plugin kept in a skills folder" });
       continue;
     }
-    const reals = entries.filter((e) => !e.link);
+    const reals = entries.filter((e, i, all) => !e.link && all.findIndex((o) => !o.link && realpathOrNull2(o.path) === realpathOrNull2(e.path)) === i);
     if (reals.length < 2) continue;
     hashReals(reals);
-    const primary = reals.find((r) => r.dir === keep[name]) ?? reals.find((r) => r.dir === agents) ?? reals[0];
-    if (!keep[name] && reals.some((r) => r.hash !== primary.hash)) {
+    const kept = reals.find((r) => r.dir === keep[name]);
+    const primary = kept ?? reals.find((r) => r.dir === agents) ?? reals[0];
+    if (!kept && reals.some((r) => r.hash !== primary.hash)) {
       report.conflicts.push(conflictOf(name, null, reals, enabled, globalReadsOf));
       continue;
     }
-    const steps = reals.filter((r) => r !== primary).map((r) => ({ kind: "replace", path: r.path, target: primary.path }));
+    const steps = reals.filter((r) => r !== primary).map((r) => ({ kind: "replace", path: r.path, target: primary.path, ...r.hash !== primary.hash ? { differs: true } : {} }));
     report.plans.push({ name, root: null, primary: primary.path, steps });
   }
   return report;
@@ -1481,20 +1588,27 @@ function applyTidy(plan, { git: git2 = "keep", info: info2 } = {}) {
   return { name: plan.name, root: plan.root, applied, held };
 }
 function describeStep(step, root) {
-  const shown = root ? relativeTo(root, step.path) : step.path.replace(userHome(), "~");
+  const shown = root ? relativeTo(root, step.path) : tildify(step.path);
   switch (step.kind) {
     case "link":
       return `link ${shown}`;
     case "unlink":
       return `remove extra link ${shown}`;
     case "replace":
-      return `${shown}: duplicate copy \u2192 link`;
+      return `${shown}: ${step.differs ? "differing" : "duplicate"} copy \u2192 link`;
     case "remove":
-      return `remove duplicate copy ${shown}`;
+      return `remove ${step.differs ? "differing" : "duplicate"} copy ${shown}`;
   }
 }
 function copyLabel(conflict, dir) {
-  return conflict.root ? relativeTo(conflict.root, dir) : dir.replace(userHome(), "~");
+  return folderLabel(conflict.root, dir);
+}
+function folderLabel(root, dir) {
+  return root ? relativeTo(root, dir) : tildify(dir);
+}
+function foldersOf(root, name) {
+  const entries = entriesOf(root ? ALL_PROJECT_DIRS.map((d) => join12(root, d)) : globalSkillDirs(), name);
+  return { all: entries.map((e) => e.dir), real: entries.filter((e) => !e.link).map((e) => e.dir) };
 }
 
 // src/health.ts
@@ -1543,13 +1657,14 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     issues.push({
       id: `broken:${skill.name}`,
       severity: "problem",
-      title: `${skill.name}: broken link in ${skill.path.replace(/\/[^/]+$/, "").replace(/^\/Users\/[^/]+/, "~")}`,
+      title: `${skill.name}: broken link in ${tildify(dirname5(skill.path))}`,
       detail: "It points at a folder that no longer exists, so it loads nothing.",
       fix: {
         label: "Remove the link",
         run: () => {
           const r = unloadGlobal(skill.path);
-          return r.ok ? `Removed broken link ${skill.name}` : `${skill.name}: ${r.reason}`;
+          if (!r.ok) throw new Error(`${skill.name}: ${r.reason}`);
+          return `Removed broken link ${skill.name}`;
         }
       }
     });
@@ -1570,8 +1685,10 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     });
   }
   const loadedHere = new Map(projects2.map((root) => [root, loadedIn(root)]));
-  const seenByClaude = (s) => s.visibility.some((v) => v.id === "claude-code" && v.paths > 0);
-  const namesIn2 = (root) => [...new Set([...statuses.get(root), ...nested.get(root)].filter(seenByClaude).map((s) => s.name))];
+  const namesIn2 = (root, agent = "claude-code") => [
+    ...new Set([...statuses.get(root), ...nested.get(root)].filter((s) => s.visibility.some((v) => v.id === agent && v.paths > 0)).map((s) => s.name))
+  ];
+  const pluginAgentsIn = (plugin, root) => new Set(loadedHere.get(root).filter((m) => plugin.skills.includes(m.path)).flatMap((m) => m.harnesses));
   const globalYours = new Set(loaded.filter((m) => m.movable).map((m) => m.name));
   const installedYours = /* @__PURE__ */ new Set([...globalYours, ...[...statuses.values()].flat().map((s) => s.name)]);
   const repoChoices = (plugin, root, names) => {
@@ -1579,7 +1696,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     const copies = statuses.get(root).filter((s) => names.includes(s.name));
     const allManaged = names.every((n) => copies.some((c) => c.name === n && c.managed));
     return [
-      { label: `Turn the plugin ${plugin.id} off in ${where} only`, hint: "other repos keep it", run: () => orThrow(turnOffIn(plugin, root)) },
+      { label: `Turn the plugin ${plugin.id} off in ${where} only`, hint: "other repos keep it; in .claude/settings.local.json, a local-only file", run: () => orThrow(turnOffIn(plugin, root)) },
       // Only copies skilllib installed: Your skills keeps them. A repo's own skill is the team's, never removed from here.
       ...names.length && allManaged ? [
         {
@@ -1599,8 +1716,10 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   const machinePlugins = claudePlugins(machine);
   for (const plugin of machinePlugins) {
     const names = plugin.skills.map((p) => basename6(p));
-    const inRepos = projects2.filter((root) => loadedHere.get(root).some((m) => plugin.skills.includes(m.path))).map((root) => [root, namesIn2(root).filter((n) => names.includes(n))]).filter(([, d]) => d.length);
-    const loadedYours = /* @__PURE__ */ new Set([...globalYours, ...inRepos.flatMap(([, d]) => d)]);
+    const 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)]);
+    const loadedYours = /* @__PURE__ */ new Set([...claudeYours, ...cursorRepos.flatMap(([, d]) => d)]);
     const dupes = names.filter((n) => libraryNames.has(n) || loadedYours.has(n));
     if (!dupes.length) continue;
     const others = plugin.skills.length - dupes.length;
@@ -1612,15 +1731,18 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
     };
     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 notInstalled = dupes.filter((n) => !installedYours.has(n));
     issues.push({
       id: `plugin:${plugin.id}`,
       severity: bothLoad.length ? "problem" : "suggestion",
       title: `${dupes.join(", ")}: also in the Claude Code plugin ${plugin.id}`,
       detail: [
-        bothLoad.length ? `Claude Code loads both (the plugin's as /${pluginName}:${bothLoad[0]}). Your skill wins.` : "",
+        claudeBoth.length ? `Claude Code loads both (the plugin's as /${pluginName}:${claudeBoth[0]}). Your skill wins.` : "",
+        cursorWheres.length ? `${cursorWheres.join(", ")} ${cursorWheres.length === 1 ? "turns" : "turn"} it off for Claude Code, but Cursor ignores repo settings and lists both there: only turning the plugin off or removing it changes that.` : "",
         notInstalled.length ? `Your ${notInstalled.join(", ")} ${notInstalled.length === 1 ? "is" : "are"} only in Your skills, not installed anywhere: once the plugin is gone, add ${notInstalled.length === 1 ? "it" : "them"} where you need ${notInstalled.length === 1 ? "it" : "them"}.` : "",
-        others ? `The plugin's other ${plural(others, "skill")} are copied into Your skills first, so nothing is lost.` : "",
+        others ? `The plugin's other ${others === 1 ? "skill is" : `${others} skills are`} copied into Your skills first, so nothing is lost.` : "",
         plugin.extras.length ? `It also brings ${plugin.extras.join(", ")}: ${plugin.synced ? "turning it off pauses those" : "removing it drops those, turning it off pauses them"}.` : "",
         plugin.synced ? "It's synced from claude.ai, so it can only be turned off here." : "",
         inRepos.length ? `Or keep it and turn it off only in ${inRepos.map(([root]) => basename6(root)).join(", ")}.` : ""
@@ -1667,7 +1789,11 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       detail: `${global.plans.map((p) => p.name).join(", ")}: each keeps one copy (in ~/.agents/skills when there's one) and the others become links. Restorable from Health.`,
       fix: {
         label: "Keep one copy of each",
-        run: () => `${plural(applyAll(global.plans, "go").skills, "global skill")} now have one copy`
+        run: () => {
+          const r = applyAll(global.plans, "go");
+          if (!r.skills) throw new Error("No global skill changed");
+          return `${plural(r.skills, "global skill")} now ${r.skills === 1 ? "has" : "have"} one copy`;
+        }
       }
     });
   }
@@ -1679,7 +1805,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       id: "review:global",
       severity: "suggestion",
       title: `${plural(unreviewed.length, "global skill")} of yours ${unreviewed.length === 1 ? "loads" : "load"} in every repo`,
-      detail: `${unreviewed.join(", ")}. Choose which repos keep each (Global \u2192 Clean up\u2026), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
+      detail: `${unreviewed.join(", ")}. Move each to the repos that need it (skilllib \u2192 Global \u2192 Move it to the repos that need it\u2026), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
     });
   }
   const enabled = enabledHarnesses();
@@ -1697,6 +1823,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       run: () => {
         const results = skills.map((m) => ({ m, ...linkGlobal(m.path, blindOf(m)) }));
         const skipped = results.flatMap((r) => r.skipped);
+        if (!results.some((r) => r.linked.length)) throw new Error(`Nothing linked${skipped.length ? `; skipped ${skipped.join(", ")} (a different skill has that name)` : ""}`);
         return `Linked ${plural(results.filter((r) => r.linked.length).length, "global skill")} for ${agentNames(missing)}${skipped.length ? `; skipped ${skipped.join(", ")} (a different skill has that name)` : ""}`;
       }
     };
@@ -1714,28 +1841,69 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
   for (const root of projects2) {
     const where = basename6(root);
     const status2 = statuses.get(root);
-    const behind = status2.filter((s) => s.state === "update available" || s.state === "folder missing");
-    if (behind.length > 0) {
+    const restorable = status2.filter((s) => s.state === "folder missing" && s.latest !== null);
+    if (restorable.length > 0) {
       issues.push({
         id: `sync:${root}`,
         severity: "problem",
-        title: `${where}: ${plural(behind.length, "skill")} out of date`,
-        detail: behind.map((s) => s.name).join(", "),
+        title: `${where}: ${plural(restorable.length, "skill")} in skilllib.json not installed`,
+        detail: `${restorable.map((s) => s.name).join(", ")}: the folder is missing`,
         fix: {
           label: "Sync the project",
           run: () => {
             const changes = syncProject(root);
-            return `${where}: ${changes.filter((c) => c.action !== "skipped").length} updated`;
+            const done = changes.filter((c) => c.action !== "skipped");
+            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
+            if (!done.length) throw new Error(`${where}: nothing restored${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
+            return `${where}: restored ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
           }
         }
       });
     }
+    for (const s of status2.filter((s2) => s2.state === "folder missing" && s2.latest === null))
+      issues.push({
+        id: `unavailable:${root}:${s.name}`,
+        severity: "problem",
+        title: `${s.name}: pinned in ${where}'s skilllib.json, but not in your library`,
+        detail: `Its folder is missing, and your library (${tildify(libraryDir())}) has no copy to restore: import it, or set SKILLLIB_HOME to the library that has it.`,
+        // 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 = status2.filter((s) => s.state === "update available");
+    if (behind.length > 0)
+      issues.push({
+        id: `update:${root}`,
+        severity: "suggestion",
+        title: `${where}: ${plural(behind.length, "skill")} out of date`,
+        detail: behind.map((s) => `${s.name} (v${s.version} \u2192 v${s.latest})`).join(", "),
+        fix: {
+          label: "Update to the newest versions",
+          run: () => {
+            const changes = updateProject(root, behind.map((s) => s.name));
+            const done = changes.filter((c) => c.action !== "skipped");
+            const skipped = changes.filter((c) => c.action === "skipped").map((c) => `${c.name}: ${c.reason}`);
+            if (!done.length) throw new Error(`${where}: nothing updated${skipped.length ? `; ${skipped.join("; ")}` : ""}`);
+            return `${where}: updated ${plural(done.length, "skill")}${skipped.length ? `; skipped ${skipped.join("; ")}` : ""}`;
+          }
+        }
+      });
     const tidy2 = planProjectTidy(root);
     if (tidy2.plans.length) {
-      const git2 = gitInfo(root);
-      const visible2 = tidy2.plans.flatMap((p) => gitVisibleSteps(p, git2).map((s) => describeStep(s, root)));
+      const git3 = gitInfo(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({
@@ -1752,14 +1920,24 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       });
     }
     issues.push(...tidy2.conflicts.map(conflictIssue));
-    const partial = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0));
+    const blindHere = status2.filter((s) => s.state !== "folder missing" && s.visibility.some((v) => v.paths === 0)).map((s) => ({ s, would: linkEverywhere(root, s.name, s.location, { dryRun: true }) }));
+    for (const { s, would } of blindHere.filter(({ would: w }) => !w.created.length && !w.blocked.length && w.uncommitted.length))
+      issues.push({
+        id: `uncommitted:${root}:${s.name}`,
+        severity: "suggestion",
+        title: `${s.name} in ${where}: ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))} can't use it until it's committed`,
+        detail: `Git tracks ${would.uncommitted.join(", ")}, but not ${s.location}/${s.name}: a link there would be broken for teammates. Commit it, then link it (\`skilllib link --allow-tracked\`, or from Health).`
+      });
+    const partial = blindHere.filter(({ would }) => would.created.length || would.blocked.length).map(({ s }) => s);
     if (partial.length) {
       const missing = [...new Set(partial.flatMap((s) => s.visibility.filter((v) => v.paths === 0).map((v) => v.id)))];
-      const tracked = readConfig().agentsDirOk?.includes(root) ? [] : [...new Set(missing.map((id) => harness(id).projectDirs[0]))].filter((dir) => isGitTracked(root, dir));
+      const tracked = [...new Set(blindHere.flatMap(({ would }) => would.blocked))];
       const run = (allowTracked) => () => {
         if (allowTracked) allowTrackedLinks(root);
         const r = linkAll(root, { allowTracked });
-        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing)}${r.blocked.length ? `; skipped ${r.blocked.join(", ")} (git tracks it)` : ""}`;
+        const notes = `${r.blocked.length ? `; skipped ${r.blocked.join(", ")} (git tracks ${r.blocked.length === 1 ? "it" : "them"})` : ""}${r.uncommitted.length ? `; ${r.uncommitted.join(", ")} not linked into folders git tracks (not committed, so teammates would get broken links)` : ""}`;
+        if (!r.linked.length) throw new Error(`${where}: nothing linked${notes}`);
+        return `${where}: linked ${plural(r.linked.length, "skill")} for ${agentNames(missing)}${notes}`;
       };
       issues.push({
         id: `usable:${root}`,
@@ -1768,20 +1946,40 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
         detail: `${partial.map((s) => `${s.name} (not ${agentNames(s.visibility.filter((v) => v.paths === 0).map((v) => v.id))})`).join(", ")}. Adding links makes the one real copy reach every agent you use; nothing is copied or moved.${tracked.length ? ` Git tracks ${tracked.join(", ")}, so links there show in git status.` : ""}`,
         ...tracked.length ? {
           choices: [
-            { label: "Add links, but not where git tracks the folder", hint: `skips ${tracked.join(", ")}`, run: run(false) },
+            // 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 = gitInfo(root);
+    const committed = (s) => ["committed", "changed"].includes(git2?.of(relativeTo(root, s.path)) ?? "");
     for (const s of status2) {
       if (isLink(s.path) || differing.has(s.name)) continue;
-      if (s.state === "local only") {
+      if (s.state === "local only" && committed(s)) {
+        issues.push({
+          id: `local:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name} in ${where} isn't in your library`,
+          detail: "Copy it into the library to reuse it in other projects. The repo's copy stays as it is: it's the team's (committed).",
+          choices: [
+            {
+              label: "Copy into the library",
+              hint: `${where}'s copy stays as it is`,
+              run: () => {
+                importSkill(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}: only exists in ${where}`,
+          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.",
           choices: [
             {
@@ -1984,7 +2182,7 @@ function groupBy(items) {
 }
 var sameSet = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
 function globalFrom(kind, origin, path) {
-  if (kind === "global") return tildify(path.replace(/[\\/][^\\/]+$/, "")).replace(/\\/g, "/");
+  if (kind === "global" || kind === "skilllib") return tildify(path.replace(/[\\/][^\\/]+$/, "")).replace(/\\/g, "/");
   return origin;
 }
 var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "target", "vendor", "coverage"]);
@@ -1997,28 +2195,34 @@ function topLevel(root) {
 }
 function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   const agents = enabledHarnesses();
-  const git2 = gitInfo(root);
-  const inRepo = isProjectCandidate(root) && (existsSync12(join13(root, ".git")) || existsSync12(join13(root, MANIFEST_FILE)));
-  const project = inRepo ? projectStatus(root) : [];
-  const skills = groupBy(
-    project.map((s) => {
+  const inRepo = projectHere(root) === root;
+  const nestedHere = inRepo ? nestedSkills(root, { enabled: agents }) : [];
+  const git2 = gitInfo(root, [...new Set(nestedHere.map((s) => s.location))]);
+  const group = (list2) => groupBy(
+    list2.map((s) => {
       const loadedBy = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
       const behind = s.managed && s.latest !== null && s.version !== null && s.latest > s.version;
+      const gitState = git2?.of(relativeTo(root, s.path));
+      const repo = !s.managed && (s.state.startsWith("repo skill") || gitState === "committed" || gitState === "changed");
+      const usual = s.state === "ok" || s.state === "local only" || repo && s.state !== "from npx skills";
       const attrs = {
-        source: s.managed ? "library" : s.state.startsWith("repo skill") ? "repo" : "local",
+        source: s.managed ? "library" : repo ? "repo" : "local",
         ...s.location !== ".claude/skills" && { dir: s.location },
         ...s.version !== null && { version: s.version },
-        ...s.state !== "ok" && s.state !== "local only" && !s.state.startsWith("repo skill") && { state: s.state },
+        ...!usual && { state: s.state },
         ...behind && { latest: s.latest },
-        ...git2 && { git: git2.of(relativeTo(root, s.path)) },
+        ...gitState && { git: gitState },
         ...!sameSet(loadedBy, agents) && { agents: loadedBy }
       };
       return [JSON.stringify(attrs), s.name, () => ({ ...attrs, skills: [] })];
     })
   );
+  const skills = group(inRepo ? projectStatus(root) : []);
+  const nested = group(nestedHere);
   const machine = machineSkills(agents);
+  const loaded = inRepo ? skillsLoadedIn(root, machine, agents) : machine;
   const global = groupBy(
-    machine.filter((m) => !m.broken && m.harnesses.length > 0).map((m) => {
+    loaded.filter((m) => !m.broken && m.harnesses.length > 0).map((m) => {
       const from = globalFrom(m.kind, m.origin, m.path);
       return [`${m.kind}\0${from}\0${m.harnesses.join()}`, m.name, () => ({ source: m.kind, from, agents: m.harnesses, skills: [] })];
     })
@@ -2037,6 +2241,7 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
     files: topLevel(root),
     agents,
     skills,
+    ...nested.length > 0 && { nested },
     global,
     issues: [...issues.values()],
     ...Object.keys(usesHere).length > 0 && { usesHere }
@@ -2047,9 +2252,9 @@ function firstSentence(description) {
   const sentence = line.match(/^(.{40,}?[.!?])(?:\s|$)/)?.[1] ?? line;
   return sentence.length > 200 ? sentence.slice(0, 199).trimEnd() + "\u2026" : sentence;
 }
-function libraryFor(currentProject2) {
+function libraryFor(currentProject) {
   const manifests = visibleProjects().map((p) => ({ name: basename7(p), skills: readManifest(p).skills }));
-  const here = currentProject2 ? new Set(projectStatus(currentProject2).map((s) => s.name)) : null;
+  const here = currentProject ? new Set(projectStatus(currentProject).map((s) => s.name)) : null;
   const all = librarySkills();
   const describe = (s) => {
     const projects2 = manifests.filter((m) => s.name in m.skills).map((m) => m.name);
@@ -2060,8 +2265,8 @@ function libraryFor(currentProject2) {
 }
 
 // src/usage.ts
-import { createReadStream, existsSync as existsSync13, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { createReadStream, existsSync as existsSync12, readdirSync as readdirSync8, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
 import { createInterface } from "readline";
 var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
   "add-dir",
@@ -2141,12 +2346,12 @@ function usesFromTranscriptLine(line) {
   return [];
 }
 function transcriptFiles(sinceMs) {
-  const base = join14(claudeDir(), "projects");
-  if (!existsSync13(base)) return [];
+  const base = join13(claudeDir(), "projects");
+  if (!existsSync12(base)) return [];
   return readdirSync8(base).flatMap((project) => {
-    const dir = join14(base, project);
-    if (!statSync3(dir).isDirectory()) return [];
-    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join14(dir, f)).filter((f) => statSync3(f).mtimeMs >= sinceMs);
+    const dir = join13(base, project);
+    if (!statSync4(dir).isDirectory()) return [];
+    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join13(dir, f)).filter((f) => statSync4(f).mtimeMs >= sinceMs);
   });
 }
 async function scanUsage(days) {
@@ -2210,29 +2415,40 @@ function parseArgs(argv) {
 function colorState(state) {
   if (state === "ok") return green(state);
   if (state === "folder missing" || state === "not in library") return red(state);
-  if (state === "local only" || state === "from npx skills") return dim(state);
+  if (state === "local only" || state === "from npx skills" || state === "repo skill") return dim(state);
   return yellow(state);
 }
 function withDirs(root, changes) {
   const { skills } = readManifest(root);
   return changes.map((c) => {
-    const dep = c.action === "installed" || c.action === "updated" ? skills[c.name] : void 0;
+    const dep = c.action === "installed" || c.action === "updated" || c.action === "reset" ? skills[c.name] : void 0;
     return dep ? { ...c, dirs: [dep.dir ?? ".claude/skills", ...dep.links ?? []] } : c;
   });
 }
 function printChanges(root, changes, args) {
+  if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
   if (args.json) return json(withDirs(root, changes));
   for (const c of changes) {
     if (c.blocked?.length) {
       warn(`${c.name}: git tracks ${c.blocked.join(", ")} here, so no link was added there. Re-run with --allow-tracked to add it.`);
     }
-    if (c.action === "skipped") warn(`${c.name}: ${c.reason}`);
+    if (c.uncommitted?.length) {
+      warn(
+        `${c.name}: git tracks ${c.uncommitted.join(", ")} here but not ${c.name}'s real copy, so no link was added there (teammates would get a broken link). Commit ${c.name} first, then run skilllib link --allow-tracked.`
+      );
+    }
+    if (c.action === "skipped") error(`${c.name}: ${c.reason}`);
     else {
-      const icon = c.action === "removed" ? red("-") : green(c.action === "installed" ? "+" : "\u2191");
+      const icon = c.action === "removed" ? red("-") : c.action === "reset" ? yellow("\u21BA") : green(c.action === "installed" ? "+" : "\u2191");
       const versions = c.action === "removed" ? "" : c.from && c.from !== c.to ? ` v${c.from} \u2192 v${c.to}` : c.to ? ` v${c.to}` : "";
       info(`  ${icon} ${c.name}${versions} ${dim(c.action)}`);
     }
+    if (c.backedUp) info(dim(`    local edits saved to ${tildify(c.backedUp)}; \`skilllib restore ${c.name}\` brings them back`));
   }
+  const done = changes.filter((c) => c.action !== "skipped").length;
+  const skipped = changes.length - done;
+  if (skipped && done) info(dim(`
+${done} done, ${skipped} skipped`));
 }
 function projectOfFactory(projects2) {
   const sorted = [...projects2].sort((a, b) => b.length - a.length);
@@ -2250,35 +2466,51 @@ async function usageBySkill(days, onlyProject) {
   const scoped = onlyProject ? uses.filter((u) => projectOf(u.cwd) === onlyProject) : uses;
   return new Map(summarize(scoped, projectOf).map((s) => [s.skill, s]));
 }
-function currentProject() {
-  const root = findProjectRoot();
-  return isProjectCandidate(root) && (existsSync14(join15(root, ".git")) || existsSync14(join15(root, "skilllib.json"))) ? root : null;
+function requireProject() {
+  const root = projectHere();
+  if (root) return root;
+  if (!isProjectCandidate(findProjectRoot())) {
+    const stray = existsSync13(join14(userHome(), MANIFEST_FILE)) ? `, though ${tildify(join14(userHome(), MANIFEST_FILE))} makes it look like one` : "";
+    throw new Error(`Your home folder isn't a project${stray}: skills added here would load in every repo. Run this inside a project.`);
+  }
+  throw new Error("Not in a git repo. Run this inside a project (or `git init` first).");
 }
 function lastUsed(summary) {
   return summary ? summary.lastUsed.slice(0, 10) : "-";
 }
 async function status(args) {
-  const root = findProjectRoot();
   if (args.json) {
-    const usage3 = await usageBySkill(args.days, root);
-    json(usableHere(root, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
-    if (currentProject()) rememberProjects([root]);
+    const root2 = findProjectRoot();
+    const usage3 = await usageBySkill(args.days, root2);
+    json(usableHere(root2, new Map([...usage3].map(([name, u]) => [name, u.uses]))));
+    if (projectHere()) rememberProjects([root2]);
     return;
   }
+  const root = requireProject();
   const skills = projectStatus(root);
   const nested = nestedSkills(root);
   info(`${basename8(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>");
-    return;
-  }
+  if (skills.length === 0 && nested.length === 0) info("No skills in this project yet. Add one from your library with: skilllib add <name>");
   const usage2 = await usageBySkill(args.days, root);
+  const git2 = gitInfo(root, [...new Set(nested.map((s) => s.location))]);
+  const committed = (path) => ["committed", "changed"].includes(git2?.of(relativeTo(root, path)) ?? "");
+  const asRepo = {
+    "local only": "repo skill",
+    "untracked copy of library skill": "repo skill, in library",
+    "untracked, differs from library": "repo skill, differs from library"
+  };
+  const stateOf = (s) => colorState(committed(s.path) && asRepo[s.state] || s.state);
+  const agentsOf = (s) => {
+    const ids = s.visibility.filter((v) => v.paths > 0).map((v) => v.id);
+    return ids.length === s.visibility.length ? dim("all") : ids.length ? ids.map((id) => harness(id).name).join(", ") : red("none");
+  };
   if (skills.length) {
     table(
       skills.map((s) => ({
         Skill: s.name,
-        Status: s.source ? dim(`npx skills: ${s.source}`) : colorState(s.state),
+        Status: s.source ? dim(`npx skills: ${s.source}`) : stateOf(s),
+        Agents: agentsOf(s),
         [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0),
         "Last used": lastUsed(usage2.get(s.name))
       }))
@@ -2290,7 +2522,8 @@ async function status(args) {
       nested.map((s) => ({
         Skill: s.name,
         Folder: s.location,
-        Status: colorState(s.state),
+        Status: stateOf(s),
+        Agents: agentsOf(s),
         [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0)
       }))
     );
@@ -2298,18 +2531,32 @@ async function status(args) {
   const states = new Set(skills.map((s) => s.state));
   const hints = [];
   if (states.has("update available")) hints.push("`skilllib update` to install the newest versions");
-  if (states.has("folder missing")) hints.push("`skilllib sync` to restore missing skills");
+  const missing = skills.filter((s) => s.state === "folder missing");
+  if (missing.some((s) => s.latest !== null)) hints.push("`skilllib sync` to restore missing skills");
+  const notInLibrary = missing.filter((s) => s.latest === null).map((s) => s.name);
+  if (notInLibrary.length)
+    hints.push(`${notInLibrary.join(", ")} ${notInLibrary.length === 1 ? "isn't" : "aren't"} in your library (${tildify(libraryDir())}): \`skilllib import <dir>\` to add, or set SKILLLIB_HOME to the library that has ${notInLibrary.length === 1 ? "it" : "them"}`);
   if (states.has("edited locally") || states.has("edited locally, update available"))
     hints.push("`skilllib import .claude/skills/<name> --force` to save local edits to the library");
   if (states.has("local only")) hints.push("`skilllib import .claude/skills/<name>` to add a local skill to the library");
   if (states.has("untracked copy of library skill") || states.has("untracked, differs from library"))
     hints.push("`skilllib add <name>` to manage an untracked skill (--force if it differs)");
   if (hints.length > 0) info("\n" + hints.map((h) => dim(`\u2192 ${h}`)).join("\n"));
+  const here = usableHere(root);
+  const globals = new Set(here.global.flatMap((g) => g.skills)).size;
+  if (globals) info(`
+${globals} global ${globals === 1 ? "skill also loads" : "skills also load"} here ${dim("(your global folders, plugins, claude.ai): `skilllib` lists them")}`);
+  const problems = here.issues.reduce((n, i) => n + i.problems.length, 0);
+  if (problems) warn(`${problems} ${problems === 1 ? "issue" : "issues"} here or in your global skills: \`skilllib doctor\` lists them with fixes`);
   rememberProjects([root]);
 }
+async function overview(args) {
+  if (args.json || projectHere()) return status(args);
+  info("Not in a project. `skilllib projects` lists yours, `skilllib list` your library, `skilllib global` your global skills.");
+}
 async function list(args) {
   if (args.json) {
-    return json(libraryFor(currentProject()));
+    return json(libraryFor(projectHere()));
   }
   const skills = librarySkills();
   if (skills.length === 0) {
@@ -2337,14 +2584,14 @@ async function list(args) {
     );
   }
   const libraryNames = new Set(skills.map((s) => s.name));
-  const globals = machineSkills().filter((m) => m.movable && !m.broken);
+  const globals = [...new Set(machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.name))];
   if (globals.length > 0) {
     info("");
-    warn(`${globals.length} of your global skill(s) still load in every project`);
-    const missing = globals.filter((g) => !libraryNames.has(g.name));
+    warn(`${globals.length} of your global ${globals.length === 1 ? "skill still loads" : "skills still load"} in every project`);
+    const missing = globals.filter((g) => !libraryNames.has(g));
     info(
       dim(
-        missing.length > 0 ? `\u2192 \`skilllib import --global\` copies ${missing.length} of them into the library` : "\u2192 all are in your library; run `skilllib` \u2192 Global skills to stop loading them everywhere"
+        missing.length > 0 ? `\u2192 \`skilllib import --global\` copies ${missing.length} of them into the library` : "\u2192 all are in your library; run `skilllib` \u2192 Global to stop loading them everywhere"
       )
     );
   }
@@ -2384,7 +2631,7 @@ function add(args) {
     error("Usage: skilllib add <skill-name>... [--force]");
     process.exit(1);
   }
-  const root = findProjectRoot();
+  const root = requireProject();
   if (args.allowTracked) allowTrackedLinks(root);
   printChanges(root, args.positional.map((name) => addSkill(root, name, { force: args.force })), args);
   rememberProjects([root]);
@@ -2394,18 +2641,21 @@ function remove(args) {
     error("Usage: skilllib remove <skill-name>... [--force]");
     process.exit(1);
   }
-  const root = findProjectRoot();
+  const root = requireProject();
   printChanges(root, args.positional.map((name) => removeSkill(root, name, { force: args.force })), args);
 }
 function sync(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const results = roots.map((root) => {
     if (args.allowTracked) allowTrackedLinks(root);
     const changes = syncProject(root, { force: args.force });
+    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
     if (!args.json) {
       if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
-      if (changes.length === 0) success("Installed versions match skilllib.json");
-      else printChanges(root, changes, args);
+      if (changes.length === 0) {
+        if (existsSync13(join14(root, MANIFEST_FILE))) success("Installed versions match skilllib.json");
+        else info(dim("No skilllib.json: nothing to sync"));
+      } else printChanges(root, changes, args);
     }
     return { project: basename8(root), path: root, changes: withDirs(root, changes) };
   });
@@ -2413,10 +2663,16 @@ function sync(args) {
   if (!args.all) rememberProjects(roots);
 }
 function update(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const results = roots.map((root) => {
     if (args.allowTracked) allowTrackedLinks(root);
-    const changes = updateProject(root, args.positional.length ? args.positional : void 0, { force: args.force });
+    const names = args.positional.length ? args.positional : void 0;
+    const changes = updateProject(root, names, { force: args.force });
+    if (!args.all) {
+      const { skills } = readManifest(root);
+      for (const name of names ?? []) if (!(name in skills)) changes.push({ name, action: "skipped", reason: "not managed by skilllib in this project" });
+    }
+    if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
     if (!args.json) {
       if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) success("Everything is on the latest version");
@@ -2427,7 +2683,7 @@ function update(args) {
   if (args.json) json(args.all ? results : results[0].changes);
 }
 function outdated(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   const behind = roots.flatMap(
     (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ project: basename8(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
@@ -2439,7 +2695,7 @@ function outdated(args) {
 \u2192 skilllib update${args.all ? " --all" : ""}`));
 }
 function importSkills(args) {
-  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve4(p));
+  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve7(p));
   if (dirs.length === 0) {
     error("Usage: skilllib import <skill-dir>... [--force] | skilllib import --global");
     process.exit(1);
@@ -2458,9 +2714,9 @@ function importSkills(args) {
       continue;
     }
     success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
-    const skillsDir = resolve4(dir, "..");
-    const root = resolve4(skillsDir, "..", "..");
-    if (skillsDir === join15(root, ".claude", "skills") && isProjectCandidate(root)) {
+    const skillsDir = resolve7(dir, "..");
+    const root = resolve7(skillsDir, "..", "..");
+    if (skillsDir === join14(root, ".claude", "skills") && isProjectCandidate(root)) {
       if (readManifest(root).skills[name]?.hash !== treeHash(dir)) {
         const change = addSkill(root, name);
         if (change.action !== "skipped") info(dim(`  ${basename8(root)} now depends on ${name} v${change.to}`));
@@ -2479,24 +2735,34 @@ function scan(args) {
   }
   const found = discoverProjects();
   const library = new Set(librarySkills().map((s) => s.name));
-  const skillNames = (root) => [...skillDirsIn(projectSkillsDir(root)), ...skillDirsIn(agentsSkillsDir(root))].map((d) => basename8(d));
+  const skillNames = (root) => [
+    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.flatMap((d) => skillDirsIn(join14(root, d))).map((d) => basename8(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(s), ${withSkills.length} with skills
+  info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project${found.length === 1 ? "" : "s"}, ${withSkills.length} with skills
 `);
   table(
     withSkills.map((root) => ({
       Project: basename8(root),
       Path: dim(tildify(root)),
-      Skills: [...new Set(skillNames(root))].map((n) => library.has(n) ? n : yellow(n)).join(", ")
+      Skills: skillNames(root).map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
   );
   if (withSkills.length > 0) info(`
-${yellow("Yellow")} skills aren't in your library yet (import them from \`skilllib\` \u2192 3 Sources or 5 Health).`);
+${yellow("Yellow")} skills aren't in your library yet (\`skilllib import <skill-dir>\`, or \`skilllib\` \u2192 Health).`);
 }
 function folders(args) {
   const [action, ...paths] = args.positional;
+  let failed = false;
   if (action === "add") {
-    for (const p of paths) success(`Added ${tildify(addRoot(p))}`);
+    for (const p of paths) {
+      try {
+        success(`Added ${tildify(addRoot(p))}`);
+      } catch (e) {
+        error(e.message);
+        failed = true;
+      }
+    }
     discoverProjects();
   } else if (action === "remove" || action === "rm") {
     for (const p of paths) {
@@ -2508,12 +2774,24 @@ function folders(args) {
   info(roots.length ? `Project folders:
 ${roots.map((r) => `  ${tildify(r)}`).join("\n")}` : "No project folders. Add one: skilllib folders add ~/Projects");
   if (hidden.length) info(dim(`Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}  (skilllib unhide <path>)`));
+  if (failed) process.exit(1);
 }
 function unhide(args) {
+  if (args.positional.length === 0) {
+    error("Usage: skilllib unhide <path>...");
+    process.exit(1);
+  }
+  let failed = false;
   for (const p of args.positional) {
-    setHidden(expandHome(p), false);
-    success(`${tildify(expandHome(p))} is visible again`);
+    const path = expandHome(p);
+    if (setHidden(path, false)) success(`${tildify(path)} is visible again`);
+    else {
+      const { hidden } = readConfig();
+      error(`${tildify(path)} wasn't hidden. ${hidden.length ? `Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}` : "No projects are hidden."}`);
+      failed = true;
+    }
   }
+  if (failed) process.exit(1);
 }
 function newSkill(args) {
   const [name, ...rest] = args.positional;
@@ -2526,14 +2804,14 @@ function newSkill(args) {
     error(`Can't create ${name}: ${r.reason}`);
     process.exit(1);
   }
-  success(`Created ${tildify(join15(r.dir, "SKILL.md"))}`);
+  success(`Created ${tildify(join14(r.dir, "SKILL.md"))}`);
 }
 function restore(args) {
   const backups = [...listBackups(), ...pluginBackups()];
   const name = args.positional[0];
   if (!name) {
     if (backups.length === 0) return info("Nothing to restore.");
-    table(backups.map((b) => ({ Skill: b.name, From: b.kind === "trash" ? "library (deleted)" : b.kind === "plugin" ? "Claude Code plugin" : tildify(dirname5(b.from)), Moved: b.movedAt })));
+    table(backups.map((b) => ({ Skill: b.name, From: backupFrom(b), Moved: b.movedAt })));
     info(dim("\n\u2192 skilllib restore <name>"));
     return;
   }
@@ -2544,7 +2822,10 @@ function restore(args) {
   }
   const r = backup.kind === "plugin" ? restorePlugin(backup) : restoreBackup(backup);
   if (r.ok) success(`Restored ${name} to ${tildify(r.to)}`);
-  else error(`Can't restore ${name}: ${r.reason}`);
+  else {
+    error(`Can't restore ${name}: ${r.reason}`);
+    process.exitCode = 1;
+  }
 }
 async function doctor(args) {
   const projects2 = visibleProjects();
@@ -2564,13 +2845,18 @@ async function doctor(args) {
       })
     );
   }
+  const fixed = (fix) => {
+    const r = runFix(fix);
+    if (!r.ok) process.exitCode = 1;
+    return r;
+  };
   if (args.json) {
     return json(
       issues.map(({ fix, choices, ...issue }) => ({
         ...issue,
         ...fix && { fix: fix.label },
         ...choices && { choices: choices.map((c) => c.label) },
-        ...args.fix && fix && { fixed: runFix(fix) }
+        ...args.fix && fix && { fixed: fixed(fix) }
       }))
     );
   }
@@ -2580,7 +2866,7 @@ async function doctor(args) {
     info(dim(`  ${issue.detail}${issue.fix ? `  \u2192  ${issue.fix.label}` : ""}`));
     if (issue.choices) info(dim(`  choose in skilllib \u2192 Health: ${issue.choices.map((c) => c.label).join(" / ")}`));
     if (args.fix && issue.fix) {
-      const r = runFix(issue.fix);
+      const r = fixed(issue.fix);
       info(`  ${r.ok ? green("\u2713") : red("\u2717")} ${r.message}`);
     }
   }
@@ -2602,7 +2888,7 @@ async function usage(args) {
     return;
   }
   const library = new Set(librarySkills().map((s) => s.name));
-  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join15(claudeDir(), "projects"))})`)}
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join14(claudeDir(), "projects"))})`)}
 `);
   table(
     summaries.map((s) => ({
@@ -2621,7 +2907,7 @@ async function usage(args) {
 }
 function show(args) {
   const name = args.positional[0];
-  const dir = name ? join15(libraryDir(), name) : "";
+  const dir = name ? join14(libraryDir(), name) : "";
   if (!name || !isSkillDir(dir)) {
     error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
     process.exit(1);
@@ -2635,7 +2921,7 @@ function show(args) {
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
       projects: knownProjects().filter((p) => name in readManifest(p).skills).map((p) => basename8(p)),
-      skillMd: readFileSync9(join15(dir, "SKILL.md"), "utf-8")
+      skillMd: readFileSync9(join14(dir, "SKILL.md"), "utf-8")
     });
   }
   info(`${name} ${dim(tildify(dir))}`);
@@ -2664,14 +2950,21 @@ function harnessesCommand(args) {
 New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(enabled).length > 1 ? " (link)" : ""}.`));
 }
 function link(args) {
-  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const roots = args.all ? visibleProjects() : [requireProject()];
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const res = linkAll(root);
     const label = args.all ? `${basename8(root)}: ` : "";
     if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
-    else if (!args.all) success("Every skill here is already usable by all your agents");
-    if (res.blocked.length) warn(`${label}git tracks ${res.blocked.join(", ")}; re-run with --allow-tracked to link there too`);
+    else if (!args.all && !res.blocked.length && !res.uncommitted.length) success("Every skill here is already usable by all your agents");
+    if (res.blocked.length) {
+      process.exitCode = 1;
+      error(`${label}git tracks ${res.blocked.join(", ")}, so ${res.linked.length ? "some skills weren't" : "nothing was"} linked there; re-run with --allow-tracked to link there too`);
+    }
+    if (res.uncommitted.length)
+      warn(
+        `${label}${res.uncommitted.join(", ")} ${res.uncommitted.length === 1 ? "isn't" : "aren't"} committed, so not linked into folders git tracks (teammates would get broken links); commit ${res.uncommitted.length === 1 ? "it" : "them"} first`
+      );
   }
 }
 function globalCommand(args) {
@@ -2692,14 +2985,41 @@ function globalCommand(args) {
   const kept = keptGlobal();
   if (!yours.length) return info("None of your skills load globally.");
   for (const m of yours) info(`${kept.has(m.name) ? green("\u2713") : yellow("\u26A0")} ${m.name.padEnd(32)} ${dim(tildify(m.path))}`);
-  const unreviewed = yours.filter((m) => !kept.has(m.name)).length;
+  const unreviewed = new Set(yours.filter((m) => !kept.has(m.name)).map((m) => m.name)).size;
   if (unreviewed) info(dim(`
 ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <name>`));
 }
 function tidy(args) {
   const names = args.positional;
-  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve4(base, args.keep) : expandHome(args.keep)])) : {};
-  const reports = args.global ? [{ label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) }] : (args.all ? visibleProjects() : [findProjectRoot()]).map((root) => ({ label: basename8(root), report: planProjectTidy(root, { keep: keepFor(root) }) }));
+  const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve7(base, args.keep) : expandHome(args.keep)])) : {};
+  if (args.keep && !names.length) {
+    error("Usage: skilllib tidy <name>... --keep <folder>");
+    process.exit(1);
+  }
+  const targets = args.global ? [null] : args.all ? visibleProjects() : [requireProject()];
+  const problems = [];
+  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 ${basename8(targets[0])}`}`);
+      continue;
+    }
+    if (!args.keep) continue;
+    for (const { root, real } of where) {
+      if (real.includes(keepFor(root)[name])) continue;
+      const label = root ? `${basename8(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"}`
+      );
+    }
+  }
+  if (problems.length) {
+    for (const p of problems) error(p);
+    process.exit(1);
+  }
+  const reports = targets.map(
+    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename8(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
+  );
   let held = 0;
   let changed = 0;
   for (const { label, report } of reports) {
@@ -2714,6 +3034,7 @@ function tidy(args) {
       held += args.dryRun ? 0 : result.held.length;
       changed += result.applied.length;
     }
+    if (args.keep && conflicts.length) process.exitCode = 1;
     for (const c of conflicts) {
       warn(`${label} \xB7 ${c.name}: the copies differ`);
       for (const copy of c.copies) {
@@ -2756,16 +3077,19 @@ function agentSkill(args) {
 }
 
 export {
-  userHome,
   skilllibHome,
+  PROJECT_SKILLS_DIR,
   HARNESSES,
   harness,
   readSkillInfo,
   versionHistory,
   forgetLatest,
   latestVersion,
-  findProjectRoot,
-  isProjectCandidate,
+  projectHere,
+  readManifest,
+  setJsonMode,
+  error,
+  tildify,
   readConfig,
   addRoot,
   removeRoot,
@@ -2785,6 +3109,7 @@ export {
   recordOrigin,
   librarySkills,
   librarySkillDir,
+  visibilityOf,
   projectStatus,
   linkEverywhere,
   relinkDependency,
@@ -2802,8 +3127,6 @@ export {
   createSkill,
   listBackups,
   restoreBackup,
-  setJsonMode,
-  error,
   gitInfo,
   relativeTo,
   claudePlugins,
@@ -2813,6 +3136,9 @@ export {
   pluginBackups,
   restorePlugin,
   cursorPluginSkills,
+  agentSkillState,
+  installAgentSkill,
+  removeAgentSkill,
   refreshAgentSkill,
   planProjectTidy,
   planGlobalTidy,
@@ -2820,10 +3146,12 @@ export {
   applyTidy,
   describeStep,
   copyLabel,
+  addedAt,
   scanUsage,
   parseArgs,
   projectOfFactory,
   status,
+  overview,
   list,
   projects,
   add,