skilllib 1.3.1 → 1.7.0

package/dist/{tui-H5IQAGAL.js → tui-RU255WYX.js}

@@ -1,39 +1,53 @@
 import {
   HARNESSES,
+  PROJECT_SKILLS_DIR,
   addRoot,
   addSkill,
+  addedAt,
+  agentSkillState,
   allowTrackedLinks,
+  applyTidy,
   claudeBinary,
+  claudePlugins,
+  copyLabel,
   createSkill,
+  cursorPluginSkills,
   deleteGlobal,
   deleteLibrarySkill,
+  describeStep,
   discoverProjects,
   enabledHarnesses,
-  findProjectRoot,
   forgetLatest,
   gitInfo,
+  gitVisibleSteps,
   harness,
   harnessesChosen,
   importSkill,
-  isProjectCandidate,
+  installAgentSkill,
   keptGlobal,
   latestVersion,
   libraryOrigins,
   librarySkillDir,
   librarySkills,
   linkEverywhere,
+  linkGlobal,
   listBackups,
   machineSkills,
+  planGlobalTidy,
+  planProjectTidy,
   pluginBackups,
+  projectHere,
   projectOfFactory,
   projectStatus,
   projectsUsing,
   readConfig,
+  readManifest,
   readSkillInfo,
   recordOrigin,
   recordRemovedPlugin,
   relativeTo,
   relinkDependency,
+  removeAgentSkill,
   removeRoot,
   removeSkill,
   removeUntracked,
@@ -45,13 +59,16 @@ import {
   setKeepGlobal,
   setPluginEnabled,
   skilllibHome,
+  skillsLoadedIn,
   syncProject,
+  tildify,
+  turnOffIn,
   unloadGlobal,
   updateProject,
-  userHome,
   versionHistory,
+  visibilityOf,
   visibleProjects
-} from "./chunk-TWQQHXVG.js";
+} from "./chunk-AYAN7Q2X.js";
 
 // src/tui/index.tsx
 import { render } from "ink";
