skilllib 1.10.0 → 1.11.1

package/README.md

@@ -2,7 +2,7 @@
 
 # ◆ skilllib
 
-**Manage your agent skills like dependencies.**<br>
+**Manage your agent skills like dependencies, or let your agents do it.**<br>
 One library for all your skills. Each repo gets only the ones it needs,<br>
 and every agent you use can see them.
 
@@ -12,9 +12,11 @@ and every agent you use can see them.
 ![agents](https://img.shields.io/badge/works%20with-Claude%20Code%20%C2%B7%20Cursor%20%C2%B7%20Codex%20%C2%B7%20Zed%20%C2%B7%20Grok-c792ea)
 
 ```bash
-npx skilllib
+npm install -g skilllib && skilllib agent-skill install
 ```
 
+Then ask your agent: *"Which skills can you use here, and which of my global skills should only load in this repo?"*
+
 <img src="docs/design/repo.svg" alt="skilllib: Places on the left, a repo's skills with their issues and uses, and the selected skill's fixes and actions below" width="100%">
 
 </div>
@@ -43,18 +45,18 @@ Most agents can't turn off a global skill for just one repo. Claude Code can, bu
 
 ## How skilllib fixes it
 
+- **🤖 Your agents run it.** One small skill teaches Claude Code, Cursor, Codex, Zed and Grok to use the skilllib CLI. Ask them what's loaded here, what to add, what's out of date, or to move a global skill into the repos that use it. Every command has `--json` output shaped for agents, and they ask before changing anything.
 - **📚 Your skills: one versioned library.** Every skill has a single master copy in `~/.skilllib/library`, and each change becomes a new version.
 - **📦 Per-repo installs, pinned like dependencies.** Each repo lists its skills and versions in `skilllib.json`. `sync` reproduces them exactly, and `update` moves to the newest.
 - **🤝 One copy, every agent.** skilllib puts one real copy in the repo and links it into whichever folders your other agents read.
-- **🧹 Health: one list of what to fix.** Global skills you haven't decided about, skills loaded twice, duplicate copies, updates, broken links, each with its fix. For a global skill: move it to the repos that need it, keep it global, or delete it. Usage numbers and descriptions help you decide.
+- **🧹 Health: one list of what to fix.** Global skills you haven't decided about, skills loaded twice, duplicate copies, updates, broken links, each with its fix. For a global skill: move it to the repos that need it, keep it global, or delete it. Usage numbers and descriptions help you, or your agent, decide.
 - **✓ Global on purpose.** Some skills belong everywhere. Mark them once and skilllib stops warning about them.
 - **🔎 See everything in a repo:**
   - where each skill comes from (the repo, your library, global, a plugin, claude.ai…)
   - which agents load it
   - whether it's committed to git or gitignored
   - how often it was used
-- **💬 Talk to your agents about your skills.** Ask Claude Code, Cursor, Codex or Grok "which skills can you use here, and where do they come from?" or "which of my skills should this repo use?". They answer with skilllib.
-- **✦ Ask an agent.** Copy a ready-made prompt with all of that data, and let Claude Code, Cursor, Codex or Grok tell you what to keep, move or delete.
+- **🖥 An app when you want to look yourself.** `skilllib` opens a terminal app with the same data and fixes, and can copy a review prompt for any agent.
 - **🛟 Nothing is lost.** Every removal goes to a backup you can restore with one key.
 
 Everything runs locally: no server, no account, no network calls.
@@ -63,17 +65,27 @@ Everything runs locally: no server, no account, no network calls.
 
 ## Quick start
 
+It needs **Node.js 22+** and works on macOS and Linux. Windows support is newer: it uses directory junctions, so no admin rights are needed.
+
+### With your agents
+
 ```bash
-npm install -g skilllib    # or: npx skilllib
-skilllib
+npm install -g skilllib
+skilllib agent-skill install
 ```
 
-It needs **Node.js 22+** and works on macOS and Linux. Windows support is newer: it uses directory junctions, so no admin rights are needed.
+This installs the `skilllib` skill where your agents look, in every repo (see [Use it from your agents](#use-it-from-your-agents)). Start a new agent session in any repo and ask away.
+
+### In the app
+
+```bash
+skilllib    # or: npx skilllib
+```
 
 On first run, skilllib asks two things:
 
 1. **Which agents you use:** Claude Code, Cursor, Codex, Zed, Grok. The ones installed on your machine are pre-selected.
-2. **Where your projects live**, e.g. `~/Projects`. It finds every git repo in there, and rescans each time it opens.
+2. **Where your projects live**, e.g. `~/Projects`. It finds every git repo in there, and rescans each time it opens. Agent worktrees (`<repo>/.claude/worktrees/*`) aren't counted as projects.
 
 Then a good first session looks like this:
 
@@ -83,7 +95,26 @@ Then a good first session looks like this:
 
 ---
 
-## Manual
+## Use it from your agents
+
+`skilllib agent-skill install` puts a small `skilllib` skill in `~/.claude/skills` (Claude Code, Cursor and Grok read it there), with a link in `~/.agents/skills` (Codex and Zed). This is the one skill that should be global, because it's about every repo. Upgrading skilllib keeps it up to date, and `skilllib agent-skill remove` takes it out. Agents use it from their next session.
+
+Then ask in plain words. A few examples, with what the agent runs:
+
+| Ask | The agent runs |
+|---|---|
+| *Which skills can you use here, and where does each come from?* | `status --json`, which Claude Code gets as the skill loads, so it answers in one step |
+| *Which of my skills should this repo use?* | `list --json`, then reads the README and manifests, and gives a reason for each pick |
+| *Which skills do I use most? Which ones never?* | `usage --json` (Claude Code usage only, so "never" is a hint) |
+| *Move my global skills into the repos that actually use them.* | `usage --json` to see where each is used, then `global move <name> --to <repo>`, or `global keep <name>` for the ones you want everywhere |
+| *Is anything broken or out of date? Fix it.* | `status --json` or `doctor --json`, then `doctor --fix` for the safe repairs and `apply <id> <choice>` for each decision you approve |
+| *Add the skill from github.com/acme/skills to my library.* | Clones the repo into a temporary folder, then `import <dir>` and `add <name>`. skilllib itself downloads nothing |
+
+The agent asks before it changes anything, unless you asked for that exact change. Anything skilllib removes can be restored: see [Backups](#backups).
+
+---
+
+## The app
 
 ### The screen
 
@@ -143,7 +174,7 @@ What skilllib flags:
 
 ### Adding and removing skills
 
-- **+ Add a skill…** searches your library. Its last rows create a new skill (it opens in `$EDITOR`, and goes into the repo when you close it) or copy a prompt for an agent to write it.
+- **+ Add a skill…** searches your library. Tick several with `space` and add them in one go; a plugin's skills (e.g. ponytail and its `ponytail-*` commands) sit under one row that ticks or adds them all. Its last rows create a new skill (it opens in `$EDITOR`, and goes into the repo when you close it) or copy a prompt for an agent to write it.
 - **Adding** copies the newest version into the fewest folders your agents read, and records it in `skilllib.json`. Agents pick it up in their next session. The layout matches `npx skills`' symlink option: the real copy lives in `.agents/skills`, which nearly every agent reads, and Claude Code gets a link. Grok reads `.agents/skills` and, by default, `.claude/skills`, so it never needs its own copy.
   - Claude Code, with or without Cursor or Grok: `.claude/skills/<name>`.
   - Cursor, Codex, Zed or Grok without Claude Code: `.agents/skills/<name>`.
@@ -175,7 +206,7 @@ Edit a skill once in **Your skills** (Enter → *Edit SKILL.md*). Every repo tha
 
 **Global** lists everything that loads in every repo. Each of your global skills you haven't decided about is flagged **Not reviewed**, with three choices:
 
-- **Move it to the repos that need it…**: tick the repos (the ones where Claude Code used it are pre-ticked). It goes into your library and those repos, and stops loading globally. If a repo commits a folder one of your agents needs a link in (often `.claude/skills`), skilllib asks before adding it there.
+- **Move it to the repos that need it…**: tick the repos (the ones where Claude Code used it are pre-ticked). It goes into your library and those repos, and stops loading globally. If a repo commits a folder one of your agents needs a link in (often `.claude/skills`), skilllib asks before adding it there. From the command line: `skilllib global move <name>... --to <repo>...`.
 - **Keep it global on purpose**: skilllib stops warning about it (also `skilllib global keep <name>`). The mark only records your decision; to undo it, pick **Stop marking it as global on purpose**.
 - **Delete it**: it goes to Settings › Backups.
 
@@ -224,25 +255,6 @@ Paste it into Claude Code, Cursor, Codex or Grok. You get back **keep global / m
 
 It's in every skill's actions, in a repo's **⋯** menu (all its skills), and at the top of Global (all your global skills).
 
-### Ask your agents about skills
-
-Run this once:
-
-```bash
-skilllib agent-skill install
-```
-
-This installs a small `skilllib` skill that tells your agents how to use skilllib. It goes where your agents look, in every repo: `~/.claude/skills` for Claude Code and Cursor, with a link in `~/.agents/skills` for Codex and Zed. This is the one skill that should be global, because it's about every repo. Health and Settings offer the same install, and upgrading skilllib keeps the skill up to date.
-
-Then, in any repo, you can ask:
-
-- *Which skills can you use in this repo?*
-- *Where does each one come from?*
-- *Which skills from my library would you add to this project?*
-- *Is anything out of date? Update it.*
-
-The agent runs `skilllib status --json`, `skilllib list --json` and similar commands, reads the repo, and answers. It asks before it adds or removes anything. `skilllib agent-skill remove` uninstalls it.
-
 ### Duplicates
 
 The same skill often reaches your agents more than once: a copy in `.claude/skills` *and* in `.agents/skills`, a global copy *and* a repo copy, a plugin *and* your skill. skilllib keeps **one real copy per skill, plus only the links your agents need**. **Health** lists each case on the skill it's about, with its fix. From the command line, `skilllib doctor` lists them and `skilllib tidy` fixes the folder ones.
@@ -351,7 +363,7 @@ A skill is a folder with a `SKILL.md`. These are all the places your agents load
 
 ## Command line
 
-Everything the app does also works as a command, for scripts and CI:
+Everything the app does also works as a command, for your agents, scripts and CI:
 
 ```
 skilllib                        open the app (prints `status` when piped)
@@ -370,10 +382,12 @@ skilllib tidy [--all|--global]  one real copy per skill, plus only the links you
 skilllib list | show <name>     your library
 skilllib import <dir>...        add skill folders to your library (--global: all your global skills)
 skilllib global [keep|unkeep]   your global skills; mark the ones you keep global on purpose
+skilllib global move <name> --to <repo>   load a global skill only in those repos
 skilllib new <name> [desc]      create a skill
 
 skilllib usage [--days N]       which skills Claude Code used
 skilllib doctor [--fix]         find (and fix) problems
+skilllib apply <id> [choice]    apply one problem's fix, or the choice you pick (ids from status or doctor --json)
 skilllib restore [name]         put back something skilllib moved out
 skilllib agent-skill [install|remove]   teach your agents to use skilllib
 skilllib --version
@@ -385,13 +399,13 @@ Flags: `--force` (overwrite local edits, backed up to `~/.skilllib/edit-backup`)
 
 A command exits 1 when it couldn't do all you asked: a skill skipped (not in the library, or local edits in the way), links git-tracked folders blocked, an unknown `tidy` name or `--keep` folder. What it did do is still done, and listed.
 
-**`--json`** prints one line of JSON on stdout, for scripts and agents. Messages and warnings go to stderr. It works with `status`, `list`, `show`, `projects`, `outdated`, `usage`, `doctor`, `add`, `remove`, `sync`, `update`, `import` and `agent-skill`. The output is shaped to keep agents fast and cheap:
+**`--json`** prints one line of JSON on stdout, for scripts and agents. Messages and warnings go to stderr. It works with `status`, `list`, `show`, `projects`, `outdated`, `usage`, `doctor`, `apply`, `add`, `remove`, `sync`, `update`, `import`, `global move` and `agent-skill`. The output is shaped to keep agents fast and cheap:
 
 - **`status --json`** answers everything about the repo in one call:
   - the repo's skills, with their source, version, state and git state
   - skills in subfolders (`nested`, e.g. monorepo packages), with their folder
   - the global skills, grouped by where they come from, with the plugins the repo's `.claude/settings.json` turns on or off
-  - every problem skilllib found here, with its fix
+  - every problem skilllib found here, with its fix or choices and an id for `skilllib apply`
   - how often Claude Code used each skill here
   - the repo's top-level files
 
@@ -440,7 +454,7 @@ Environment variables: `SKILLLIB_HOME` moves `~/.skilllib`, `$VISUAL` / `$EDITOR
 - Turning off Cursor marketplace plugins: skilllib lists them and reports ones that duplicate your skills, but Cursor doesn't record which plugins are on in a file skilllib can read.
 - Installing plugins from a marketplace: use `/plugin` in Claude Code. Plugins a repo's own `.claude/settings.json` turns on without installing them aren't listed in Plugins yet.
 - Unloading a `npx skills` skill doesn't update that tool's lock file.
-- Installing new skills straight from GitHub is coming. For now, `skilllib import <folder>` or copy one from a repo.
+- Downloading skills: skilllib makes no network calls. To get a skill from GitHub, clone the repo and run `skilllib import <folder>`, or ask your agent to.
 
 ---
 
@@ -456,14 +470,10 @@ npm link                                     # use your checkout as `skilllib`
 
 How the TUI is designed, and why: [docs/DESIGN.md](docs/DESIGN.md).
 
-**Releasing:**
-1. Bump `version` in `package.json` and merge to `main`.
-2. Tag and push:
-   ```bash
-   git tag v1.10.0 && git push --tags
-   ```
-
-CI then tests on Linux, macOS and Windows, publishes to npm through [trusted publishing](https://docs.npmjs.com/trusted-publishers) (no token; provenance is automatic), and creates a GitHub release.
+**Releasing:** automatic, with [release-please](https://github.com/googleapis/release-please). Don't edit `version` by hand.
+1. Write commits (and PR titles) as [Conventional Commits](https://www.conventionalcommits.org/): `fix:` → patch, `feat:` → minor, `feat!:` or a `BREAKING CHANGE:` footer → major. `docs:`, `ci:`, `chore:`, `test:` and `refactor:` don't release.
+2. After each merge to `main`, release-please keeps one PR, **chore(main): release X.Y.Z**, up to date with the next version and its `CHANGELOG.md`.
+3. Merge that PR when you want to release. It tags `vX.Y.Z` and creates the GitHub release; CI then tests, builds and publishes to npm through [trusted publishing](https://docs.npmjs.com/trusted-publishers) (no token; provenance is automatic).
 
 The earlier registry-server version (Next.js, Postgres, S3) lives on the `archive/registry-server` branch.
 

package/dist/{chunk-Z2F5W3DY.js → chunk-LO4FMXDE.js}

@@ -342,7 +342,10 @@ function knownProjects() {
   const path = projectsFile();
   if (!existsSync4(path)) return [];
   const list2 = JSON.parse(readFileSync3(path, "utf-8"));
-  return onePerFolder(list2.filter((p) => existsSync4(p) && isProjectCandidate(p)));
+  return onePerFolder(list2.filter((p) => existsSync4(p) && isProjectCandidate(p) && !isAgentWorktree(p)));
+}
+function isAgentWorktree(path) {
+  return /[\\/]\.claude[\\/]worktrees[\\/]/.test(path);
 }
 function onePerFolder(paths) {
   const byReal = /* @__PURE__ */ new Map();
@@ -357,7 +360,7 @@ function isProjectCandidate(root) {
   return realPath(root) !== realPath(userHome());
 }
 function rememberProjects(roots) {
-  const incoming = roots.map((r) => resolve3(r)).filter(isProjectCandidate);
+  const incoming = roots.map((r) => resolve3(r)).filter((r) => isProjectCandidate(r) && !isAgentWorktree(r));
   const all = onePerFolder([...knownProjects(), ...incoming]).sort();
   mkdirSync2(skilllibHome(), { recursive: true });
   writeFileSync2(projectsFile(), JSON.stringify(all, null, 2) + "\n");
@@ -1262,7 +1265,7 @@ function refreshAgentSkill() {
 
 // src/commands.ts
 import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
-import { basename as basename8, join as join14, resolve as resolve7, sep as sep5 } from "path";
+import { basename as basename9, join as join14, resolve as resolve7, sep as sep5 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -1989,7 +1992,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(", ")}. 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>).`
+      detail: `${unreviewed.join(", ")}. Move each to the repos that need it (skilllib global move <name> --to <repo>...), or mark the ones you want everywhere as global on purpose (skilllib global keep <name>).`
     });
   }
   const enabled = enabledHarnesses();
@@ -2015,7 +2018,7 @@ function findIssues(projects2, machine, libraryNames, statusOf = projectStatus,
       id: `usable:global${onPurpose ? ":kept" : ""}`,
       severity: "suggestion",
       title: `${plural(skills.length, "global skill")}${onPurpose ? " you keep global" : ""} not usable by ${agentNames(missing)}`,
-      detail: `${skills.map((m) => `${m.name} (only ${agentNames(m.harnesses)})`).join(", ")}. ${onPurpose ? "A link in each agent's global folder makes the one real copy reach every agent you use." : `Link ${skills.length === 1 ? "it" : "them"} for every agent, or move ${skills.length === 1 ? "it" : "them"} to the repos that need ${skills.length === 1 ? "it" : "them"} (skilllib \u2192 Global), which works for every agent too.`}`,
+      detail: `${skills.map((m) => `${m.name} (only ${agentNames(m.harnesses)})`).join(", ")}. ${onPurpose ? "A link in each agent's global folder makes the one real copy reach every agent you use." : `Link ${skills.length === 1 ? "it" : "them"} for every agent, or move ${skills.length === 1 ? "it" : "them"} to the repos that need ${skills.length === 1 ? "it" : "them"} (skilllib global move), which works for every agent too.`}`,
       ...onPurpose ? { fix: link2 } : { choices: [link2] }
     });
   }
@@ -2377,6 +2380,9 @@ function topLevel(root) {
     return [];
   }
 }
+function statusIssues(root, machine = machineSkills(enabledHarnesses())) {
+  return findIssues(projectHere(root) === root ? [root] : [], machine, new Set(librarySkills().map((l) => l.name)));
+}
 function usableHere(root, uses = /* @__PURE__ */ new Map()) {
   const agents = enabledHarnesses();
   const inRepo = projectHere(root) === root;
@@ -2412,11 +2418,12 @@ function usableHere(root, uses = /* @__PURE__ */ new Map()) {
     })
   );
   const issues = /* @__PURE__ */ new Map();
-  for (const i of findIssues(inRepo ? [root] : [], machine, new Set(librarySkills().map((l) => l.name)))) {
+  for (const i of statusIssues(root, machine)) {
     const choices = i.choices?.map((c) => c.label);
     const key = `${i.detail}\0${i.fix?.label ?? ""}\0${choices?.join() ?? ""}`;
-    const issue = issues.get(key) ?? { problems: [], detail: i.detail, fix: i.fix?.label, choices };
+    const issue = issues.get(key) ?? { problems: [], ids: [], detail: i.detail, fix: i.fix?.label, choices };
     issue.problems.push(i.title);
+    issue.ids.push(i.id);
     issues.set(key, issue);
   }
   const usesHere = Object.fromEntries([...uses].filter(([, n]) => n > 0));
@@ -2576,6 +2583,25 @@ function usesByProject(uses, projectOf) {
   return byProject;
 }
 
+// src/move.ts
+import { basename as basename8 } from "path";
+function moveGlobalSkills(skills, roots, { group, allowTracked = false, label = basename8 } = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const m of skills) byName.set(m.name, [...byName.get(m.name) ?? [], m]);
+  return [...byName].map(([name, copies]) => {
+    if (new Set(copies.map((m) => treeHash(m.path))).size > 1)
+      return { name, moved: false, reason: `your global copies of ${name} differ; nothing moved (keep one first: skilllib tidy --global)`, changes: [] };
+    if (importSkill(copies[0].path).status === "exists")
+      return { name, moved: false, reason: `your library has a different ${name}; nothing moved (update your library from this copy first)`, changes: [] };
+    if (group) recordOrigin(name, `group: ${group}`);
+    const changes = roots.map((root) => [root, addSkill(root, name, { allowTracked })]);
+    const skipped = changes.filter(([, c]) => c.action === "skipped");
+    if (skipped.length) return { name, moved: false, reason: `not added to ${skipped.map(([r, c]) => `${label(r)} (${c.reason})`).join(", ")}, so it still loads globally`, changes };
+    const failed = copies.map((m) => unloadGlobal(m.path, m.links)).find((r) => !r.ok);
+    return failed && !failed.ok ? { name, moved: false, reason: failed.reason, changes } : { name, moved: true, changes };
+  });
+}
+
 // src/commands.ts
 var USAGE_DAYS = 30;
 function parseArgs(argv) {
@@ -2583,7 +2609,7 @@ function parseArgs(argv) {
   const days = daysIdx >= 0 ? Number(argv[daysIdx + 1]) : USAGE_DAYS;
   const keepIdx = argv.indexOf("--keep");
   return {
-    positional: argv.filter((a, i) => !a.startsWith("--") && argv[i - 1] !== "--days" && argv[i - 1] !== "--keep"),
+    positional: argv.filter((a, i) => !a.startsWith("--") && !["--days", "--keep", "--to"].includes(argv[i - 1])),
     force: argv.includes("--force"),
     all: argv.includes("--all"),
     global: argv.includes("--global"),
@@ -2593,7 +2619,8 @@ function parseArgs(argv) {
     days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS,
     dryRun: argv.includes("--dry-run"),
     allowGit: argv.includes("--allow-git"),
-    ...keepIdx >= 0 && argv[keepIdx + 1] ? { keep: argv[keepIdx + 1] } : {}
+    ...keepIdx >= 0 && argv[keepIdx + 1] ? { keep: argv[keepIdx + 1] } : {},
+    to: argv.flatMap((a, i) => argv[i - 1] === "--to" && !a.startsWith("--") ? a.split(",").filter(Boolean) : [])
   };
 }
 function colorState(state) {
@@ -2673,7 +2700,7 @@ async function status(args) {
   const root = requireProject();
   const skills = projectStatus(root);
   const nested = nestedSkills(root);
-  info(`${basename8(root)} ${dim(tildify(root))}
+  info(`${basename9(root)} ${dim(tildify(root))}
 `);
   if (skills.length === 0 && nested.length === 0) info("No skills in this project yet. Add one from your library with: skilllib add <name>");
   const usage2 = await usageBySkill(args.days, root);
@@ -2750,7 +2777,7 @@ async function list(args) {
     const installs = /* @__PURE__ */ new Map();
     for (const project of visibleProjects()) {
       for (const name of Object.keys(readManifest(project).skills)) {
-        installs.set(name, [...installs.get(name) ?? [], basename8(project)]);
+        installs.set(name, [...installs.get(name) ?? [], basename9(project)]);
       }
     }
     const usage2 = await usageBySkill(args.days);
@@ -2787,7 +2814,7 @@ function projects(args) {
       "projects",
       roots.map(
         (root) => ({
-          name: basename8(root),
+          name: basename9(root),
           path: root,
           skills: projectStatus(root).map(
             (s) => ({ name: s.name, managed: s.managed, state: s.state, version: s.version, latest: s.latest })
@@ -2806,7 +2833,7 @@ function projects(args) {
       const managed = skills.filter((s) => s.managed);
       const attention = skills.filter((s) => s.state !== "ok" && s.state !== "local only").length;
       return {
-        Project: basename8(root),
+        Project: basename9(root),
         Path: dim(tildify(root)),
         Skills: managed.map((s) => s.name).join(", ") || dim("none"),
         "Local only": String(skills.filter((s) => s.state === "local only").length),
@@ -2840,13 +2867,13 @@ function sync(args) {
     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 (args.all) info(`${basename9(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) {
         if (existsSync13(join14(root, MANIFEST_FILE))) success("Installed versions match skilllib.json");
         else info(dim("No skilllib.json: nothing to sync"));
       } else printChanges(root, changes, args);
     }
-    return { project: basename8(root), path: root, changes: withDirs(root, changes) };
+    return { project: basename9(root), path: root, changes: withDirs(root, changes) };
   });
   if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
   if (!args.all) rememberProjects(roots);
@@ -2863,18 +2890,18 @@ function update(args) {
     }
     if (changes.some((c) => c.action === "skipped")) process.exitCode = 1;
     if (!args.json) {
-      if (args.all) info(`${basename8(root)} ${dim(tildify(root))}`);
+      if (args.all) info(`${basename9(root)} ${dim(tildify(root))}`);
       if (changes.length === 0) success("Everything is on the latest version");
       else printChanges(root, changes, args);
     }
-    return { project: basename8(root), path: root, changes: withDirs(root, changes) };
+    return { project: basename9(root), path: root, changes: withDirs(root, changes) };
   });
   if (args.json) args.all ? json("changes --all", results) : json("changes", results[0].changes);
 }
 function outdated(args) {
   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 }))
+    (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ project: basename9(root), path: root, skill: s.name, installed: s.version, latest: s.latest, state: s.state }))
   );
   if (args.json) return json("outdated", behind);
   const rows = behind.map((b) => ({ Project: b.project, Skill: b.skill, Installed: `v${b.installed}`, Latest: `v${b.latest}`, Status: colorState(b.state) }));
@@ -2908,7 +2935,7 @@ function importSkills(args) {
     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}`));
+        if (change.action !== "skipped") info(dim(`  ${basename9(root)} now depends on ${name} v${change.to}`));
       }
       rememberProjects([root]);
     }
@@ -2925,14 +2952,14 @@ function scan(args) {
   const found = discoverProjects();
   const library = new Set(librarySkills().map((s) => s.name));
   const skillNames = (root) => [
-    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.flatMap((d) => skillDirsIn(join14(root, d))).map((d) => basename8(d)), ...nestedSkills(root).map((s) => s.name)])
+    .../* @__PURE__ */ new Set([...ALL_PROJECT_DIRS.flatMap((d) => skillDirsIn(join14(root, d))).map((d) => basename9(d)), ...nestedSkills(root).map((s) => s.name)])
   ];
   const withSkills = found.filter((root) => skillNames(root).length > 0);
   info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project${found.length === 1 ? "" : "s"}, ${withSkills.length} with skills
 `);
   table(
     withSkills.map((root) => ({
-      Project: basename8(root),
+      Project: basename9(root),
       Path: dim(tildify(root)),
       Skills: skillNames(root).map((n) => library.has(n) ? n : yellow(n)).join(", ")
     }))
@@ -3016,12 +3043,12 @@ function restore(args) {
     process.exitCode = 1;
   }
 }
-async function doctor(args) {
+async function allIssues(args, withUsage = true) {
   const projects2 = visibleProjects();
   const machine = machineSkills();
   const libraryNames = new Set(librarySkills().map((s) => s.name));
   const issues = findIssues(projects2, machine, libraryNames);
-  if (enabledHarnesses().includes("claude-code")) {
+  if (withUsage && enabledHarnesses().includes("claude-code")) {
     const projectOf = projectOfFactory(projects2);
     const uses = await scanUsage(args.days);
     const inProject = usesByProject(uses, projectOf);
@@ -3034,6 +3061,10 @@ async function doctor(args) {
       })
     );
   }
+  return issues;
+}
+async function doctor(args) {
+  const issues = await allIssues(args);
   const fixed = (fix) => {
     const r = runFix(fix);
     if (!r.ok) process.exitCode = 1;
@@ -3059,13 +3090,38 @@ async function doctor(args) {
   for (const issue of issues) {
     info(`${issue.severity === "problem" ? red("\u25CF") : yellow("\u25C6")} ${issue.title}`);
     info(dim(`  ${issue.detail}${issue.fix ? `  \u2192  ${issue.fix.label}` : ""}`));
-    if (issue.choices) info(dim(`  choose in skilllib \u2192 Health: ${issue.choices.map((c) => c.label).join(" / ")}`));
+    if (issue.choices) info(dim(`  your call: ${issue.choices.map((c, i) => `${i + 1}) ${c.label}`).join("  ")}  \u2192  skilllib apply ${issue.id} <n>`));
     if (args.fix && issue.fix) {
       const r = fixed(issue.fix);
       info(`  ${r.ok ? green("\u2713") : red("\u2717")} ${r.message}`);
     }
   }
-  if (!args.fix && issues.some((i) => i.fix)) info(dim("\nRun `skilllib doctor --fix` to apply the fixes, or fix them one by one in `skilllib` \u2192 Health."));
+  if (!args.fix && issues.some((i) => i.fix)) info(dim("\nRun `skilllib doctor --fix` to apply the fixes, or one at a time with `skilllib apply <id>`."));
+}
+async function apply(args) {
+  const [id, pick] = args.positional;
+  if (!id) throw new Error("Usage: skilllib apply <issue-id> [choice]   (ids and choices: skilllib status --json or doctor --json)");
+  const found = [...statusIssues(findProjectRoot()), ...await allIssues(args, id.startsWith("unused:"))].filter((i) => i.id === id);
+  if (!found.length) throw new Error(`No issue ${id} right now (it may be fixed already; for an unused:\u2026 issue, pass doctor's --days). See skilllib status --json or doctor --json`);
+  const optionsOf = (i) => i.choices ?? (i.fix ? [i.fix] : []);
+  const labels = (i) => optionsOf(i).map((c) => c.label).join("\0");
+  const byLabel = pick === void 0 ? void 0 : found.find((i) => optionsOf(i).some((c) => c.label.toLowerCase() === pick.toLowerCase()));
+  if (!byLabel && found.some((i) => labels(i) !== labels(found[0]))) {
+    const all = [...new Set(found.flatMap((i) => optionsOf(i).map((c) => c.label)))];
+    throw new Error(`${found[0].title}: its choices differ between this repo and all your repos; pick one by label: ${all.map((l) => `"${l}"`).join("  ")}`);
+  }
+  const issue = byLabel ?? found[0];
+  const options = optionsOf(issue);
+  if (!options.length) throw new Error(`${issue.title}: nothing to apply. ${issue.detail}`);
+  const listed = options.map((c, i) => `${i + 1}) ${c.label}`).join("  ");
+  if (pick === void 0 && options.length > 1) throw new Error(`${issue.title}: pick one: ${listed}`);
+  const choice = pick === void 0 ? options[0] : options.find((c) => c.label.toLowerCase() === pick.toLowerCase()) ?? options[Number(pick) - 1];
+  if (!choice) throw new Error(`${issue.title}: no choice ${pick}. Pick one: ${listed}`);
+  const r = runFix(choice);
+  if (!r.ok) process.exitCode = 1;
+  if (args.json) return json("apply", { id, applied: choice.label, ...r });
+  if (r.ok) success(r.message);
+  else error(r.message);
 }
 async function usage(args) {
   const summaries = summarize(await scanUsage(args.days), projectOfFactory(knownProjects()));
@@ -3074,7 +3130,7 @@ async function usage(args) {
     return json("usage", {
       usageDays: args.days,
       source: "Claude Code transcripts",
-      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename8(p)), inLibrary: library2.has(s.skill) })),
+      skills: summaries.map((s) => ({ skill: s.skill, uses: s.uses, lastUsed: s.lastUsed, projects: [...s.projects].map((p) => basename9(p)), inLibrary: library2.has(s.skill) })),
       unusedLibrarySkills: librarySkills().filter((l) => !summaries.some((u) => u.skill === l.name)).map((l) => l.name)
     });
   }
@@ -3089,7 +3145,7 @@ async function usage(args) {
     summaries.map((s) => ({
       Skill: s.skill,
       Uses: String(s.uses),
-      Projects: [...s.projects].map((p) => basename8(p)).join(", ") || dim("-"),
+      Projects: [...s.projects].map((p) => basename9(p)).join(", ") || dim("-"),
       "Last used": lastUsed(s),
       Library: library.has(s.skill) ? green("yes") : dim("no")
     }))
@@ -3115,7 +3171,7 @@ function show(args) {
       path: dir,
       latest: latestVersion(name)?.version ?? null,
       origin: libraryOrigins()[name] ?? "",
-      projects: knownProjects().filter((p) => name in readManifest(p).skills).map((p) => basename8(p)),
+      projects: knownProjects().filter((p) => name in readManifest(p).skills).map((p) => basename9(p)),
       skillMd: readFileSync9(join14(dir, "SKILL.md"), "utf-8")
     });
   }
@@ -3149,7 +3205,7 @@ function link(args) {
   for (const root of roots) {
     if (args.allowTracked) allowTrackedLinks(root);
     const res = linkAll(root);
-    const label = args.all ? `${basename8(root)}: ` : "";
+    const label = args.all ? `${basename9(root)}: ` : "";
     if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
     else if (!args.all && !res.blocked.length && !res.uncommitted.length) success("Every skill here is already usable by all your agents");
     if (res.blocked.length) {
@@ -3165,6 +3221,7 @@ function link(args) {
 function globalCommand(args) {
   const [action, ...names] = args.positional;
   const yours = machineSkills().filter((m) => m.movable && !m.broken);
+  if (action === "move") return moveGlobal(args, names, yours);
   if (action === "keep" || action === "unkeep") {
     const unknown = names.filter((n) => !yours.some((m) => m.name === n));
     if (!names.length || unknown.length) {
@@ -3174,7 +3231,7 @@ function globalCommand(args) {
     setKeepGlobal(names, action === "keep");
     success(action === "keep" ? `Keeping ${names.join(", ")} global on purpose` : `${names.join(", ")} will show up in cleanup again`);
   } else if (action) {
-    error("Usage: skilllib global [keep|unkeep <name>...]");
+    error("Usage: skilllib global [keep|unkeep <name>...] | skilllib global move <name>... --to <repo>...");
     process.exit(1);
   }
   const kept = keptGlobal();
@@ -3184,6 +3241,46 @@ function globalCommand(args) {
   if (unreviewed) info(dim(`
 ${unreviewed} not reviewed. Keep one global on purpose: skilllib global keep <name>`));
 }
+function repoRoot(repo) {
+  const looksLikePath = /[\\/]/.test(repo) || repo.startsWith(".") || repo.startsWith("~");
+  const named = looksLikePath ? [] : visibleProjects().filter((p) => basename9(p) === repo);
+  if (named.length === 1) return named[0];
+  if (named.length > 1) throw new Error(`Several projects are named ${repo}: ${named.map(tildify).join(", ")}. Pass its path.`);
+  const path = expandHome(repo);
+  if (!existsSync13(path)) throw new Error(`No project ${repo} (pass its path, or see skilllib projects)`);
+  const root = projectHere(path);
+  if (root !== path) throw new Error(root ? `${tildify(path)} is inside ${tildify(root)}: pass the repo's top folder` : `${tildify(path)} isn't in a git repo`);
+  return root;
+}
+function moveGlobal(args, names, yours) {
+  if (!names.length || !args.to.length) throw new Error("Usage: skilllib global move <name>... --to <repo>[,<repo>...]");
+  const unknown = names.filter((n) => !yours.some((m) => m.name === n));
+  if (unknown.length) throw new Error(`Not one of your global skills: ${unknown.join(", ")} (see skilllib global)`);
+  const roots = [...new Set(args.to.map(repoRoot))];
+  const skills = yours.filter((m) => names.includes(m.name));
+  const moves = moveGlobalSkills(skills, roots, { allowTracked: args.allowTracked });
+  if (moves.some((m) => !m.moved)) process.exitCode = 1;
+  if (args.json) {
+    return json(
+      "global move",
+      moves.map(({ name, moved, reason, changes }) => ({
+        skill: name,
+        moved,
+        ...reason ? { reason } : {},
+        projects: changes.map(([root, c]) => ({ project: basename9(root), path: root, change: withDirs(root, [c])[0] }))
+      }))
+    );
+  }
+  for (const m of moves) {
+    if (m.moved) success(`${m.name} now loads only in ${m.changes.map(([r]) => basename9(r)).join(", ")} (the global copy is in skilllib restore)`);
+    else error(`${m.name}: ${m.reason}`);
+    for (const [root, c] of m.changes) {
+      if (c.blocked?.length) warn(`  ${basename9(root)}: git tracks ${c.blocked.join(", ")}, so no link there. Re-run with --allow-tracked to add it.`);
+      if (c.uncommitted?.length) warn(`  ${basename9(root)}: no link in ${c.uncommitted.join(", ")}: git tracks it but not the skill's copy, so the link would break for teammates. Commit the copy, then run skilllib link --allow-tracked.`);
+    }
+  }
+  if (moves.some((m) => m.moved)) info(dim("Commit skilllib.json and the skill folders in each repo."));
+}
 function tidy(args) {
   const names = args.positional;
   const keepFor = (base) => args.keep ? Object.fromEntries(names.map((n) => [n, base ? resolve7(base, args.keep) : expandHome(args.keep)])) : {};
@@ -3196,13 +3293,13 @@ function tidy(args) {
   for (const name of names) {
     const where = targets.map((root) => ({ root, ...foldersOf(root, name) })).filter((w) => w.all.length);
     if (!where.length) {
-      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename8(targets[0])}`}`);
+      problems.push(`${name}: no skill by that name ${args.global ? "in your global folders" : args.all ? "in your projects" : `in ${basename9(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 ` : "";
+      const label = root ? `${basename9(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"}`
       );
@@ -3213,7 +3310,7 @@ function tidy(args) {
     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) }) }
+    (root) => root === null ? { label: "global folders", report: planGlobalTidy({ keep: keepFor(null) }) } : { label: basename9(root), report: planProjectTidy(root, { keep: keepFor(root) }) }
   );
   let held = 0;
   let changed = 0;
@@ -3347,6 +3444,7 @@ export {
   copyLabel,
   addedAt,
   scanUsage,
+  moveGlobalSkills,
   parseArgs,
   projectOfFactory,
   status,
@@ -3365,6 +3463,7 @@ export {
   newSkill,
   restore,
   doctor,
+  apply,
   usage,
   show,
   harnessesCommand,

package/dist/index.js

@@ -2,6 +2,7 @@
 import {
   add,
   agentSkill,
+  apply,
   doctor,
   error,
   folders,
@@ -27,7 +28,7 @@ import {
   unhide,
   update,
   usage
-} from "./chunk-Z2F5W3DY.js";
+} from "./chunk-LO4FMXDE.js";
 
 // src/index.ts
 import { readFileSync } from "fs";
@@ -43,6 +44,8 @@ Set up:
   skilllib import <dir>...       Add skill folders to the library (--force replaces)
   skilllib import --global       Copy your global skills (every agent's folder) into the library
   skilllib global [keep|unkeep <name>...]  Your global skills; mark ones you keep global on purpose
+  skilllib global move <name>... --to <repo>...
+                                 Load global skills only in those repos (by path or project name)
 
 In a project (a git repo or a folder with skilllib.json; never your home folder):
   skilllib status                This project's skills, which agents load them, and issues
@@ -65,6 +68,7 @@ Library:
 
 Health:
   skilllib doctor [--fix]        Broken links, duplicates, out-of-date projects
+  skilllib apply <id> [choice]   Apply one issue's fix, or the choice you pick (number or label)
   skilllib restore [name]        Restore something skilllib moved out of the way
   skilllib unhide <path>         Show a hidden project again
 
@@ -73,7 +77,7 @@ Agents:
                                  Teach your agents to use skilllib, so you can ask them
                                  "which skills can you use here?" in any repo
   --json                         Machine-readable output (status list show projects outdated
-                                 usage doctor add remove sync update import agent-skill)
+                                 usage doctor apply add remove sync update import global move agent-skill)
 
 Options: --force (overwrite local edits)  --allow-tracked (link into git-tracked skill folders)  --days N
 `.trim();
@@ -92,10 +96,10 @@ async function main() {
   if (!["--version", "-v", "version", "help", "--help", "-h"].includes(command ?? "")) refreshAgentSkill();
   switch (command) {
     case void 0:
-      return process.stdin.isTTY && process.stdout.isTTY ? (await import("./tui-7CMGG6HX.js")).tui() : overview(args);
+      return process.stdin.isTTY && process.stdout.isTTY ? (await import("./tui-3LDZ5GOZ.js")).tui() : overview(args);
     case "ui":
       if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("`skilllib ui` needs an interactive terminal. Agents and scripts: use `skilllib status --json`.");
-      return (await import("./tui-7CMGG6HX.js")).tui();
+      return (await import("./tui-3LDZ5GOZ.js")).tui();
     case "status":
       return status(args);
     case "add":
@@ -144,6 +148,8 @@ async function main() {
       return restore(args);
     case "doctor":
       return doctor(args);
+    case "apply":
+      return apply(args);
     case "usage":
       return usage(args);
     case "agent-skill":

package/dist/json.d.cts

@@ -70,10 +70,13 @@ type StatusGlobalGroup = {
 };
 /**
  * Problems skilllib found here or in your global skills that share a cause and remedy: a `fix` is a
- * safe repair (`skilllib doctor --fix` runs it); `choices` need the user to decide (skilllib → Health).
+ * safe repair (`skilllib doctor --fix` runs it); `choices` need the user to decide.
+ * `skilllib apply <id> [choice]` applies either, one problem at a time.
  */
 type StatusIssue = {
     problems: string[];
+    /** One per problem, in the same order: what `skilllib apply` takes. */
+    ids: string[];
     detail: string;
     fix?: string;
     choices?: string[];
@@ -167,7 +170,7 @@ type DoctorJson = {
     detail: string;
     /** A safe repair; `doctor --fix` runs it. */
     fix?: string;
-    /** Fixes that need a decision (skilllib → Health). */
+    /** Fixes that need a decision: `skilllib apply <id> <n>` runs the nth (from 1). */
     choices?: string[];
     /** With --fix: what running `fix` did. */
     fixed?: {
@@ -175,6 +178,25 @@ type DoctorJson = {
         message: string;
     };
 }[];
+/** `skilllib apply <issue-id> [choice] --json` */
+type ApplyJson = {
+    id: string;
+    applied: string;
+    ok: boolean;
+    message: string;
+};
+/** `skilllib global move <name>... --to <repo>... --json`: one entry per skill. */
+type GlobalMoveJson = {
+    skill: string;
+    /** Added to every repo and no longer global. When false, it still loads globally and `reason` says why. */
+    moved: boolean;
+    reason?: string;
+    projects: {
+        project: string;
+        path: string;
+        change: ChangeJson;
+    }[];
+}[];
 /** `skilllib usage [--days N] --json` */
 type UsageJson = {
     usageDays: number;
@@ -197,4 +219,4 @@ type AgentSkillJson = {
     removed?: string[];
 };
 
-export type { AgentSkillJson, AgentSkillState, AllChangesJson, ChangeJson, ChangesJson, DoctorJson, GitState, HarnessId, ImportJson, ListJson, OutdatedJson, ProjectSource, ProjectsJson, ShowJson, SkillState, SourceKind, StatusGlobalGroup, StatusIssue, StatusJson, StatusSkillGroup, UsageJson };
+export type { AgentSkillJson, AgentSkillState, AllChangesJson, ApplyJson, ChangeJson, ChangesJson, DoctorJson, GitState, GlobalMoveJson, HarnessId, ImportJson, ListJson, OutdatedJson, ProjectSource, ProjectsJson, ShowJson, SkillState, SourceKind, StatusGlobalGroup, StatusIssue, StatusJson, StatusSkillGroup, UsageJson };

package/dist/json.d.ts

@@ -70,10 +70,13 @@ type StatusGlobalGroup = {
 };
 /**
  * Problems skilllib found here or in your global skills that share a cause and remedy: a `fix` is a
- * safe repair (`skilllib doctor --fix` runs it); `choices` need the user to decide (skilllib → Health).
+ * safe repair (`skilllib doctor --fix` runs it); `choices` need the user to decide.
+ * `skilllib apply <id> [choice]` applies either, one problem at a time.
  */
 type StatusIssue = {
     problems: string[];
+    /** One per problem, in the same order: what `skilllib apply` takes. */
+    ids: string[];
     detail: string;
     fix?: string;
     choices?: string[];
@@ -167,7 +170,7 @@ type DoctorJson = {
     detail: string;
     /** A safe repair; `doctor --fix` runs it. */
     fix?: string;
-    /** Fixes that need a decision (skilllib → Health). */
+    /** Fixes that need a decision: `skilllib apply <id> <n>` runs the nth (from 1). */
     choices?: string[];
     /** With --fix: what running `fix` did. */
     fixed?: {
@@ -175,6 +178,25 @@ type DoctorJson = {
         message: string;
     };
 }[];
+/** `skilllib apply <issue-id> [choice] --json` */
+type ApplyJson = {
+    id: string;
+    applied: string;
+    ok: boolean;
+    message: string;
+};
+/** `skilllib global move <name>... --to <repo>... --json`: one entry per skill. */
+type GlobalMoveJson = {
+    skill: string;
+    /** Added to every repo and no longer global. When false, it still loads globally and `reason` says why. */
+    moved: boolean;
+    reason?: string;
+    projects: {
+        project: string;
+        path: string;
+        change: ChangeJson;
+    }[];
+}[];
 /** `skilllib usage [--days N] --json` */
 type UsageJson = {
     usageDays: number;
@@ -197,4 +219,4 @@ type AgentSkillJson = {
     removed?: string[];
 };
 
-export type { AgentSkillJson, AgentSkillState, AllChangesJson, ChangeJson, ChangesJson, DoctorJson, GitState, HarnessId, ImportJson, ListJson, OutdatedJson, ProjectSource, ProjectsJson, ShowJson, SkillState, SourceKind, StatusGlobalGroup, StatusIssue, StatusJson, StatusSkillGroup, UsageJson };
+export type { AgentSkillJson, AgentSkillState, AllChangesJson, ApplyJson, ChangeJson, ChangesJson, DoctorJson, GitState, GlobalMoveJson, HarnessId, ImportJson, ListJson, OutdatedJson, ProjectSource, ProjectsJson, ShowJson, SkillState, SourceKind, StatusGlobalGroup, StatusIssue, StatusJson, StatusSkillGroup, UsageJson };

package/dist/{tui-7CMGG6HX.js → tui-3LDZ5GOZ.js}

@@ -36,6 +36,7 @@ import {
   linkGlobal,
   listBackups,
   machineSkills,
+  moveGlobalSkills,
   planGlobalTidy,
   planProjectTidy,
   pluginBackups,
@@ -72,7 +73,7 @@ import {
   versionHistory,
   visibilityOf,
   visibleProjects
-} from "./chunk-Z2F5W3DY.js";
+} from "./chunk-LO4FMXDE.js";
 
 // src/tui/index.tsx
 import { render } from "ink";
@@ -873,11 +874,14 @@ function originGroup(origin) {
   return null;
 }
 var word = (name) => name.split(/[-_.]/)[0];
+function libraryOrigin(w, l) {
+  return l && (l.origin ?? w.library.find((x) => x.origin?.match(/^plugin: ([^@]+)@/)?.[1] === l.name)?.origin);
+}
 function groupCandidates(w, u) {
   const byTime = (family, installed) => installed ? [{ key: `time:${family}:${installed}`, label: `installed together ${installed.slice(0, 10)}` }] : [];
   const byWord = (family, name) => word(name).length >= 3 ? [{ key: `word:${family}:${word(name)}`, label: `${word(name)}-*` }] : [];
   if (!("source" in u)) {
-    const origin = originGroup(u.origin);
+    const origin = originGroup(libraryOrigin(w, u));
     return [...origin ? [origin] : [], ...byWord("library", u.name)];
   }
   const m = u.machine;
@@ -892,8 +896,7 @@ function groupCandidates(w, u) {
     return [...origin ? [origin] : [], ...byTime("global", m.installed), ...byWord("global", m.name)];
   }
   if (u.local?.source === "lib") {
-    const l = w.library.find((x) => x.name === u.name);
-    const origin = originGroup(l?.origin);
+    const origin = originGroup(libraryOrigin(w, w.library.find((x) => x.name === u.name)));
     return [...origin ? [origin] : [], ...byWord("local", u.name)];
   }
   return byWord("local", u.name);
@@ -920,7 +923,33 @@ function addRows(w, target, q) {
   const taken = new Set(target ? project(w, target).skills.map((s) => s.name) : []);
   const loaded = new Set(target ? usable(w, target).map((u) => u.name) : []);
   const hit = (name, description) => !q || matches(name, q) || q.length >= 3 && description.toLowerCase().includes(q);
-  const library = target ? w.library.filter((l) => !taken.has(l.name) && hit(l.name, w.descriptions[l.name] ?? "")).map((l) => ({ key: `lib:${l.name}`, name: l.name, note: `v${l.latest}`, description: w.descriptions[l.name] ?? "", run: (w2) => w2.ops.add(target, l.name) })) : [];
+  const groups = assignGroups(w.library.map((l) => groupCandidates(w, l)));
+  const shown = w.library.map((l, i) => ({ l, g: groups[i] })).filter(({ l }) => !taken.has(l.name) && hit(l.name, w.descriptions[l.name] ?? ""));
+  const skillRow = (l, inGroup) => ({
+    key: `lib:${l.name}`,
+    name: l.name,
+    note: `v${l.latest}`,
+    description: w.descriptions[l.name] ?? "",
+    members: [l.name],
+    ...inGroup ? { inGroup } : {},
+    run: (w2) => w2.ops.add(target, l.name)
+  });
+  const library = [];
+  const done = /* @__PURE__ */ new Set();
+  for (const { l, g } of target ? shown : []) {
+    if (done.has(l.name)) continue;
+    const members = g ? shown.filter((x) => x.g?.key === g.key).map((x) => x.l) : [l];
+    members.forEach((m) => done.add(m.name));
+    if (members.length < 2) {
+      library.push(skillRow(l, false));
+      continue;
+    }
+    const names = members.map((m) => m.name);
+    library.push(
+      { key: `group:${g.key}`, name: groupLabel(g, names), note: `${names.length} skills`, description: names.join(", "), members: names, run: (w2) => w2.ops.addTo([target], names) },
+      ...members.map((m) => skillRow(m, true))
+    );
+  }
   const exists = q !== "" && (loaded.has(q) || w.library.some((l) => l.name === q));
   const where = target ? ` for ${target}` : "";
   const fresh = exists ? [] : [
@@ -1682,7 +1711,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       const repo = open;
       const skills = project(world, repo).skills.map((s) => s.name);
       return [
-        row("#add", "+ Add a skill\u2026", ["Search your library, or create a new skill."], () => setModal({ kind: "add", cursor: 0, query: "", target: repo })),
+        row("#add", "+ Add a skill\u2026", ["Search your library, or create a new skill."], () => setModal({ kind: "add", cursor: 0, query: "", target: repo, picked: /* @__PURE__ */ new Set() })),
         ...fix,
         row(
           "#repo",
@@ -1705,7 +1734,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     }
     if (place === "health") return fix;
     if (place === "library")
-      return [row("#add", "+ New skill\u2026", ["Create a skill in your library, or have an agent write it. Skills in your repos can be copied in from their own actions."], () => setModal({ kind: "add", cursor: 0, query: "", target: null }))];
+      return [row("#add", "+ New skill\u2026", ["Create a skill in your library, or have an agent write it. Skills in your repos can be copied in from their own actions."], () => setModal({ kind: "add", cursor: 0, query: "", target: null, picked: /* @__PURE__ */ new Set() }))];
     return [];
   }
   function move(delta) {
@@ -1963,6 +1992,18 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       if (key.upArrow) return step(-1);
       if (key.downArrow) return step(1);
       if (key.backspace || key.delete) return setModal({ ...m, query: m.query.slice(0, -1), cursor: 0 });
+      const members = rows[cursor2]?.members;
+      if (input === " " && members) {
+        const picked = new Set(m.picked);
+        const all2 = members.every((n) => picked.has(n));
+        for (const n of members) all2 ? picked.delete(n) : picked.add(n);
+        return setModal({ ...m, picked });
+      }
+      if (key.return && m.target && m.picked.size) {
+        const [target, names] = [m.target, [...m.picked]];
+        setModal(null);
+        return apply((w) => w.ops.addTo([target], names));
+      }
       if (key.return && rows[cursor2]?.agent) {
         setModal(null);
         return ui.copy(writeSkillPrompt(world, m.query, m.target), "a prompt for an agent to write the skill");
@@ -2170,10 +2211,15 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
     );
   } else if (modal?.kind === "add") {
     const rows = addRows(world, modal.target, modal.query);
+    const picked = modal.picked;
+    const tick = (names) => {
+      const n = names.filter((x) => picked.has(x)).length;
+      return { text: n === names.length ? "[x] " : n ? "[-] " : "[ ] ", width: 4, color: n ? color.green : color.faint };
+    };
     body = /* @__PURE__ */ jsx2(
       ListPanel,
       {
-        title: modal.target ? `Add a skill to ${modal.target}` : "New skill",
+        title: modal.target ? picked.size ? `Add ${picked.size} skill${picked.size === 1 ? "" : "s"} to ${modal.target}` : `Add a skill to ${modal.target}` : "New skill",
         focused: true,
         width: columns,
         height: bodyH,
@@ -2182,10 +2228,14 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
         header: /* @__PURE__ */ jsx2(Text2, { color: modal.query ? color.accent : color.muted, children: modal.query ? `\u2315 ${modal.query}\u258F` : modal.target ? "type to search your library, or to name a new skill" : "type the new skill's name" }),
         headerHeight: 1,
         rows: rows.map(
-          (r) => r.header ? { key: r.key, header: true, cells: [{ text: r.header }] } : r.create || r.agent ? { key: r.key, cells: [{ text: r.name, grow: true, color: color.accent }] } : {
+          (r) => r.header ? { key: r.key, header: true, cells: [{ text: r.header }] } : r.create || r.agent ? { key: r.key, cells: [{ text: r.name, grow: true, color: color.accent }] } : r.members.length > 1 ? {
+            key: r.key,
+            cells: [tick(r.members), { text: clip(r.name, 30), width: 30, bold: true }, { text: `${r.note}: ${r.description}`, grow: true, color: color.faint }]
+          } : {
             key: r.key,
             cells: [
-              { text: clip(r.name, 22), width: 22 },
+              tick(r.members),
+              { text: clip(`${r.inGroup ? "  " : ""}${r.name}`, 24), width: 24 },
               { text: r.note, width: 6, color: color.accent },
               { text: r.description, grow: true, color: color.faint }
             ]
@@ -2200,7 +2250,7 @@ function App({ initial, reload, loadUsage: loadUsage2 }) {
       list,
       split ? side : null
     ] });
-  const hints = modal?.kind === "confirm" ? "enter apply \xB7 esc cancel" : modal?.kind === "repos" || modal?.kind === "fixall" ? "space tick \xB7 enter apply \xB7 esc cancel" : modal?.kind === "agents" ? "space tick \xB7 enter save" : modal?.kind === "menu" ? "\u2191\u2193 choose \xB7 enter do it \xB7 esc cancel" : modal?.kind === "add" ? "enter add \xB7 esc cancel" : modal ? "any key closes" : focus === "detail" ? "\u2191\u2193 \u2190\u2192 choose \xB7 enter apply \xB7 esc back" : focus === "sidebar" ? "\u2191\u2193 choose \xB7 enter open \xB7 type to filter repos" : place === "projects" && !open ? `type to filter \xB7 enter open \xB7 ${sidebar ? "\u2190 sidebar" : "\u2190\u2192 places"} \xB7 ? keys` : place === "settings" ? `enter toggle \xB7 ${sidebar ? "\u2190 sidebar" : "\u2190\u2192 places"} \xB7 ? keys` : `type to filter \xB7 space \u2605 fix \xB7 enter actions \xB7 tab tabs${sidebar ? " \xB7 esc back" : `${dashboard ? " \xB7 esc all projects" : ""} \xB7 ? keys`}`;
+  const hints = modal?.kind === "confirm" ? "enter apply \xB7 esc cancel" : modal?.kind === "repos" || modal?.kind === "fixall" ? "space tick \xB7 enter apply \xB7 esc cancel" : modal?.kind === "agents" ? "space tick \xB7 enter save" : modal?.kind === "menu" ? "\u2191\u2193 choose \xB7 enter do it \xB7 esc cancel" : modal?.kind === "add" ? modal.target ? "space tick \xB7 enter add \xB7 esc cancel" : "enter add \xB7 esc cancel" : modal ? "any key closes" : focus === "detail" ? "\u2191\u2193 \u2190\u2192 choose \xB7 enter apply \xB7 esc back" : focus === "sidebar" ? "\u2191\u2193 choose \xB7 enter open \xB7 type to filter repos" : place === "projects" && !open ? `type to filter \xB7 enter open \xB7 ${sidebar ? "\u2190 sidebar" : "\u2190\u2192 places"} \xB7 ? keys` : place === "settings" ? `enter toggle \xB7 ${sidebar ? "\u2190 sidebar" : "\u2190\u2192 places"} \xB7 ? keys` : `type to filter \xB7 space \u2605 fix \xB7 enter actions \xB7 tab tabs${sidebar ? " \xB7 esc back" : `${dashboard ? " \xB7 esc all projects" : ""} \xB7 ? keys`}`;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: termCols, height: termRows, children: [
     sidebar ? null : topBar,
     /* @__PURE__ */ jsxs2(Box2, { children: [
@@ -2655,29 +2705,19 @@ function realOps(roots, backups) {
       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}`);
+      const repoRoots = repos.map(rootOf);
+      for (const mv of moveGlobalSkills(skills, repoRoots, { group, label: (root) => repos[repoRoots.indexOf(root)] })) {
+        if (!mv.moved) {
+          notes.push(`${mv.name}: ${mv.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] : []);
+        moved.push(mv.name);
+        for (const [i, [root, c]] of mv.changes.entries()) {
+          const repo = repos[i];
+          const blind = visibilityOf(root, mv.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 });
+          held.push({ repo, name: mv.name, blocked, blind, copy: copyDir(repo, mv.name), shared: !c.uncommitted?.length });
         }
       }
       const gaps = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skilllib",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "description": "Manage your agent skills like dependencies. One library for all your skills; each repo gets only the ones it needs, and every agent can see them. Works with Claude Code, Cursor, Codex, Zed and Grok.",
   "keywords": [
     "agent-skills",

package/skills/skilllib/SKILL.md

@@ -14,25 +14,32 @@ Always pass `--json` (one line of JSON on stdout; messages go to stderr). Never
 
 The **Now** section at the end has this repo's `status` and `list` output. Answer from it and don't run them again. If it shows the commands instead of their output, run both in parallel.
 
-`status --json`: `skills` are this repo's own; `nested` (when there are any) are in subfolders such as monorepo packages, and load only when the agent works in their `dir`; `global` groups load in every repo, as this repo loads them (its `.claude/settings.json` can turn a plugin on or off); `issues` are everything skilllib finds wrong (out-of-date or missing skills, broken links, skills loaded twice), with either a `fix` (a safe repair; `skilllib doctor --fix` applies every fix, across all the user's projects) or `choices` (decisions the user makes in `skilllib` → Health). When asked what's out of date or broken, `issues` and each skill's `state` are the answer. Don't audit skill contents unless asked.
+`status --json`: `skills` are this repo's own; `nested` (when there are any) are in subfolders such as monorepo packages, and load only when the agent works in their `dir`; `global` groups load in every repo, as this repo loads them (its `.claude/settings.json` can turn a plugin on or off); `issues` are everything skilllib finds wrong (out-of-date or missing skills, broken links, skills loaded twice), one `ids` entry per `problems` entry, with either a `fix` (a safe repair; `skilllib doctor --fix` applies every fix, across all the user's projects) or `choices` (decisions: propose one, and apply it once the user agrees, see Changing). When asked what's out of date or broken, `issues` and each skill's `state` are the answer. Don't audit skill contents unless asked.
 
 - `source`: `library` (added with skilllib) · `repo` (the team's: committed to git, or in `.agents/skills`) · `local` (only on this machine: not committed, not managed by skilllib) · `global` (`~/.claude/skills`, `~/.agents/skills` or `~/.codex/skills`) · `skills.sh` (`npx skills add`; `from` is the source repo) · `plugin` (Claude Code plugin; turn off with `/plugin`) · `claude.ai` (synced from the account) · `built-in` (bundled with an agent) · `skilllib` (this skill; `skilllib agent-skill remove` takes it out).
 - Missing fields mean the usual: loaded by all of `agents`, state ok, in `.claude/skills`. `usesHere` counts Claude Code uses in this repo.
 
-`list --json`: `inThisProject` (names) and `skills`, the library skills the repo doesn't have, each with a short `description` and the `projects` using it. To recommend, read the repo's README and manifests (see `files` in `status`) in one parallel step, then give a reason for each pick. Don't add a skill that already loads globally (it would load twice): name it, and say `skilllib` → Global → Clean up moves it into just the repos that need it. `show <name> --json` has the full SKILL.md.
+`list --json`: `inThisProject` (names) and `skills`, the library skills the repo doesn't have, each with a short `description` and the `projects` using it. To recommend, read the repo's README and manifests (see `files` in `status`) in one parallel step, then give a reason for each pick. Don't add a skill that already loads globally (it would load twice): offer to move it into just the repos that need it instead (`global move`). `show <name> --json` has the full SKILL.md.
 
-Also: `usage --json` (Claude Code usage only, so "unused" is a hint), `projects --json` (every repo), `outdated --all --json`.
+Also: `usage --json` (Claude Code usage only, so "unused" is a hint; each skill lists the `projects` that used it), `projects --json` (every repo), `outdated --all --json`, `doctor --json` (every issue in every repo and globally, each with an `id`).
 
 ## Changing (ask first unless the user asked for this exact change)
 
-`add <name>...` · `remove <name>...` · `update [name...]` · `sync` (pinned versions) · `import <dir>` (into the library) · `doctor --fix`. Pass several names in one call. Each prints `[{name, action, from, to, dirs, reason, blocked, uncommitted, backedUp}]`, which is the whole result: there's no need to check files afterwards.
+`add <name>...` · `remove <name>...` · `update [name...]` · `sync` (pinned versions) · `import <dir>` (into the library) · `doctor --fix`. Pass several names in one call. Their result is `[{name, action, from, to, dirs, reason, blocked, uncommitted, backedUp}]`, which is the whole result: there's no need to check files afterwards.
 
 - `skipped` + `reason`: nothing changed for that skill, and the command exits 1; tell the user. `--force` overwrites local edits (`backedUp` says where they went; `skilllib restore <name>` brings them back), but only use it with their OK.
 - `blocked`: git tracks that folder. Re-run with `--allow-tracked` only with their OK.
 - `uncommitted`: git tracks that folder but not the skill's real copy, so a link there would break for teammates; `--allow-tracked` doesn't change that. Once the copy is committed, `link --allow-tracked` adds it.
 - Changes apply from the agent's next session. Remind the user to commit `skilllib.json` and `.claude/skills`.
 
-To move global skills into repos, tell the user to run `skilllib` and open Global → Clean up.
+**Prefer per-repo skills to global ones.** A global skill loads in every repo, for every agent. When `usage --json` shows one used in only a few repos, propose moving it there:
+
+- `global move <name>... --to <repo>[,<repo>...]` (a project name from `projects`, or the path of a repo's top folder): imports it into the library, adds it to each repo, and only then stops loading it globally (restorable with `skilllib restore`). Prints `[{skill, moved, reason, projects: [{project, path, change}]}]`; `moved: false` means it still loads globally, and `reason` says why.
+- `global keep <name>...`: the user wants it everywhere; skilllib stops flagging it.
+
+**Fixes and decisions.** `apply <id> [choice]` runs one problem's `fix`, or the choice you name: its label (safest), or its number from 1. With several choices it needs one. Prints `{id, applied, ok, message}`. Ids come from `issues` in `status --json` (Now, below) or from `doctor --json` (every repo; pass `apply` the same `--days` you gave `doctor`). A few issues span repos and offer different choices in each; then `apply` takes only the label.
+
+**Importing.** `import <dir>...` copies skill folders (each with a `SKILL.md`) into the library; skilllib doesn't download anything. For a skill on GitHub, clone the repo into a temporary folder, `import` the skill's folder, then `add` it here.
 
 ## Now