@@ -177,10 +194,7 @@ import { spawnSync } from "child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 var EXCERPT_CHARS = 1200;
-function tildify(p) {
-  const home = userHome();
-  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
-}
+var tildify2 = (p) => tildify(p);
 function skillExcerpt(dir, chars) {
   const file = join(dir, "SKILL.md");
   if (!existsSync(file)) return { text: "(SKILL.md not found)", files: 0, size: 0 };
@@ -204,7 +218,7 @@ function buildReviewPrompt(skills, ctx) {
       `- Description: ${s.description || "(none)"}`,
       `- Source: ${s.source}`,
       `- Installed via: ${s.installedHow}`,
-      `- Location: ${tildify(s.path)}${s.links.length ? ` (also linked from ${s.links.map(tildify).join(", ")})` : ""}`,
+      `- Location: ${tildify2(s.path)}${s.links.length ? ` (also linked from ${s.links.map(tildify2).join(", ")})` : ""}`,
       `- Loaded by: ${s.loadedBy}`,
       ...s.vendor ? [`- Vendor-managed: ${s.vendor}`] : [],
       ...s.keptGlobal ? ["- I marked this as global on purpose: recommend changing that only for a strong reason (unused, duplicated, low quality)"] : [],
@@ -230,7 +244,7 @@ function buildReviewPrompt(skills, ctx) {
 - Usage counts only cover Claude Code sessions over the last ${ctx.usageDays} days; other agents' usage isn't tracked, so treat "unused" as a strong hint, not proof.
 
 ## My projects
-${ctx.projects.map((p) => `- ${p.name} \u2014 ${tildify(p.path)}`).join("\n") || "(none)"}
+${ctx.projects.map((p) => `- ${p.name} \u2014 ${tildify2(p.path)}`).join("\n") || "(none)"}
 
 You can open the paths above (skills and projects) to check what a skill does and what each project uses (package.json, README, tech stack).
 
@@ -281,9 +295,17 @@ function matchScore(text, query) {
 }
 
 // src/tui/world.ts
+var failed = (message) => ({ message, failed: true });
+var isFailure = (r) => typeof r !== "string" && "failed" in r;
+var followUp = (r) => typeof r !== "string" && "then" in r ? r.then : void 0;
+var said = (r) => typeof r === "string" ? r : r.message;
+var joined = (results) => {
+  const message = results.map(said).join(" \xB7 ");
+  return results.some(isFailure) ? failed(message) : message;
+};
 var SEVERITY_RANK = { problem: 0, warning: 1, hint: 2 };
 function filterOf(source) {
-  return source === "lib" || source === "repo" || source === "untracked" ? "local" : source === "global" ? "global" : source === "plugin" ? "plugins" : "vendor";
+  return source === "lib" || source === "repo" || source === "untracked" ? "local" : source === "global" || source === "skilllib" ? "global" : source === "plugin" ? "plugins" : "vendor";
 }
 function project(w, name) {
   return w.projects.find((p) => p.name === name);
@@ -299,24 +321,82 @@ function dailyUses(w, name, onlyRepo) {
   }
   return days;
 }
+function machineIn(w, p) {
+  return p.machine ?? w.machine;
+}
 function usable(w, projectName) {
   const p = project(w, projectName);
   const uses = (n) => w.usage[projectName]?.[n] ?? 0;
   return [
     ...p.skills.map((s) => ({ name: s.name, source: s.source, where: s.dir, agents: s.agents, uses: uses(s.name), local: s })),
-    ...w.machine.map((m) => ({ name: m.name, source: m.source, where: m.where, agents: m.agents, uses: uses(m.name), machine: m }))
+    ...machineIn(w, p).map((m) => ({ name: m.name, source: m.source, where: m.where, agents: m.agents, uses: uses(m.name), machine: m }))
   ];
 }
 function lib(w, name) {
   return w.library.find((l) => l.name === name);
 }
+var agentNames = (ids) => ids.map((a) => harness(a).name).join(", ");
+function usedElsewhere(w, except, name) {
+  const repos = w.projects.filter((p) => p.name !== except && (w.usage[p.name]?.[name] ?? 0) > 0 && !p.skills.some((s) => s.name === name)).map((p) => p.name);
+  return repos.length ? `, and ${repos.join(", ")} used it in the last 30 days` : "";
+}
+function dupeIssues(repo, name, d) {
+  const g = repo === null ? "-g" : "";
+  if (d.differ)
+    return [
+      {
+        id: `conflict${g}:${name}`,
+        severity: "problem",
+        title: `Copies differ: ${d.differ.map((c) => c.label + (c.runs.length ? ` (${agentNames(c.runs)})` : "")).join(" vs ")}`,
+        short: "Copies differ",
+        decision: true,
+        fixes: d.differ.filter((c) => c.canWin).map((c) => ({
+          label: `Keep the ${c.label} copy`,
+          preview: `The other ${d.differ.length === 2 ? "copy becomes a link" : "copies become links"} to it, so every agent runs this one. Replaced copies go to Settings \u203A Backups.${repo ? " If git tracks a copy that changes, skilllib asks first." : ""}`,
+          run: (w) => w.ops.tidy(repo, name, { keep: c.dir })
+        }))
+      }
+    ];
+  return [
+    {
+      id: `copies${g}:${name}`,
+      severity: "warning",
+      title: repo ? "More copies or links in this repo than your agents need" : "Identical copies in several global folders",
+      short: "Extra copies",
+      decision: false,
+      fixes: [
+        {
+          label: "Keep one copy, plus the links your agents need",
+          preview: `${d.steps.join("; ")}. Replaced copies go to Settings \u203A Backups.${d.git.length ? ` Git would see ${d.git.join(", ")}: skilllib asks before ${d.git.length === 1 ? "that one" : "those"}.` : ""}`,
+          run: (w) => w.ops.tidy(repo, name)
+        }
+      ]
+    }
+  ];
+}
+function cursorPluginIssue(name, plugin) {
+  return {
+    id: `cursor-plugin:${name}`,
+    severity: "warning",
+    title: `Also in the Cursor plugin ${plugin}: Cursor lists both while it's on`,
+    short: "Also in a Cursor plugin",
+    decision: true,
+    fixes: [
+      {
+        label: "Turn the plugin off in Cursor (Settings \u203A Plugins)",
+        preview: "skilllib can't read or change Cursor's plugins. Your skill wins once the plugin is off.",
+        run: () => `Turn ${plugin} off in Cursor; skilllib can't tell whether it's on`
+      }
+    ]
+  };
+}
 function globalFixes(m) {
   return [
     {
       label: "Move it to the repos that need it\u2026",
       preview: `Pick repos. ${m.name} goes into your library and those repos, and stops loading globally (original backed up).`,
       run: () => "",
-      pickRepos: (w, repos) => w.ops.moveGlobal(m, repos)
+      pickRepos: (w, repos) => w.ops.moveGlobal([m], repos)
     },
     m.kept ? { label: "Stop marking it as global on purpose", preview: `skilllib warns about ${m.name} again, like any global skill.`, run: (w) => w.ops.keepGlobal(m.name, false) } : { label: "Keep it global on purpose", preview: `Mark ${m.name} as global on purpose. skilllib stops warning about it.`, run: (w) => w.ops.keepGlobal(m.name, true) },
     { label: "Delete it", preview: `Remove ${m.path}. A backup is kept in Settings \u203A Backups.`, run: (w) => w.ops.deleteGlobal(m) }
@@ -324,9 +404,10 @@ function globalFixes(m) {
 }
 function machineActions(m) {
   if (m.broken) return [];
-  return m.source === "global" ? globalFixes(m) : [];
+  return m.source === "global" ? globalFixes(m) : m.source === "skilllib" ? [removeAgentSkillFix()] : [];
 }
 function machineIssues(w, m) {
+  if (m.source === "skilllib") return [agentSkillIssue(w)].flatMap((i) => i ? [i] : []);
   if (m.broken)
     return [
       {
@@ -346,42 +427,64 @@ function machineIssues(w, m) {
       severity: "problem",
       title: `Loaded twice: also in ${other.source} ${other.where}`,
       short: "Loaded twice",
-      decision: false,
+      // Every repo then runs the other copy instead of yours: a decision, never "fix all".
+      decision: true,
       fixes: [
         {
           label: `Keep the ${other.source}'s copy, stop loading yours globally`,
-          preview: `Copy ${m.name} into your library if needed, then move ${m.path} to the backups.`,
+          preview: `Copy ${m.name} into your library if needed, then move ${m.path} to the backups. Every repo then runs the ${other.source}'s copy instead of yours.`,
           run: (w2) => w2.ops.unloadGlobal(m)
         }
       ]
     });
-  const twins = w.machine.filter((x) => x.source === "global" && x.name === m.name && !x.broken && x.agents.some((a) => m.agents.includes(a)));
-  if (m.source === "global" && twins.length > 1)
+  if (m.source === "global" && m.dupes) issues.push(...dupeIssues(null, m.name, m.dupes));
+  if (m.source === "global" && m.cursorPlugin && m.agents.includes("cursor")) issues.push(cursorPluginIssue(m.name, m.cursorPlugin));
+  const seen = new Set(w.machine.filter((x) => x.name === m.name && !x.broken).flatMap((x) => x.agents));
+  const blind = m.source === "global" && m.agents.length && !m.dupes ? w.agents.filter((a) => !seen.has(a)) : [];
+  const names = blind.map((a) => harness(a).name).join(", ");
+  const link = {
+    label: `Link it for ${names}`,
+    preview: `Add a link in the global skills folder ${names} read${blind.length === 1 ? "s" : ""} (nothing is copied or moved), so ${names} load${blind.length === 1 ? "s" : ""} it in every repo too.`,
+    run: (w2) => w2.ops.linkGlobal(m, blind)
+  };
+  if (m.kept && blind.length)
+    issues.push({ id: `blind-global:${m.name}`, severity: "warning", title: `${names} can't see it: only ${m.agents.map((a) => harness(a).name).join(", ")} load${m.agents.length === 1 ? "s" : ""} it`, short: `${names} can't see it`, decision: false, fixes: [link] });
+  if (m.source === "global" && !m.kept) {
+    const [move, ...rest] = globalFixes(m);
     issues.push({
-      id: `dup-global:${m.name}`,
-      severity: "problem",
-      title: `Loaded twice: in ${twins.map((t) => t.where).join(" and ")}`,
-      short: "Loaded twice",
+      id: `global:${m.name}`,
+      severity: "warning",
+      title: blind.length ? `Global, not reviewed: loads in every repo, but ${names} can't see it` : "Global, not reviewed: loads in every repo",
+      short: blind.length ? `Not reviewed \xB7 ${names} can't see it` : "Not reviewed",
       decision: true,
-      fixes: twins.map((t) => ({ label: `Delete the copy in ${t.where}`, preview: `Move ${t.path} to Settings \u203A Backups; the other copy stays.`, run: (w2) => w2.ops.deleteGlobal(t) }))
+      fixes: blind.length ? [move, link, ...rest] : [move, ...rest]
     });
-  if (m.source === "global" && !m.kept)
-    issues.push({ id: `global:${m.name}`, severity: "warning", title: "Global, not reviewed: loads in every repo", short: "Not reviewed", decision: true, fixes: globalFixes(m) });
+  }
   return issues;
 }
 function issuesOf(w, projectName, u) {
   const s = u.local;
   const issues = [];
   const shares = (m) => m.name === s.name && !m.broken && m.agents.some((a) => s.agents.includes(a));
-  const g = w.machine.find((m) => m.source === "global" && shares(m));
-  const vendor = w.machine.find((m) => m.source !== "global" && shares(m));
+  const loaded = machineIn(w, project(w, projectName));
+  const g = loaded.find((m) => m.source === "global" && shares(m));
+  const vendor = loaded.find((m) => m.source !== "global" && shares(m));
   const l = lib(w, s.name);
   const remove = {
     label: "Remove this repo's copy",
     preview: s.source === "lib" ? `Delete ${s.dir}/${s.name} in ${projectName}. Your library keeps it.` : `Move ${s.dir}/${s.name} in ${projectName} to Settings \u203A Backups.`,
     run: (w2) => w2.ops.remove(projectName, s.name)
   };
-  if (s.missing)
+  if (s.missing && s.library === "missing")
+    issues.push({
+      id: `unavailable:${s.name}`,
+      severity: "problem",
+      title: "Pinned in skilllib.json, but not in your library: import it, or set SKILLLIB_HOME to the library that has it",
+      short: "Pinned, not in your library",
+      decision: true,
+      fixes: [{ label: "Remove it from skilllib.json", preview: `${projectName}'s skilllib.json stops pinning ${s.name} v${s.version}. There's no folder to delete.`, run: (w2) => w2.ops.remove(projectName, s.name) }]
+    });
+  else if (s.missing)
     issues.push({
       id: `missing:${s.name}`,
       severity: "problem",
@@ -390,7 +493,7 @@ function issuesOf(w, projectName, u) {
       decision: false,
       fixes: [{ label: "Restore it (sync)", preview: `Reinstall ${s.name} v${s.version} into ${s.dir}.`, run: (w2) => w2.ops.restore(projectName, s.name) }]
     });
-  if (s.source === "lib" && s.library === "missing")
+  else if (s.source === "lib" && s.library === "missing")
     issues.push({
       id: `not-in-lib:${s.name}`,
       severity: "problem",
@@ -399,23 +502,50 @@ function issuesOf(w, projectName, u) {
       decision: false,
       fixes: [{ label: "Copy it back into your library", preview: `Copy this repo's ${s.name} into your library, so it can be restored and shared again.`, run: (w2) => w2.ops.copyToLibrary(projectName, s.name) }]
     });
-  if (g)
+  if (g?.kept)
+    issues.push({
+      id: `kept-g:${s.name}`,
+      severity: "warning",
+      title: `Also global in ${g.where}, and you keep it global: this repo's copy is extra`,
+      short: "Extra: you keep it global",
+      decision: true,
+      fixes: [
+        ...s.source !== "repo" ? [{ ...remove, label: "Remove this repo's copy, keep it global" }] : [],
+        {
+          label: "Stop loading it globally after all",
+          preview: `Copy ${s.name} into your library if needed, then move ${g.path} to the backups. Every other repo stops seeing it${usedElsewhere(w, projectName, s.name)}.`,
+          run: (w2) => w2.ops.unloadGlobal(g)
+        }
+      ]
+    });
+  else if (g)
     issues.push({
       id: `twice-g:${s.name}`,
       severity: "problem",
       title: `Loaded twice: also global in ${g.where}`,
       short: "Loaded twice",
-      decision: false,
+      // Unloading the global copy changes every repo: a decision, never "fix all".
+      decision: true,
       fixes: [
         {
           label: "Keep this repo's copy, stop loading it globally",
-          preview: `Copy ${s.name} into your library if needed, then move ${g.path} to the backups. Other repos stop seeing it.`,
+          preview: `Copy ${s.name} into your library if needed, then move ${g.path} to the backups. Every other repo stops seeing it${usedElsewhere(w, projectName, s.name)}.`,
           run: (w2) => w2.ops.unloadGlobal(g)
         },
         ...s.source !== "repo" ? [{ ...remove, label: "Keep it global, remove it from this repo" }] : []
       ]
     });
-  if (vendor)
+  const cursorOnly = vendor?.source === "plugin" && w.agents.includes("claude-code") && !vendor.agents.includes("claude-code");
+  if (vendor && cursorOnly)
+    issues.push({
+      id: `twice-p:${s.name}`,
+      severity: "warning",
+      title: `Same name as a skill in plugin ${vendor.where}: Claude Code has it off in ${projectName}, but Cursor ignores repo settings and lists both`,
+      short: "Cursor also lists a plugin's copy",
+      decision: true,
+      fixes: [replacePluginFix(w, vendor.where)]
+    });
+  else if (vendor)
     issues.push({
       id: `twice-p:${s.name}`,
       severity: "problem",
@@ -424,13 +554,19 @@ function issuesOf(w, projectName, u) {
       decision: true,
       fixes: [
         ...s.source !== "repo" ? [{ ...remove, label: `Remove this repo's copy, use the ${vendor.source}'s` }] : [],
-        {
-          label: vendor.source === "plugin" ? "Turn the plugin off with /plugin in Claude Code" : `Turn it off in ${vendor.where}`,
-          preview: "skilllib can't turn it off for you yet.",
+        vendor.source === "plugin" ? {
+          label: `Turn the plugin off in ${projectName} only`,
+          preview: `Sets "${vendor.where}": false in ${projectName}'s .claude/settings.local.json (claude plugin disable --scope local), a local-only file git ignores. Other repos keep it.${vendor.agents.includes("cursor") ? " Cursor ignores repo settings, so it still lists both." : ""}`,
+          run: (w2) => w2.ops.pluginOffHere(projectName, vendor.where)
+        } : {
+          label: `Turn it off in ${vendor.where}`,
+          preview: "skilllib can't turn it off for you.",
           run: () => `Turn ${vendor.where} off at its source; skilllib picks it up next time`
         }
       ]
     });
+  if (s.dupes) issues.push(...dupeIssues(projectName, s.name, s.dupes));
+  if (s.cursorPlugin && s.agents.includes("cursor")) issues.push(cursorPluginIssue(s.name, s.cursorPlugin));
   if (s.source === "lib" && s.edited)
     issues.push({
       id: `edited:${s.name}`,
@@ -453,22 +589,36 @@ function issuesOf(w, projectName, u) {
       fixes: [{ label: `Update to v${l.latest}`, preview: `Replace ${s.dir}/${s.name} with library v${l.latest}.`, run: (w2) => w2.ops.update(projectName, s.name) }]
     });
   const blind = w.agents.filter((a) => !u.agents.includes(a));
-  if (!s.missing && blind.length)
+  const unshared = blind.filter((a) => s.unshared?.includes(a));
+  const linkable = blind.filter((a) => !unshared.includes(a));
+  const commitFirst = unshared.length ? ` ${agentNames(unshared)} ${unshared.length === 1 ? "needs" : "need"} it committed first (git tracks the folder they read).` : "";
+  if (!s.missing && linkable.length)
     issues.push({
       id: `blind:${s.name}`,
       severity: "warning",
-      title: `${blind.map((a) => harness(a).name).join(", ")} can't see it`,
-      short: `${blind.map((a) => harness(a).name).join(", ")} can't see it`,
+      title: `${agentNames(blind)} can't see it`,
+      short: `${agentNames(blind)} can't see it`,
       decision: false,
       fixes: [
         {
           label: "Link it for every agent",
-          preview: `Add links (nothing is copied or moved), so ${blind.map((a) => harness(a).name).join(", ")} load it too.`,
+          preview: `Add links (nothing is copied or moved), so ${agentNames(linkable)} ${linkable.length === 1 ? "loads" : "load"} it too.${commitFirst}`,
           run: (w2) => w2.ops.link(projectName, s.name)
         }
       ]
     });
-  if (s.source !== "lib" && s.library === "differs")
+  else if (!s.missing && unshared.length)
+    issues.push({
+      id: `blind:${s.name}`,
+      severity: "warning",
+      title: `${agentNames(unshared)} can't see it: commit ${s.dir}/${s.name} first, then link it (git tracks the folder they read, and a link to an uncommitted copy would break for teammates)`,
+      short: `${agentNames(unshared)} can't see it: commit it first`,
+      // Nothing skilllib can do: committing is yours.
+      decision: true,
+      fixes: []
+    });
+  const differ = !!s.dupes?.differ;
+  if (s.source !== "lib" && s.library === "differs" && !differ)
     issues.push({
       id: `differs:${s.name}`,
       severity: "hint",
@@ -480,22 +630,24 @@ function issuesOf(w, projectName, u) {
         ...s.source === "untracked" ? [{ label: "Replace it with the library version", preview: `Replace ${s.dir}/${s.name} with your library's newest version and track it (this copy backed up).`, run: (w2) => w2.ops.discardEdits(projectName, s.name) }] : []
       ]
     });
-  if (s.source === "untracked" && s.library === "same")
+  if (s.source === "untracked" && s.library === "same" && !differ)
     issues.push({
       id: `adopt:${s.name}`,
       severity: "hint",
       title: "Same as your library skill, but not tracked",
       short: "Not tracked",
-      decision: false,
+      // It writes to the repo's skilllib.json (and your library): your call, never in Fix all (as in doctor, #11).
+      decision: true,
       fixes: [{ label: "Track it", preview: `Record ${s.name} in skilllib.json so library updates reach it.`, run: (w2) => w2.ops.track(projectName, s.name) }]
     });
-  if (s.source === "untracked" && !l && !vendor)
+  if (s.source === "untracked" && !l && !vendor && !differ)
     issues.push({
       id: `local:${s.name}`,
       severity: "hint",
       title: "Only exists in this repo",
       short: "Only in this repo",
-      decision: false,
+      // It writes to the repo's skilllib.json (and your library): your call, never in Fix all (as in doctor, #11).
+      decision: true,
       fixes: [
         {
           label: "Import it into your library",
@@ -504,7 +656,7 @@ function issuesOf(w, projectName, u) {
         }
       ]
     });
-  if (s.source === "lib" && w.days && u.uses === 0 && !s.missing)
+  if (s.source === "lib" && w.days && u.uses === 0 && !s.missing && (s.added ?? 0) <= Date.now() - 30 * 24 * 60 * 60 * 1e3)
     issues.push({
       id: `unused:${s.name}`,
       severity: "hint",
@@ -515,6 +667,53 @@ function issuesOf(w, projectName, u) {
     });
   return issues;
 }
+function agentSkillFix(w) {
+  return {
+    label: w.agentSkill === "outdated" ? "Update the skilllib skill" : "Install the skilllib skill for your agents",
+    preview: "One global skill, skilllib, where your agents look in every repo (~/.claude/skills, and ~/.agents/skills for Codex and Zed). Then ask your agents which skills they can use here, where each comes from, and which of your skills a repo should add. `skilllib agent-skill remove` takes it out.",
+    run: (w2) => w2.ops.installAgentSkill()
+  };
+}
+function removeAgentSkillFix() {
+  return {
+    label: "Remove the skilllib skill",
+    preview: "Removes it from ~/.claude/skills and ~/.agents/skills, where skilllib put it. Your agents then stop using skilllib to answer which skills they can use. Settings \u203A skilllib skill puts it back.",
+    run: (w) => w.ops.removeAgentSkill()
+  };
+}
+function agentSkillIssue(w) {
+  if (w.agentSkill === "installed" || !w.agents.length) return null;
+  const missing = w.agentSkill === "missing";
+  return {
+    id: "agent-skill",
+    severity: missing ? "hint" : "warning",
+    title: missing ? "Your agents don't know about skilllib" : "The skilllib skill for your agents is out of date",
+    short: missing ? "Your agents don't know about skilllib" : "Out of date",
+    decision: missing,
+    fixes: [agentSkillFix(w)]
+  };
+}
+function runAll(w, fixes) {
+  const held = [];
+  const bad = [];
+  for (const fix of fixes) {
+    let r;
+    try {
+      r = fix.run(w);
+    } catch (e) {
+      r = failed(e.message);
+    }
+    if (isFailure(r)) bad.push(said(r));
+    else if (followUp(r)) held.push(said(r));
+  }
+  const ok = fixes.length - held.length - bad.length;
+  const message = [
+    `Applied ${ok}${ok === fixes.length ? "" : ` of ${fixes.length}`} fix${fixes.length === 1 ? "" : "es"}${ok ? " (anything removed is in Settings \u203A Backups)" : ""}`,
+    held.length ? `${held.join("; ")} (fix ${held.length === 1 ? "it" : "them"} on ${held.length === 1 ? "its" : "their"} own to go ahead)` : "",
+    bad.length ? `couldn't: ${bad.join("; ")}` : ""
+  ].filter(Boolean).join(" \xB7 ");
+  return bad.length ? failed(message) : message;
+}
 function worst(issues) {
   return [...issues].sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity])[0];
 }
@@ -543,7 +742,7 @@ function deleteLibraryFix(w, names) {
       "Every copy goes to Settings \u203A Backups.",
       others.length ? `Untracked or the team's own copies in ${others.join(", ")} stay.` : ""
     ].filter(Boolean).join(" "),
-    run: (w2) => names.map((n) => w2.ops.deleteLibrary(n)).map((r) => typeof r === "string" ? r : r.message).join(" \xB7 ")
+    run: (w2) => joined(names.map((n) => w2.ops.deleteLibrary(n)))
   };
 }
 function replacePluginFix(w, id) {
@@ -589,6 +788,8 @@ function groupCandidates(w, u) {
   if (m?.source === "plugin") return [{ key: `plugin:${m.where}`, label: `\u29C9 ${m.where.split("@")[0]} plugin` }];
   if (m?.source === "claude.ai") return [{ key: "claude.ai", label: "claude.ai skills" }];
   if (m?.source === "cursor") return [{ key: "cursor", label: "Cursor built-ins" }];
+  if (m?.source === "system") return [{ key: `system:${m.where}`, label: m.where }];
+  if (m?.source === "skilllib") return [];
   if (m) {
     const origin = originGroup(m.origin);
     return [...origin ? [origin] : [], ...byTime("global", m.installed), ...byWord("global", m.name)];
@@ -632,10 +833,8 @@ function addRows(w, target, q) {
       name: q ? `+ Create "${q}"${where}` : "+ Create a new skill (type its name)",
       note: "",
       description: "",
-      run: (w2) => {
-        const made = w2.ops.createSkill(q);
-        return target ? w2.ops.add(target, q) : made;
-      }
+      run: (w2) => w2.ops.createSkill(q),
+      ...target ? { afterEdit: (w2) => w2.ops.add(target, q) } : {}
     },
     { key: "agent", agent: true, name: q ? `\u2726 Write "${q}" with an agent` : "\u2726 Write a new skill with an agent", note: "", description: "" }
   ];
@@ -644,9 +843,32 @@ function addRows(w, target, q) {
 }
 
 // src/tui/prompts.ts
-function reviewPrompt(w, names, scope) {
+var agentNames2 = (agents) => agents.map((a) => harness(a).name).join(", ") || "none of my agents";
+var localSource = (s) => s.source === "lib" ? "Your skills (skilllib library), installed in the repo" : s.source === "repo" ? "a repo's own skill (committed by the team)" : "a copy only on this machine (not committed)";
+var localInstalled = (s) => s.origin ?? (s.source === "lib" ? "added from my library with skilllib" : s.source === "repo" ? "committed in the repo" : "copied into the repo by hand (not committed)");
+function reviewPrompt(w, names, scope, repo) {
   const skills = names.map((name) => {
     const copies = w.machine.filter((m2) => m2.name === name);
+    const here = repo ? w.projects.find((p) => p.name === repo)?.skills.find((s) => s.name === name) : void 0;
+    if (here) {
+      const lib3 = w.library.find((l) => l.name === name);
+      return {
+        name,
+        description: w.descriptions[name] ?? "",
+        source: localSource(here),
+        installedHow: localInstalled(here),
+        path: here.path,
+        links: [],
+        loadedBy: `${agentNames2(here.agents)} \u2014 in ${repo}`,
+        vendor: null,
+        usesTotal: w.days ? totalUses(w, name) : null,
+        usesByProject: Object.entries(w.usage).flatMap(([p, u]) => u[name] ? [[p, u[name]]] : []),
+        installedIn: w.projects.filter((p) => p.skills.some((s) => s.name === name)).map((p) => p.name),
+        otherCopies: copies.map((c) => `${c.source} ${c.where}`),
+        inYourSkills: lib3 ? `yes, v${lib3.latest}` : null,
+        keptGlobal: void 0
+      };
+    }
     const m = copies.find((c) => c.source === "global") ?? copies[0];
     const lib2 = w.library.find((l) => l.name === name);
     const repos = w.projects.filter((p) => p.skills.some((s) => s.name === name));
@@ -654,11 +876,11 @@ function reviewPrompt(w, names, scope) {
     return {
       name,
       description: w.descriptions[name] ?? "",
-      source: m ? m.source === "global" ? "my global skills" : `vendor: ${m.source} (${m.where})` : lib2 ? "Your skills (skilllib library)" : "a repo's own skill",
-      installedHow: m?.origin ?? (m ? m.where : lib2 ? "created or imported into skilllib" : "committed in the repo"),
+      source: m ? m.source === "global" ? "my global skills" : `vendor: ${m.source} (${m.where})` : lib2 ? "Your skills (skilllib library)" : local ? localSource(local) : "a repo's own skill",
+      installedHow: m?.origin ?? (m ? m.where : lib2 ? "created or imported into skilllib" : local ? localInstalled(local) : "committed in the repo"),
       path: m?.path ?? (lib2 ? w.ops.libraryFile(name).replace(/\/SKILL\.md$/, "") : local?.path ?? ""),
       links: m?.links ?? [],
-      loadedBy: m ? `${m.agents.map((a) => harness(a).name).join(", ") || "none of my agents"} \u2014 in every repo` : `repos: ${repos.map((p) => p.name).join(", ") || "none"}`,
+      loadedBy: m ? `${agentNames2(m.agents)} \u2014 in every repo` : repos.map((p) => `${agentNames2(p.skills.find((s) => s.name === name).agents)} \u2014 in ${p.name}`).join("; ") || "none of my agents",
       vendor: m && m.source !== "global" ? "turn it off at its source (/plugin in Claude Code, claude.ai settings, or Cursor)" : null,
       usesTotal: w.days ? totalUses(w, name) : null,
       usesByProject: Object.entries(w.usage).flatMap(([p, u]) => u[name] ? [[p, u[name]]] : []),
@@ -691,9 +913,7 @@ Keep it under 200 lines. ${p ? "skilllib will offer to import it into my library
 
 // src/tui/App.tsx
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function tildify2(p) {
-  return p.startsWith(userHome()) ? "~" + p.slice(userHome().length) : p;
-}
+var tildify3 = (p) => tildify(p);
 var PLACES = [
   ["projects", "Projects"],
   ["library", "Your skills"],
@@ -725,6 +945,7 @@ function tag(u, w) {
   if (s) return [s.source, color.blue];
   if (u.source === "global") return [u.machine?.kept ? "global \u2713" : "global", color.yellow];
   if (u.source === "plugin") return [`\u29C9 ${u.where.split("@")[0]}`, color.magenta];
+  if (u.source === "skilllib") return ["\u25C6 skilllib", color.accent];
   return [u.source, color.muted];
 }
 function isNameChar(input, key) {
@@ -775,7 +996,7 @@ function TitleRow({ cells, width }) {
 }
 var fixOption = (fix) => ({ label: fix.label, fix });
 var GIT_LABEL = { committed: "\u2713 committed", changed: "\xB1 uncommitted changes", new: "+ not committed", ignored: "\u2205 gitignored" };
-var COPY_RANK = { lib: 0, repo: 0, untracked: 0, global: 1, plugin: 2, "claude.ai": 3, cursor: 3 };
+var COPY_RANK = { lib: 0, repo: 0, untracked: 0, global: 1, skilllib: 1, plugin: 2, "claude.ai": 3, cursor: 3, system: 3 };
 function byName(copies) {
   const groups = /* @__PURE__ */ new Map();
   for (const c of copies) groups.set(c.name, [...groups.get(c.name) ?? [], c]);
@@ -843,7 +1064,7 @@ function skillItem(w, copies, issues, nameW, actions, repo) {
       const b = builder(u.name);
       for (const l of wrap(w.descriptions[u.name] || "(no description)", width - 4, 3)) b.line([l, color.muted]);
       b.line();
-      if (repo && !u.local) b.line(["Loads in every repo", color.text], [u.source === "global" ? "   issues and cleanup live in Global" : "   managed at its source", color.faint]);
+      if (repo && !u.local) b.line(["Loads in every repo", color.text], [u.source === "global" || u.source === "skilllib" ? "   issues and cleanup live in Global" : "   managed at its source", color.faint]);
       else b.issues(issues);
       b.actions(actions, width);
       b.line();
@@ -852,7 +1073,7 @@ function skillItem(w, copies, issues, nameW, actions, repo) {
       b.line(["Loaded from", color.accent]);
       for (const c of copies) {
         const s = c.local;
-        const path = s ? `${s.dir}/${c.name}` : c.source === "global" ? `${c.where}/${c.name}` : c.where;
+        const path = s ? `${s.dir}/${c.name}` : c.source === "global" || c.source === "skilllib" ? `${c.where}/${c.name}` : c.where;
         const extra = s ? s.missing ? "missing" : s.git ? GIT_LABEL[s.git] : "" : "";
         const [ct, cc] = c === u ? ["", void 0] : tag(c, w);
         b.line(["  ", void 0], [path + "  ", color.text], [ct ? ct + "  " : "", cc], [extra, color.faint]);
@@ -866,7 +1087,10 @@ function projectSkillItems(w, p, nameW, ui) {
     (copies) => skillItem(w, copies, mergeIssues(copies.filter((c) => c.local).map((c) => issuesOf(w, p, c))), nameW, skillActions(w, p, copies[0], ui), p)
   );
 }
-var reviewOption = (w, name, ui) => ({ label: "Review prompt", action: () => ui.copy(reviewPrompt(w, [name], `Review the skill ${name}.`), `a review prompt for ${name}`) });
+var reviewOption = (w, name, ui, repo) => ({
+  label: "Review prompt",
+  action: () => ui.copy(reviewPrompt(w, [name], `Review the skill ${name}${repo ? ` in ${repo}` : ""}.`, repo), `a review prompt for ${name}`)
+});
 function versionsOption(w, repo, name, installed, ui) {
   return {
     label: "Other versions\u2026",
@@ -879,27 +1103,35 @@ function versionsOption(w, repo, name, installed, ui) {
 function skillActions(w, p, u, ui) {
   const s = u.local;
   const inLibrary = w.library.find((l) => l.name === u.name);
-  const remove = { label: "Remove from repo", preview: s?.source === "lib" ? `Delete ${s.dir}/${u.name} in ${p}. Your library keeps it.` : `Move ${s?.dir}/${u.name} in ${p} to Settings \u203A Backups.`, run: (w2) => w2.ops.remove(p, u.name) };
+  const remove = {
+    // Its folder gone: all that's left to remove is the skilllib.json entry (the label Health offers too).
+    label: s?.missing ? "Remove it from skilllib.json" : "Remove from repo",
+    preview: s?.missing ? `${p}'s skilllib.json stops pinning ${u.name}. There's no folder to delete.` : s?.source === "lib" ? `Delete ${s.dir}/${u.name} in ${p}.${inLibrary ? " Your library keeps it." : ""}` : `Move ${s?.dir}/${u.name} in ${p} to Settings \u203A Backups.`,
+    run: (w2) => w2.ops.remove(p, u.name)
+  };
   if (s?.source === "lib")
     return [
-      ...inLibrary && s.version < inLibrary.latest ? [fixOption({ label: `Update to v${inLibrary.latest}`, preview: `Replace ${s.dir}/${u.name} with library v${inLibrary.latest}.`, run: (w2) => w2.ops.update(p, u.name) })] : [],
-      { label: "Edit in library", action: () => ui.edit(w.ops.libraryFile(u.name)) },
-      versionsOption(w, p, u.name, s.version, ui),
+      // A tracked skill your library doesn't have: nothing to edit there, no versions to pick.
+      ...inLibrary ? [
+        ...s.version < inLibrary.latest ? [fixOption({ label: `Update to v${inLibrary.latest}`, preview: `Replace ${s.dir}/${u.name} with library v${inLibrary.latest}.`, run: (w2) => w2.ops.update(p, u.name) })] : [],
+        { label: "Edit in library", action: () => ui.edit(w.ops.libraryFile(u.name)) },
+        versionsOption(w, p, u.name, s.version, ui)
+      ] : [],
       fixOption(remove),
-      reviewOption(w, u.name, ui)
+      reviewOption(w, u.name, ui, p)
     ];
   if (s?.source === "repo")
     return [
       ...inLibrary ? [] : [fixOption({ label: "Copy into library", preview: `Copy ${u.name} into your library, so other repos can add it. The repo's copy stays as it is.`, run: (w2) => w2.ops.copyToLibrary(p, u.name) })],
       { label: "Edit SKILL.md", action: () => ui.edit(`${s.path}/SKILL.md`) },
-      reviewOption(w, u.name, ui)
+      reviewOption(w, u.name, ui, p)
     ];
   if (s)
     return [
       inLibrary ? fixOption({ label: "Track it", preview: `Record ${u.name} in skilllib.json so library updates reach it.`, run: (w2) => w2.ops.track(p, u.name) }) : fixOption({ label: "Import it into your library", preview: `Copy ${u.name} into your library and track it here.`, run: (w2) => w2.ops.importLocal(p, u.name) }),
       { label: "Edit SKILL.md", action: () => ui.edit(`${s.path}/SKILL.md`) },
       fixOption(remove),
-      reviewOption(w, u.name, ui)
+      reviewOption(w, u.name, ui, p)
     ];
   return [{ label: "Open in Global", action: () => ui.openInGlobal(u.name) }, reviewOption(w, u.name, ui)];
 }
@@ -908,7 +1140,7 @@ function overview(w, p) {
   const info = w.ops.repoInfo(p);
   const manifest = project2.manifest === "none" ? ["no skilllib.json", color.faint] : project2.manifest === "no git" ? ["skilllib.json (not a git repo)", color.muted] : [`skilllib.json ${GIT_LABEL[project2.manifest]}`, project2.manifest === "committed" ? color.text : color.yellow];
   return [
-    ["Folder", [[tildify2(project2.path), color.text]]],
+    ["Folder", [[tildify3(project2.path), color.text]]],
     ["Remote", [[info.remote ?? "none", info.remote ? color.blue : color.faint]]],
     ["Branch", [[info.branch ?? "\u2013", color.text], [info.dirty ? `  ${info.dirty} uncommitted` : "", color.yellow]]],
     ["Manifest", [manifest]]
@@ -955,11 +1187,11 @@ function globalItems(w, nameW, ui) {
 }
 function globalActions(w, u, ui) {
   const m = u.machine;
-  const atSource = m.source === "plugin" ? "Turn it off with /plugin in Claude Code" : m.source === "claude.ai" ? "Turn it off in claude.ai \u203A Settings" : "Cursor manages it";
+  const atSource = m.source === "plugin" ? "Turn it off with /plugin in Claude Code" : m.source === "claude.ai" ? "Turn it off in claude.ai \u203A Settings" : m.source === "system" ? `An admin manages ${m.where}` : "Cursor manages it";
   return [
     ...machineActions(m).map(fixOption),
     ...m.source === "plugin" ? [fixOption(replacePluginFix(w, m.where))] : [],
-    ...m.source === "global" ? [] : [{ label: atSource, action: () => ui.notify(`${atSource}; skilllib picks up the change next time`) }],
+    ...m.source === "global" || m.source === "skilllib" ? [] : [{ label: atSource, action: () => ui.notify(`${atSource}; skilllib picks up the change next time`) }],
     ...m.source === "global" && !m.broken ? [{ label: "Edit SKILL.md", action: () => ui.edit(`${m.path}/SKILL.md`) }] : [],
     reviewOption(w, m.name, ui)
   ];
@@ -967,8 +1199,9 @@ function globalActions(w, u, ui) {
 function libraryItems(w, nameW, ui) {
   return w.library.map((l) => {
     const repos = w.projects.filter((p) => p.skills.some((s) => s.name === l.name));
+    const removable = repos.filter((p) => p.skills.some((s) => s.name === l.name && s.source !== "repo"));
     const uses = totalUses(w, l.name);
-    const addFix = { label: "Add to repos\u2026", preview: `Install ${l.name} v${l.latest} into the repos you pick.`, run: () => "", candidates: (w2) => w2.projects.filter((p) => !p.skills.some((s) => s.name === l.name)).map((p) => p.name), pickRepos: (w2, rs) => rs.map((r) => said(w2.ops.add(r, l.name))).join(" \xB7 ") };
+    const addFix = { label: "Add to repos\u2026", preview: `Install ${l.name} v${l.latest} into the repos you pick.`, run: () => "", candidates: (w2) => w2.projects.filter((p) => !p.skills.some((s) => s.name === l.name)).map((p) => p.name), pickRepos: (w2, rs) => w2.ops.addTo(rs, [l.name]) };
     const delFix = deleteLibraryFix(w, [l.name]);
     const issues = repos.length ? [] : [{ id: `nowhere:${l.name}`, severity: "hint", title: "Used in no repo", short: "Used in no repo", decision: true, fixes: [addFix, delFix] }];
     const behind = repos.filter((p) => p.skills.some((s) => s.name === l.name && s.source === "lib" && s.version < l.latest)).length;
@@ -1000,13 +1233,13 @@ function libraryItems(w, nameW, ui) {
         b.issues(issues);
         b.actions([
           fixOption(addFix),
-          ...repos.length ? [
+          ...removable.length ? [
             fixOption({
               label: "Remove from repos\u2026",
               preview: `Pick repos to remove ${l.name} from. Your library keeps it.`,
               run: () => "",
-              candidates: () => repos.map((p) => p.name),
-              pickRepos: (w2, rs) => rs.map((r) => said(w2.ops.remove(r, l.name))).join(" \xB7 ")
+              candidates: () => removable.map((p) => p.name),
+              pickRepos: (w2, rs) => joined(rs.map((r) => w2.ops.remove(r, l.name)))
             })
           ] : [],
           fixOption(delFix),
@@ -1022,15 +1255,39 @@ function libraryItems(w, nameW, ui) {
 }
 function healthItems(w, nameW, ui) {
   const flagged = (where, items) => items.filter((i) => i.issues.length).map((i) => ({ ...i, key: `${where}:${i.key}`, cells: [i.cells[0], i.cells[1], { text: clip(where, 16), width: 16, color: color.muted }, i.cells[4]] }));
-  return [...w.projects.flatMap((p) => flagged(p.name, projectSkillItems(w, p.name, nameW, ui))), ...flagged("Global", globalItems(w, nameW, ui))];
+  return [...w.projects.flatMap((p) => flagged(p.name, projectSkillItems(w, p.name, nameW, ui))), ...flagged("Global", globalItems(w, nameW, ui)), ...agentSkillItems(w, nameW)];
+}
+function agentSkillItems(w, nameW) {
+  const issue = agentSkillIssue(w);
+  if (!issue || w.machine.some((m) => m.source === "skilllib")) return [];
+  const sev = SEV[issue.severity];
+  return [
+    {
+      key: "agent-skill",
+      name: "skilllib",
+      issues: [issue],
+      uses: 0,
+      cells: [
+        { text: sev.icon, width: 2, color: sev.color },
+        { text: clip("skilllib", nameW), width: nameW },
+        { text: clip("Your agents", 16), width: 16, color: color.muted },
+        { text: " " + issue.short, grow: true, color: sev.color }
+      ],
+      detail: (width) => {
+        const b = builder("skilllib");
+        for (const l of wrap("The skilllib skill lets you ask your agents which skills they can use here, where each comes from, and which of your skills a repo should add.", width - 4, 3)) b.line([l, color.muted]);
+        b.line();
+        b.issues([issue]);
+        return b.d;
+      }
+    }
+  ];
 }
 function addCursor(rows, cursor) {
   const i = Math.min(cursor, rows.length - 1);
   return rows[i] && !rows[i].header ? i : Math.max(0, rows.findIndex((r) => !r.header));
 }
-function said(r) {
-  return typeof r === "string" ? r : r.message;
-}
+var said2 = said;
 function App({ initial, reload, loadUsage: loadUsage2 }) {
   const { exit, suspendTerminal } = useApp();
   const { columns: termCols, rows: termRows } = useWindowSize();
@@ -1068,12 +1325,14 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     notify: setToast,
     openInGlobal,
     edit,
-    copy: (text, what) => setToast(said(world.ops.copy(text, what))),
+    copy: (text, what) => setToast(said2(world.ops.copy(text, what))),
     menu: (title, options) => setModal({ kind: "menu", title, options, cursor: 0 })
   };
   const flagged = [
     ...world.projects.flatMap((p) => projectIssues(world, p.name).map((x) => ({ key: `${p.name}:${x.skill.name}`, issue: x.issue }))),
-    ...world.machine.flatMap((m) => machineIssues(world, m).map((issue) => ({ key: `Global:${m.name}`, issue })))
+    ...world.machine.flatMap((m) => machineIssues(world, m).map((issue) => ({ key: `Global:${m.name}`, issue }))),
+    // The skilllib skill's issue is on its Global row when it has one (see agentSkillItems).
+    ...[agentSkillIssue(world)].flatMap((issue) => issue ? [{ key: "Global:skilllib", issue }] : [])
   ];
   const healthCount = new Set(flagged.map((f) => f.key)).size;
   const healthWorst = worst(flagged.map((f) => f.issue));
@@ -1102,16 +1361,18 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
   if (items[cursor]?.header) cursor = firstSelectable;
   const current = items[cursor];
   const detail = current?.detail?.(columns);
-  function apply(run) {
+  function apply(run, w = world) {
     let result;
     try {
-      result = run(world);
+      result = run(w);
     } catch (e) {
-      result = `Couldn't do it: ${e.message}`;
+      result = failed(`Couldn't do it: ${e.message}`);
     }
     setBase(reload());
-    setToast(`\u2713 ${said(result)}`);
-    if (typeof result !== "string") setModal({ kind: "confirm", fix: result.then });
+    const then = followUp(result);
+    const toast2 = `${isFailure(result) ? "\u2717" : then ? "!" : "\u2713"} ${said2(result)}`;
+    setToast(toast2);
+    if (then) setModal({ kind: "confirm", fix: then, toast: toast2 });
   }
   function choose(o) {
     if (o.action) return o.action();
@@ -1131,6 +1392,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
   function fixSelected() {
     const issue = current && worst(current.issues);
     if (!issue) return setToast("Nothing to fix \xB7 enter shows what you can do");
+    if (!issue.fixes.length) return setToast(`Nothing skilllib can do here: ${issue.short}`);
     if (issue.decision) {
       setFocus("detail");
       setDetailCursor(Math.max(0, detail?.options.findIndex((o) => o.issue === issue) ?? 0));
@@ -1207,7 +1469,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
           preview: `Pick repos. These ${n(mine.length)} go into your library and those repos, and stop loading globally (originals backed up).`,
           run: () => "",
           preticked: usedIn,
-          pickRepos: (w, repos) => (mine.forEach((m) => w.ops.moveGlobal(m, repos, label)), `${n(mine.length)} now load only in ${repos.join(", ")}`)
+          pickRepos: (w, repos) => w.ops.moveGlobal(mine, repos, label)
         }),
         ...mine.some((m) => !m.kept) ? [fixOption({ label: `Keep all ${mine.length} global on purpose`, preview: `skilllib stops warning about these ${n(mine.length)}.`, run: (w) => (mine.forEach((m) => w.ops.keepGlobal(m.name, true)), `${n(mine.length)} marked as global on purpose`) })] : [],
         fixOption({ label: `Delete all ${mine.length}`, preview: `Move these ${n(mine.length)} to Settings \u203A Backups.`, run: (w) => (mine.forEach((m) => w.ops.deleteGlobal(m)), `Deleted ${n(mine.length)} (in Settings \u203A Backups)`) })
@@ -1218,7 +1480,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
           preview: `Install these ${n(libs.length)} into the repos you pick.`,
           run: () => "",
           preticked: () => [],
-          pickRepos: (w, repos) => (repos.forEach((r) => libs.forEach((l) => w.ops.add(r, l.name))), `Added ${n(libs.length)} to ${repos.join(", ")}`)
+          pickRepos: (w, repos) => w.ops.addTo(repos, libs.map((l) => l.name))
         })
       ] : [],
       ...libs.length ? [fixOption(deleteLibraryFix(world, libs.map((l) => l.name)))] : [],
@@ -1258,9 +1520,9 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
           `\u22EF ${repo}\u2026`,
           ["Open its folder, hide it from the list, or copy a review prompt for its skills."],
           () => ui.menu(repo, [
-            { label: "Open its folder", action: () => setToast(said(world.ops.openFolder(project(world, repo).path))) },
+            { label: "Open its folder", action: () => setToast(said2(world.ops.openFolder(project(world, repo).path))) },
             { label: "Hide it from the list", action: () => (apply((w) => w.ops.hide(repo)), setOpen(null), setFocus(sidebar ? "sidebar" : "list")) },
-            ...skills.length ? [{ label: `Review prompt for its ${skills.length} skills`, action: () => ui.copy(reviewPrompt(world, skills, `Review the skills in ${repo}.`), `a review prompt for ${repo}`) }] : []
+            ...skills.length ? [{ label: `Review prompt for its ${skills.length} skills`, action: () => ui.copy(reviewPrompt(world, skills, `Review the skills in ${repo}.`, repo), `a review prompt for ${repo}`) }] : []
           ])
         )
       ];
@@ -1292,19 +1554,21 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     setQuery("");
     setChip("all");
   }
-  function edit(file) {
-    if (!existsSync2(file)) return setToast(`${tildify2(file)} doesn't exist`);
+  function edit(file, then) {
+    if (!existsSync2(file)) return then ? apply(then) : (setBase(reload()), setToast(`${tildify3(file)} doesn't exist`));
     const editor = process.env.VISUAL || process.env.EDITOR || (process.platform === "win32" ? "notepad" : "vi");
     void suspendTerminal(() => {
       if (process.platform === "win32") spawnSync2(`${editor} "${file}"`, { shell: true, stdio: "inherit" });
       else spawnSync2("/bin/sh", ["-c", `${editor} "$1"`, "sh", file], { stdio: "inherit" });
     }).then(() => {
-      setBase(reload());
-      setToast(`Saved ${tildify2(file)}`);
+      const fresh = reload();
+      if (then) return apply(then, fresh);
+      setBase(fresh);
+      setToast(`Saved ${tildify3(file)}`);
     });
   }
   function askForFolder(title) {
-    setModal({ kind: "input", title, value: "~/Projects", submit: (v) => apply((w) => w.ops.addRoot(v)) });
+    setModal({ kind: "input", title, value: "", placeholder: "~/Projects", submit: (v) => apply((w) => w.ops.addRoot(v)) });
   }
   useEffect(() => {
     const folder = () => !initial.roots.length && askForFolder("Where are your projects? skilllib finds the git repos in there");
@@ -1333,20 +1597,27 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
           apply((w) => (w.ops.setAgents(wasOn ? w.agents.filter((a) => a !== h.id) : HARNESSES.map((x) => x.id).filter((id) => id === h.id || w.agents.includes(id))), `${h.name} ${wasOn ? "off" : "on"}`));
         })
       ),
+      // The skill that lets your agents use skilllib: installing adds a global skill, so it asks first.
+      row(
+        "agent-skill",
+        `${world.agentSkill === "installed" ? "[x]" : "[ ]"} \u25C6 skilllib skill`,
+        world.agentSkill === "installed" ? "your agents can use skilllib" : world.agentSkill === "outdated" ? "out of date \xB7 enter updates it" : "lets your agents use skilllib \xB7 enter installs it",
+        () => world.agentSkill === "installed" ? setToast("Installed \xB7 `skilllib agent-skill remove` takes it out") : choose(fixOption(agentSkillFix(world)))
+      ),
       header("#roots", "Project folders"),
       ...world.roots.map(
         (r) => row(
           `root:${r}`,
-          tildify2(r),
+          tildify3(r),
           "scanned for git repos",
-          () => ui.menu(tildify2(r), [
+          () => ui.menu(tildify3(r), [
             { label: "Look for repos again", action: () => apply((w) => w.ops.rescan()) },
-            fixOption({ label: "Stop scanning this folder", preview: `Repos already found in ${tildify2(r)} stay listed until you hide them.`, run: (w) => w.ops.removeRoot(r) })
+            fixOption({ label: "Stop scanning this folder", preview: `Repos already found in ${tildify3(r)} stay listed until you hide them.`, run: (w) => w.ops.removeRoot(r) })
           ])
         )
       ),
       row("root:add", "+ Add a folder\u2026", "", () => askForFolder("Folder that contains your projects")),
-      ...world.hidden.length ? [header("#hidden", "Hidden repos"), ...world.hidden.map((h) => row(`hidden:${h}`, tildify2(h), "enter shows it again", () => apply((w) => w.ops.unhide(h))))] : [],
+      ...world.hidden.length ? [header("#hidden", "Hidden repos"), ...world.hidden.map((h) => row(`hidden:${h}`, tildify3(h), "enter shows it again", () => apply((w) => w.ops.unhide(h))))] : [],
       header("#backups", "Backups"),
       ...world.backups.length ? world.backups.map(
         (b, i) => row(`backup:${i}`, `\u21BA ${b.name}`, `${b.from} \xB7 ${b.at}`, () => apply((w) => w.ops.restoreBackup(i)))
@@ -1450,7 +1721,11 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     }
     if (m.kind === "input") {
       if (key.escape) return setModal(null);
-      if (key.return) return setModal(null), m.submit(m.value.trim());
+      if (key.return) {
+        const value = m.value.trim() || m.placeholder;
+        setModal(null);
+        return value ? m.submit(value) : void 0;
+      }
       if (key.backspace || key.delete) return setModal({ ...m, value: m.value.slice(0, -1) });
       if (key.ctrl && input === "u") return setModal({ ...m, value: "" });
       if (input && !key.ctrl && !key.meta) return setModal({ ...m, value: m.value + input });
@@ -1463,7 +1738,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       if (key.return && m.options[m.cursor]) return setModal(null), choose(m.options[m.cursor]);
       return;
     }
-    if (key.escape) return setModal(null);
+    if (key.escape) return setModal(null), m.kind === "confirm" && m.toast && setToast(m.toast);
     if (m.kind === "confirm") {
       if (key.return || input === "y") {
         setModal(null);
@@ -1500,17 +1775,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       if (key.return) {
         setModal(null);
         const chosen = m.items.filter((it) => it.on);
-        apply((w) => {
-          let ok = 0;
-          for (const it of chosen) {
-            try {
-              it.fix.run(w);
-              ok++;
-            } catch {
-            }
-          }
-          return `Applied ${ok} fix${ok === 1 ? "" : "es"} (anything removed is in Settings \u203A Backups)`;
-        });
+        apply((w) => runAll(w, chosen.map((it) => it.fix)));
       }
       return;
     }
@@ -1533,9 +1798,9 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
         const row = rows[cursor2];
         if (row.create && !/^[a-z0-9]/.test(m.query)) return setToast("Type the new skill's name first");
         setModal(null);
-        apply(row.run);
-        if (row.create) edit(world.ops.libraryFile(m.query));
-        return;
+        if (!row.create) return apply(row.run);
+        row.run(world);
+        return edit(world.ops.libraryFile(m.query), row.afterEdit);
       }
       if (isNameChar(input, key)) return setModal({ ...m, query: m.query + input.toLowerCase(), cursor: 0 });
     }
@@ -1648,8 +1913,11 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     );
   else if (modal?.kind === "input")
     body = /* @__PURE__ */ jsxs2(Panel, { title: modal.title, focused: true, width: columns, height: 5, children: [
-      /* @__PURE__ */ jsx2(Text2, { color: color.text, children: modal.value + "\u258F" }),
-      /* @__PURE__ */ jsx2(Text2, { color: color.faint, children: "enter to confirm \xB7 ctrl+u clears \xB7 esc cancels" })
+      modal.value || !modal.placeholder ? /* @__PURE__ */ jsx2(Text2, { color: color.text, children: modal.value + "\u258F" }) : /* @__PURE__ */ jsxs2(Text2, { children: [
+        "\u258F",
+        /* @__PURE__ */ jsx2(Text2, { color: color.faint, children: modal.placeholder })
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { color: color.faint, children: modal.value || !modal.placeholder ? "enter to confirm \xB7 ctrl+u clears \xB7 esc cancels" : `type a path, or enter for ${modal.placeholder} \xB7 esc cancels` })
     ] });
   else if (modal?.kind === "agents")
     body = /* @__PURE__ */ jsx2(
@@ -1776,7 +2044,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       ] })
     ] }),
     /* @__PURE__ */ jsxs2(Box2, { height: 1, width: termCols, justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsx2(Text2, { color: toast.startsWith("\u2713") || toast.startsWith("\u21BA") ? color.green : color.muted, wrap: "truncate-end", children: " " + toast }),
+      /* @__PURE__ */ jsx2(Text2, { color: toast.startsWith("\u2713") || toast.startsWith("\u21BA") ? color.green : toast.startsWith("\u2717") ? color.red : toast.startsWith("!") ? color.yellow : color.muted, wrap: "truncate-end", children: " " + toast }),
       toast ? null : /* @__PURE__ */ jsx2(Text2, { color: color.faint, children: hints + " " })
     ] })
   ] });
@@ -1835,9 +2103,8 @@ function Help({ width, height }) {
 import { execFileSync, spawn, spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync3, lstatSync, realpathSync } from "fs";
 import { basename, dirname, join as join2 } from "path";
-function tildify3(p) {
-  const home = userHome();
-  return (p.startsWith(home) ? "~" + p.slice(home.length) : p).replace(/\\/g, "/");
+function tildify4(p) {
+  return tildify(p).replace(/\\/g, "/");
 }
 function uniqueNames(roots) {
   const tail = (r, n) => r.split(/[\\/]/).filter(Boolean).slice(-n).join("/");
@@ -1855,25 +2122,37 @@ function localSkill(root, s, git2) {
     "update available": {},
     "edited locally": { edited: true },
     "edited locally, update available": { edited: true },
-    "folder missing": { missing: true },
+    // sync restores it from your library, unless the library doesn't have it (a teammate's skill, another library).
+    "folder missing": { missing: true, ...s.latest === null && { library: "missing" } },
     "not in library": { library: "missing" }
   };
   const other = {
     "untracked copy of library skill": { source: "untracked", library: "same" },
     "untracked, differs from library": { source: "untracked", library: "differs" },
     "local only": { source: "untracked" },
+    // Installed with `npx skills add` (the repo's skills-lock.json): not skilllib's, so not a library skill.
+    "from npx skills": { source: "untracked" },
     "repo skill": { source: "repo" },
     "repo skill, in library": { source: "repo", library: "same" },
     "repo skill, differs from library": { source: "repo", library: "differs" }
   };
+  const state = git2 ? git2.of(relativeTo(root, s.path)) : null;
+  const own = other[s.state]?.source === "untracked" && (state === "committed" || state === "changed") ? { source: "repo" } : {};
+  const blind = s.state === "folder missing" ? [] : s.visibility.filter((v) => v.paths === 0).map((v) => v.id);
+  const uncommitted = blind.length ? linkEverywhere(root, s.name, s.location, { dryRun: true }).uncommitted : [];
+  const unshared = blind.filter((id) => uncommitted.includes(harness(id).projectDirs[0]));
   return {
     name: s.name,
     source: "lib",
     dir: s.location,
     path: s.path,
-    agents: s.visibility.map((v) => v.id),
-    ...s.managed ? { library: "same", version: s.version ?? void 0, ...managed[s.state] } : other[s.state],
-    git: git2 ? git2.of(relativeTo(root, s.path)) : null
+    // Agents that actually load it here: visibility lists every agent you use, with `paths: 0` for the blind ones.
+    agents: s.visibility.filter((v) => v.paths > 0).map((v) => v.id),
+    ...s.managed ? { library: "same", version: s.version ?? void 0, ...managed[s.state] } : { ...other[s.state], ...own },
+    ...unshared.length && { unshared },
+    ...s.source ? { origin: `npx skills: ${s.source}` } : {},
+    added: addedAt(s.path),
+    git: state
   };
 }
 var partsOf = /* @__PURE__ */ new Map();
@@ -1903,8 +2182,8 @@ function machineSkill(s, kept) {
   const global = s.kind === "global" || s.kind === "skills.sh";
   return {
     name: s.name,
-    source: global ? "global" : s.kind === "plugin" ? "plugin" : s.kind === "claude.ai" ? "claude.ai" : "cursor",
-    where: global ? tildify3(dirname(s.path)) : s.kind === "claude.ai" ? "claude.ai account" : s.kind === "built-in" ? `${s.origin} built-in` : s.origin,
+    source: global ? "global" : s.kind === "plugin" ? "plugin" : s.kind === "claude.ai" ? "claude.ai" : s.kind === "system" ? "system" : s.kind === "skilllib" ? "skilllib" : "cursor",
+    where: global || s.kind === "skilllib" ? tildify4(dirname(s.path)) : s.kind === "claude.ai" ? "claude.ai account" : s.kind === "built-in" ? `${s.origin} built-in` : s.origin,
     ...s.kind === "skills.sh" ? { origin: `npx skills: ${s.origin}` } : {},
     path: s.path,
     links: s.links,
@@ -1915,11 +2194,17 @@ function machineSkill(s, kept) {
     ...s.kind === "plugin" ? { pluginParts: pluginParts(dirname(dirname(s.path))) } : {}
   };
 }
+function dupesOf(r, root, git2 = null) {
+  const out = /* @__PURE__ */ new Map();
+  for (const p of r.plans) out.set(p.name, { steps: p.steps.map((s) => describeStep(s, root)), git: gitVisibleSteps(p, git2).map((s) => describeStep(s, root)) });
+  for (const c of r.conflicts)
+    out.set(c.name, { steps: [], git: [], differ: c.copies.map((x) => ({ dir: x.dir, label: root ? copyLabel(c, x.dir) : tildify4(x.dir), runs: x.runs, canWin: !c.managed || x.dir === c.managed })) });
+  return out;
+}
 function loadWorld() {
   forgetLatest();
   const agents = enabledHarnesses();
-  const cwdRoot = findProjectRoot();
-  const here = isProjectCandidate(cwdRoot) && (existsSync3(join2(cwdRoot, ".git")) || existsSync3(join2(cwdRoot, "skilllib.json"))) ? cwdRoot : null;
+  const here = projectHere();
   const real = (p) => {
     try {
       return realpathSync(p);
@@ -1938,20 +2223,39 @@ function loadWorld() {
     return { name: s.name, latest: latestVersion(s.name)?.version ?? 1, origin: origins[s.name] };
   });
   const kept = keptGlobal();
-  const machine = machineSkills(agents).map((s) => {
+  const cursorPlugin = new Map(agents.includes("cursor") ? cursorPluginSkills().map((s) => [s.name, s.plugin]) : []);
+  const globalDupes = dupesOf(planGlobalTidy({ enabled: agents }), null);
+  const sourced = machineSkills(agents);
+  const machine = sourced.map((s) => {
     descriptions[s.name] ??= s.description;
-    return machineSkill(s, kept);
+    const m = machineSkill(s, kept);
+    if (m.source !== "global" || m.broken) return m;
+    const dupes = globalDupes.get(m.name);
+    const plugin = cursorPlugin.get(m.name);
+    return { ...m, ...dupes ? { dupes } : {}, ...plugin ? { cursorPlugin: plugin } : {} };
   });
+  const plugins = (root) => {
+    const loaded = skillsLoadedIn(root, sourced, agents);
+    if (loaded === sourced) return {};
+    for (const s of loaded) descriptions[s.name] ??= s.description;
+    return { machine: loaded.map((s) => machine[sourced.indexOf(s)] ?? machineSkill(s, kept)) };
+  };
   const projects = roots.map((root) => {
     const status = projectStatus(root);
     const hasManifest = existsSync3(join2(root, "skilllib.json"));
     const git2 = status.length || hasManifest ? gitInfo(root) : null;
     for (const s of status) if (!descriptions[s.name] && !s.state.includes("missing")) descriptions[s.name] = readSkillInfo(s.path).description;
+    const dupes = status.length ? dupesOf(planProjectTidy(root, { enabled: agents }), root, git2) : /* @__PURE__ */ new Map();
     return {
       name: names.get(root),
       path: root,
       manifest: hasManifest ? git2 ? git2.of("skilllib.json") : "no git" : "none",
-      skills: status.map((s) => localSkill(root, s, git2))
+      skills: status.map((s) => {
+        const d = dupes.get(s.name);
+        const plugin = cursorPlugin.get(s.name);
+        return { ...localSkill(root, s, git2), ...d ? { dupes: d } : {}, ...plugin ? { cursorPlugin: plugin } : {} };
+      }),
+      ...plugins(root)
     };
   });
   const backups = [...listBackups(), ...pluginBackups()].sort((a, b) => b.movedAt.localeCompare(a.movedAt));
@@ -1963,10 +2267,11 @@ function loadWorld() {
     library,
     usage: {},
     descriptions,
-    backups: backups.map((b) => ({ name: b.name, from: tildify3(b.from), at: b.movedAt })),
+    backups: backups.map((b) => ({ name: b.name, from: tildify4(b.from), at: b.movedAt })),
     roots: readConfig().roots,
     hidden: readConfig().hidden,
     agentsChosen: harnessesChosen(),
+    agentSkill: agentSkillState(agents),
     ops: realOps(new Map(projects.map((p) => [p.name, p.path])), backups)
   };
 }
@@ -1998,44 +2303,99 @@ function remoteLabel(url) {
   if (!url) return void 0;
   return url.replace(/^[a-z+]+:\/\//, "").replace(/^[^@/]+@/, "").replace(/:(?!\d)/, "/").replace(/\.git$/, "");
 }
-function said2(c, repo) {
+function said3(c, repo) {
   if (c.action === "skipped") return `${c.name}: ${c.reason ?? "skipped"}`;
   if (c.action === "removed") return `Removed ${c.name} from ${repo}`;
-  return `${c.action === "installed" ? "Added" : "Updated"} ${c.name}${c.to ? ` v${c.to}` : ""} in ${repo}`;
+  const back = c.action === "updated" && c.from !== void 0 && c.to !== void 0 && c.to < c.from;
+  const done = back ? `Pinned ${c.name} to v${c.to} in ${repo} (was v${c.from})` : `${c.action === "installed" ? "Added" : c.action === "reset" ? "Reset" : "Updated"} ${c.name}${c.to ? ` v${c.to}` : ""} in ${repo}`;
+  return c.backedUp ? `${done} (your edits are in Settings \u203A Backups)` : done;
 }
 function realOps(roots, backups) {
   const rootOf = (repo) => roots.get(repo);
   const find = (repo, name) => projectStatus(rootOf(repo)).find((s) => s.name === name);
   const info = /* @__PURE__ */ new Map();
+  const result = (c, repo) => c.action === "skipped" ? failed(said3(c, repo)) : said3(c, repo);
+  const copyDir = (repo, name) => readManifest(rootOf(repo)).skills[name]?.dir ?? PROJECT_SKILLS_DIR;
   const withLinks = (c, repo, name) => {
-    if (!c.blocked?.length) return said2(c, repo);
-    return { message: said2(c, repo), then: allowTracked(repo, name, c.blocked) };
+    const it = (dirs) => dirs.length === 1 ? "it" : "them";
+    if (c.uncommitted?.length)
+      return `${said3(c, repo)}; not linked in ${c.uncommitted.join(", ")}: git tracks ${it(c.uncommitted)} and ${copyDir(repo, name)}/${name} isn't committed, so teammates would get broken links`;
+    if (!c.blocked?.length) return result(c, repo);
+    return { message: `${said3(c, repo)}; not linked in ${c.blocked.join(", ")}: git tracks ${it(c.blocked)}`, then: allowTracked([{ repo, name, blocked: c.blocked }]) };
   };
-  const allowTracked = (repo, name, blocked) => ({
-    label: `Also link it in ${blocked.join(", ")}`,
-    preview: `${blocked.join(", ")} is committed in ${repo}: the links will show in git status. skilllib remembers this for ${repo}.`,
-    run: (w) => {
-      allowTrackedLinks(rootOf(repo));
-      return w.ops.link(repo, name, true);
-    }
-  });
-  const orForce = (c, repo, label, force) => c.action === "skipped" && c.reason?.includes("edits") ? { message: said2(c, repo), then: { label, preview: `Your edits to ${c.name} in ${repo} are lost.`, run: () => said2(force(), repo) } } : said2(c, repo);
+  const addTo = (repos, names) => {
+    if (repos.length === 1 && names.length === 1) return withLinks(addSkill(rootOf(repos[0]), names[0]), repos[0], names[0]);
+    const changes = repos.flatMap((repo) => names.map((name) => ({ repo, name, c: addSkill(rootOf(repo), name) })));
+    const done = changes.filter((x) => x.c.action !== "skipped");
+    const added = [...new Set(done.map((x) => x.name))];
+    const summary = done.length ? `Added ${added.length === 1 ? `${added[0]} v${done[0].c.to}` : `${added.length} skills`} to ${[...new Set(done.map((x) => x.repo))].join(", ")}` : "";
+    const notes = [];
+    for (const repo of repos)
+      for (const kind of ["blocked", "uncommitted"]) {
+        const here = done.filter((x) => x.repo === repo && x.c[kind]?.length);
+        if (!here.length) continue;
+        const dirs = [...new Set(here.flatMap((x) => x.c[kind]))];
+        const who = here.length === names.length ? "" : `${here.map((x) => x.name).join(", ")}: `;
+        const copies = [...new Set(here.map((x) => copyDir(repo, x.name)))];
+        const why = kind === "blocked" ? `git tracks ${dirs.length === 1 ? "it" : "them"}` : `${copies.join(", ")} ${copies.length === 1 ? "isn't" : "aren't"} committed, so a link would break for teammates`;
+        notes.push(`${who}not linked in ${dirs.join(", ")} in ${repo}: ${why}`);
+      }
+    const skipped = changes.filter((x) => x.c.action === "skipped").map((x) => `${x.name} not added to ${x.repo}: ${x.c.reason}`);
+    const text = [summary, ...notes, ...skipped].filter(Boolean).join("; ");
+    const held = done.flatMap((x) => x.c.blocked?.length ? [{ repo: x.repo, name: x.name, blocked: x.c.blocked }] : []);
+    if (!done.length) return failed(text);
+    if (held.length) return { message: text, then: allowTracked(held) };
+    return skipped.length ? failed(text) : text;
+  };
+  const allowTracked = (held) => {
+    const repos = [...new Set(held.map((h) => h.repo))];
+    const dirs = [...new Set(held.flatMap((h) => h.blocked))];
+    return {
+      label: `Also link ${new Set(held.map((h) => h.name)).size === 1 ? "it" : "them"} in ${dirs.join(", ")}`,
+      preview: `${dirs.join(", ")} ${dirs.length === 1 ? "is" : "are"} committed in ${repos.join(", ")}: the links will show in git status. skilllib remembers this for ${repos.join(", ")}.`,
+      run: (w) => {
+        for (const repo of repos) allowTrackedLinks(rootOf(repo));
+        if (held.length === 1) return w.ops.link(held[0].repo, held[0].name, true);
+        const results = held.map((h) => ({ ...h, r: linkIn(h.repo, h.name, true) }));
+        const linked = results.filter((x) => x.r.created.length);
+        const names = [...new Set(linked.map((x) => x.name))];
+        const summary = linked.length ? `Linked ${names.length === 1 ? names[0] : `${names.length} skills`} in ${[...new Set(linked.flatMap((x) => x.r.created))].join(", ")} in ${[...new Set(linked.map((x) => x.repo))].join(", ")}` : "";
+        const others = results.filter((x) => !x.r.created.length || x.r.uncommitted.length).map((x) => `${x.repo}: ${linkSaid(x.name, x.r)}`);
+        return [summary, ...others].join("; ");
+      }
+    };
+  };
+  const linkIn = (repo, name, allow) => {
+    const s = find(repo, name);
+    return s.managed ? relinkDependency(rootOf(repo), name, { allowTracked: allow }) : linkEverywhere(rootOf(repo), name, s.location, { allowTracked: allow });
+  };
+  const linkSaid = (name, r) => {
+    const linked = r.created.length ? `linked in ${r.created.join(", ")}` : "";
+    const notLinked = r.uncommitted.length ? `not linked in ${r.uncommitted.join(", ")}: git tracks ${r.uncommitted.length === 1 ? "it" : "them"} and ${name} isn't committed, so teammates would get broken links` : "";
+    return `${name}: ${[linked, notLinked].filter(Boolean).join("; ") || "nothing to link"}`;
+  };
+  const orForce = (c, repo, label, force) => c.action === "skipped" && c.reason?.includes("edits") ? {
+    message: `${c.name} in ${repo} has local edits`,
+    then: { label, preview: `Your edits to ${c.name} in ${repo} go to Settings \u203A Backups.`, run: () => result(force(), repo) }
+  } : result(c, repo);
   const toLibrary = (path) => {
     const r = importSkill(path, { force: true });
     return r.status === "unchanged" ? `${r.name} is already the same in your library` : `${r.name} v${latestVersion(r.name)?.version} is in your library`;
   };
   return {
-    add: (repo, name) => withLinks(addSkill(rootOf(repo), name), repo, name),
+    add: (repo, name) => addTo([repo], [name]),
+    addTo,
     remove: (repo, name) => {
       const s = find(repo, name);
-      if (!s) return `${name} isn't in ${repo}`;
-      if (s.state.startsWith("repo skill")) return `${name} is the repo's own (committed by your team): skilllib doesn't delete it`;
+      if (!s) return failed(`${name} isn't in ${repo}`);
+      const committed = !s.managed && ["committed", "changed"].includes(gitInfo(rootOf(repo))?.of(relativeTo(rootOf(repo), s.path)) ?? "");
+      if (s.state.startsWith("repo skill") || committed) return failed(`${name} is the repo's own (committed by your team): skilllib doesn't delete it`);
       if (!s.managed) return removeUntracked(rootOf(repo), name, s.path), `Removed ${name} from ${repo} (in Settings \u203A Backups)`;
       return orForce(removeSkill(rootOf(repo), name), repo, "Remove it anyway", () => removeSkill(rootOf(repo), name, { force: true }));
     },
     restore: (repo, name) => {
       const c = syncProject(rootOf(repo)).find((x) => x.name === name);
-      return c ? said2(c, repo) : `${name} is already in place`;
+      return c ? result(c, repo) : `${name} is already in place`;
     },
     update: (repo, name) => {
       const c = updateProject(rootOf(repo), [name])[0];
@@ -2053,10 +2413,10 @@ function realOps(roots, backups) {
       return withLinks(addSkill(rootOf(repo), name, s.managed && s.version ? { version: s.version } : {}), repo, name);
     },
     link: (repo, name, allow = false) => {
-      const s = find(repo, name);
-      const r = s.managed ? relinkDependency(rootOf(repo), name, { allowTracked: allow }) : linkEverywhere(rootOf(repo), name, s.location, { allowTracked: allow });
-      const message = r.created.length ? `${name}: linked in ${r.created.join(", ")}` : `${name}: nothing to link`;
-      return r.blocked.length && !allow ? { message, then: allowTracked(repo, name, r.blocked) } : message;
+      const r = linkIn(repo, name, allow);
+      const message = linkSaid(name, r);
+      if (!r.blocked.length || allow) return r.created.length ? message : failed(message);
+      return { message: `${message}; not linked in ${r.blocked.join(", ")}: git tracks ${r.blocked.length === 1 ? "it" : "them"}`, then: allowTracked([{ repo, name, blocked: r.blocked }]) };
     },
     track: (repo, name) => withLinks(addSkill(rootOf(repo), name), repo, name),
     importLocal: (repo, name) => {
@@ -2065,41 +2425,109 @@ function realOps(roots, backups) {
       return withLinks(addSkill(rootOf(repo), name), repo, name);
     },
     copyToLibrary: (repo, name) => toLibrary(find(repo, name).path),
+    tidy: (repo, name, { keep, allowGit = false } = {}) => {
+      const root = repo === null ? null : rootOf(repo);
+      const opts = keep ? { keep: { [name]: keep } } : {};
+      const plan = (root ? planProjectTidy(root, opts) : planGlobalTidy(opts)).plans.find((p) => p.name === name);
+      if (!plan) return `${name}: nothing to tidy`;
+      const r = applyTidy(plan, { git: allowGit ? "go" : "keep" });
+      const steps = (list) => list.map((s) => describeStep(s, root)).join(", ");
+      if (!r.held.length) return r.applied.length ? `${name}: ${steps(r.applied)}` : `${name}: nothing changed`;
+      return {
+        message: `${name}: ${r.applied.length ? `${steps(r.applied)}; ` : ""}held back ${steps(r.held)}, because git tracks it`,
+        then: {
+          label: "Also change what git tracks",
+          preview: `${steps(r.held)}: these changes will show in git status in ${repo}. Replaced copies go to Settings \u203A Backups.`,
+          run: (w) => w.ops.tidy(repo, name, { keep, allowGit: true })
+        }
+      };
+    },
     unloadGlobal: (m) => {
       if (!m.broken && !latestVersion(m.name)) importSkill(m.path);
       const r = unloadGlobal(m.path, m.links);
-      return r.ok ? `${m.name} no longer loads globally (in Settings \u203A Backups)` : `${m.name}: ${r.reason}`;
+      return r.ok ? `${m.name} no longer loads globally (in Settings \u203A Backups)` : failed(`${m.name}: ${r.reason}`);
     },
     deleteGlobal: (m) => {
       const r = deleteGlobal(m.path, m.links);
-      return r.ok ? m.broken ? `Removed the broken link ${m.name}` : `Deleted ${m.name} (in Settings \u203A Backups)` : `${m.name}: ${r.reason}`;
+      return r.ok ? m.broken ? `Removed the broken link ${m.name}` : `Deleted ${m.name} (in Settings \u203A Backups)` : failed(`${m.name}: ${r.reason}`);
     },
     keepGlobal: (name, keep) => (setKeepGlobal([name], keep), keep ? `${name} marked as global on purpose` : `${name} is no longer marked as global on purpose`),
-    moveGlobal: (m, repos, group) => {
-      if (importSkill(m.path).status === "exists") return `${m.name}: your library has a different ${m.name}; nothing moved (update your library from this copy first)`;
-      if (group) recordOrigin(m.name, `group: ${group}`);
-      const results = repos.map((r2) => [r2, addSkill(rootOf(r2), m.name)]);
-      const skipped = results.filter(([, c]) => c.action === "skipped");
-      if (skipped.length)
-        return `${m.name}: not added to ${skipped.map(([r2, c]) => `${r2} (${c.reason})`).join(", ")}, so it still loads globally`;
-      const blocked = results.filter(([, c]) => c.blocked?.length).map(([r2]) => r2);
-      const r = unloadGlobal(m.path, m.links);
-      if (!r.ok) return `${m.name}: ${r.reason}`;
-      return `${m.name} now loads only in ${repos.join(", ")}${blocked.length ? ` (some agents can't see it in ${blocked.join(", ")}: git tracks the folder)` : ""}`;
+    linkGlobal: (m, agents) => {
+      const r = linkGlobal(m.path, agents);
+      const linked = r.linked.map(tildify4).join(", ");
+      const skipped = r.skipped.length ? `; ${r.skipped.map(tildify4).join(", ")} already holds a different skill` : "";
+      const message = `${m.name}: ${linked ? `linked ${linked}` : "nothing linked"}${skipped}`;
+      return !linked && skipped ? failed(message) : message;
+    },
+    moveGlobal: (skills, repos, group) => {
+      const moved = [];
+      const notes = [];
+      const held = [];
+      for (const m of skills) {
+        if (importSkill(m.path).status === "exists") {
+          notes.push(`${m.name}: your library has a different ${m.name}; nothing moved (update your library from this copy first)`);
+          continue;
+        }
+        if (group) recordOrigin(m.name, `group: ${group}`);
+        const results = repos.map((r2) => [r2, addSkill(rootOf(r2), m.name)]);
+        const skipped = results.filter(([, c]) => c.action === "skipped");
+        if (skipped.length) {
+          notes.push(`${m.name}: not added to ${skipped.map(([r2, c]) => `${r2} (${c.reason})`).join(", ")}, so it still loads globally`);
+          continue;
+        }
+        const r = unloadGlobal(m.path, m.links);
+        if (!r.ok) {
+          notes.push(`${m.name}: ${r.reason}`);
+          continue;
+        }
+        moved.push(m.name);
+        for (const [repo, c] of results) {
+          const blind = visibilityOf(rootOf(repo), m.name).flatMap((v) => v.paths === 0 ? [v.id] : []);
+          const blocked = [...c.blocked ?? [], ...c.uncommitted ?? []];
+          if (!blocked.length || !blind.length) continue;
+          held.push({ repo, name: m.name, blocked, blind, copy: copyDir(repo, m.name), shared: !c.uncommitted?.length });
+        }
+      }
+      const gaps = /* @__PURE__ */ new Map();
+      for (const repo of new Set(held.map((h) => h.repo)))
+        for (const shared of [true, false]) {
+          const here = held.filter((h) => h.repo === repo && h.shared === shared);
+          if (!here.length) continue;
+          const agents = [...new Set(here.flatMap((h) => h.blind))].map((id) => harness(id).name).join(", ");
+          const what = skills.length === 1 ? "it" : here.length === moved.length ? "them" : here.map((h) => h.name).join(", ");
+          const dirs = [...new Set(here.flatMap((h) => h.blocked))].join(", ");
+          const why = shared ? `git tracks ${dirs}` : `${[...new Set(here.map((h) => h.copy))].join(", ")} isn't committed, so a link in ${dirs} would break for teammates`;
+          const key = `${agents}|${what}|${why}`;
+          if (!gaps.has(key)) gaps.set(key, { who: `${agents} can't see ${what}`, why, repos: [] });
+          gaps.get(key).repos.push(repo);
+        }
+      const blindNotes = [...gaps.values()].map((g) => `${g.who} in ${g.repos.join(", ")}: ${g.why}`);
+      const summary = moved.length ? `${moved.length === 1 ? moved[0] : `${moved.length} skills`} now load${moved.length === 1 ? "s" : ""} only in ${repos.join(", ")}` : "";
+      const text = [summary, ...blindNotes, ...notes].filter(Boolean).join("; ") || "Nothing moved";
+      const askable = held.filter((h) => h.shared);
+      if (!moved.length && notes.length) return failed(text);
+      return askable.length ? { message: text, then: allowTracked(askable) } : text;
     },
     createSkill: (name) => {
       const r = createSkill(name, "");
-      return r.ok ? `Created ${name} in your library: edit its SKILL.md from Your skills` : `${name}: ${r.reason}`;
+      return r.ok ? `Created ${name} in your library: edit its SKILL.md from Your skills` : failed(`${name}: ${r.reason}`);
+    },
+    pluginOffHere: (repo, id) => {
+      const root = rootOf(repo);
+      const plugin = claudePlugins(skillsLoadedIn(root, machineSkills()), root).find((p) => p.id === id);
+      if (!plugin) return failed(`${id} isn't on in ${repo}`);
+      const r = turnOffIn(plugin, root);
+      return r.ok ? r.message : failed(r.message);
     },
     replacePlugin: (id, repos) => {
       const skills = machineSkills().filter((s) => s.kind === "plugin" && s.origin === id && !s.broken);
       const clashes = skills.filter((s) => importSkill(s.path).status === "exists").map((s) => s.name);
-      if (clashes.length) return `${id} kept: your library has different ${clashes.join(", ")}; update or delete ${clashes.length === 1 ? "it" : "them"} first`;
+      if (clashes.length) return failed(`${id} kept: your library has different ${clashes.join(", ")}; update or delete ${clashes.length === 1 ? "it" : "them"} first`);
       const skipped = repos.flatMap((r) => skills.flatMap((s) => {
         const c = addSkill(rootOf(r), s.name);
         return c.action === "skipped" ? [`${s.name} in ${r} (${c.reason})`] : [];
       }));
-      if (skipped.length) return `${id} kept: not added ${skipped.join(", ")}`;
+      if (skipped.length) return failed(`${id} kept: not added ${skipped.join(", ")}`);
       const copied = `${skills.length} skill${skills.length === 1 ? " from " + id + " is" : "s from " + id + " are"} in your library${repos.length ? ` and in ${repos.join(", ")}` : ""}`;
       const bin = claudeBinary();
       const claude = (...args) => spawnSync3(bin, ["plugin", ...args], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 2e4 });
@@ -2115,7 +2543,7 @@ function realOps(roots, backups) {
       try {
         setPluginEnabled(id, false);
       } catch (e) {
-        return `${copied}; couldn't turn ${id} off (${why}; ${e.message}): turn it off with /plugin`;
+        return failed(`${copied}; couldn't turn ${id} off (${why}; ${e.message}): turn it off with /plugin`);
       }
       return `${copied}; turned ${id} off in ~/.claude/settings.json (${why})${synced ? "" : `: finish with /plugin uninstall ${id}`}`;
     },
@@ -2128,13 +2556,13 @@ function realOps(roots, backups) {
         from.push([...roots].find(([, r2]) => r2 === root)?.[0] ?? basename(root));
       }
       const r = deleteLibrarySkill(name);
-      if (!r.ok) return `${name}: ${r.reason}`;
+      if (!r.ok) return failed(`${name}: ${r.reason}`);
       return `Deleted ${name} from your library${from.length ? ` and from ${from.join(", ")}` : ""} (in Settings \u203A Backups)`;
     },
     restoreBackup: (i) => {
       const b = backups[i];
       const r = b.kind === "plugin" ? restorePlugin(b) : restoreBackup(b);
-      return r.ok ? `Restored ${b.name} to ${tildify3(r.to)}` : `${b.name}: ${r.reason}`;
+      return r.ok ? `Restored ${b.name} to ${tildify4(r.to)}` : failed(`${b.name}: ${r.reason}`);
     },
     setAgents: (ids) => (setHarnesses(ids), "Saved your agents"),
     installVersion: (repo, name, version) => withLinks(addSkill(rootOf(repo), name, { version, force: true }), repo, name),
@@ -2143,20 +2571,28 @@ function realOps(roots, backups) {
     addRoot: (path) => {
       const root = addRoot(path);
       discoverProjects();
-      return `Scanning ${tildify3(root)} for repos`;
+      return `Scanning ${tildify4(root)} for repos`;
     },
-    removeRoot: (path) => (removeRoot(path), `Stopped scanning ${tildify3(path)}; repos already found stay until you hide them`),
+    removeRoot: (path) => (removeRoot(path), `Stopped scanning ${tildify4(path)}; repos already found stay until you hide them`),
     rescan: () => (discoverProjects(), "Looked for repos in your project folders again"),
     hide: (repo) => (setHidden(rootOf(repo), true), `Hid ${repo}: Settings \u203A Hidden repos brings it back`),
-    unhide: (path) => (setHidden(path, false), `${tildify3(path)} is back in the list`),
+    unhide: (path) => (setHidden(path, false), `${tildify4(path)} is back in the list`),
     openFolder: (path) => {
       const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
       spawn(cmd, [path], { detached: true, stdio: "ignore" }).unref();
-      return `Opened ${tildify3(path)}`;
+      return `Opened ${tildify4(path)}`;
     },
     copy: (text, what) => {
       const r = copyText(text);
-      return r.copied ? `Copied ${what}: paste it into Claude Code, Cursor or Codex` : `Couldn't reach the clipboard; ${what} is in ${tildify3(r.savedTo)}`;
+      return r.copied ? `Copied ${what}: paste it into Claude Code, Cursor or Codex` : `Couldn't reach the clipboard; ${what} is in ${tildify4(r.savedTo)}`;
+    },
+    installAgentSkill: () => {
+      const r = installAgentSkill();
+      return r.ok ? `Your agents can now use skilllib (${r.dirs.map(tildify4).join(", ")})` : failed(`skilllib skill: ${r.reason}`);
+    },
+    removeAgentSkill: () => {
+      const removed = removeAgentSkill();
+      return removed.length ? `Removed the skilllib skill (${removed.map(tildify4).join(", ")})` : failed("The skilllib skill isn't installed");
     },
     repoInfo: (repo) => {
       if (!info.has(repo)) {