skilllib 1.0.0

package/dist/chunk-J5ZDUXWL.js

@@ -0,0 +1,1572 @@
+// src/output.ts
+import { sep } from "path";
+import { homedir } from "os";
+var color = (code) => (s) => process.stdout.isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
+var green = color(32);
+var yellow = color(33);
+var red = color(31);
+var dim = color(2);
+var info = (msg) => console.log(msg);
+var success = (msg) => console.log(`${green("\u2713")} ${msg}`);
+var warn = (msg) => console.log(`${yellow("!")} ${msg}`);
+var error = (msg) => console.error(`${red("\u2717")} ${msg}`);
+function tildify(path) {
+  const home2 = homedir();
+  return path === home2 || path.startsWith(home2 + sep) ? "~" + path.slice(home2.length) : path;
+}
+function truncate(s, max) {
+  const line = s.replace(/\s+/g, " ");
+  return line.length > max ? line.slice(0, max - 1) + "\u2026" : line;
+}
+var visible = (s) => s.replace(/\x1b\[\d+m/g, "");
+function table(rows) {
+  if (rows.length === 0) return;
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => visible(r[k] ?? "").length)));
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - visible(s).length));
+  info(dim(keys.map((k, i) => pad(k, widths[i])).join("  ")));
+  for (const row of rows) info(keys.map((k, i) => pad(row[k] ?? "", widths[i])).join("  ").trimEnd());
+}
+
+// src/commands.ts
+import { basename as basename5, join as join11, resolve as resolve4, sep as sep4 } from "path";
+
+// src/library.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync3, renameSync, rmSync as rmSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename3, dirname as dirname2, join as join8, relative as relative2, sep as sep3 } from "path";
+
+// src/paths.ts
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+function userHome() {
+  return process.env.HOME || homedir2();
+}
+function skilllibHome() {
+  return process.env.SKILLLIB_HOME ?? join(userHome(), ".skilllib");
+}
+function libraryDir() {
+  return join(skilllibHome(), "library");
+}
+function claudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(userHome(), ".claude");
+}
+var PROJECT_SKILLS_DIR = ".claude/skills";
+var AGENTS_SKILLS_DIR = ".agents/skills";
+var MANIFEST_FILE = "skilllib.json";
+
+// src/harnesses.ts
+import { existsSync } from "fs";
+import { delimiter, join as join2 } from "path";
+var home = userHome;
+var HARNESSES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    short: "CC",
+    icon: "\u273B",
+    color: "#D97757",
+    projectDirs: [".claude/skills"],
+    globalDirs: () => [join2(claudeDir(), "skills")],
+    installed: () => existsSync(claudeDir()) || onPath("claude") || hasApp("Claude")
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    short: "Cu",
+    icon: "\u2B21",
+    color: "#E8E8E8",
+    projectDirs: [".agents/skills", ".cursor/skills", ".claude/skills", ".codex/skills"],
+    globalDirs: () => [join2(home(), ".agents", "skills"), join2(home(), ".cursor", "skills"), join2(claudeDir(), "skills"), join2(home(), ".codex", "skills")],
+    installed: () => existsSync(join2(home(), ".cursor")) || onPath("cursor-agent") || hasApp("Cursor")
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    short: "Cx",
+    icon: "\u25CE",
+    color: "#10A37F",
+    projectDirs: [".agents/skills"],
+    globalDirs: () => [join2(home(), ".agents", "skills"), "/etc/codex/skills"],
+    installed: () => existsSync(join2(home(), ".codex")) || onPath("codex") || hasApp("Codex")
+  },
+  {
+    id: "zed",
+    name: "Zed",
+    short: "Zd",
+    icon: "\u2124",
+    color: "#4A9EFF",
+    projectDirs: [".agents/skills"],
+    globalDirs: () => [join2(home(), ".agents", "skills")],
+    installed: () => existsSync(join2(home(), ".config", "zed")) || onPath("zed") || hasApp("Zed")
+  }
+];
+function onPath(bin) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  return (process.env.PATH ?? "").split(delimiter).some((dir) => dir && exts.some((ext) => existsSync(join2(dir, bin + ext))));
+}
+function hasApp(name) {
+  return process.platform === "darwin" && [join2("/Applications", `${name}.app`), join2(home(), "Applications", `${name}.app`)].some(existsSync);
+}
+function harness(id) {
+  return HARNESSES.find((h) => h.id === id);
+}
+var ALL_PROJECT_DIRS = [...new Set(HARNESSES.flatMap((h) => h.projectDirs))];
+function installDirs(enabled) {
+  const needsAgents = enabled.some((id) => !harness(id).projectDirs.includes(".claude/skills"));
+  return needsAgents ? [".claude/skills", ".agents/skills"] : [".claude/skills"];
+}
+
+// src/config.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6, resolve as resolve2 } from "path";
+
+// src/project.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname, join as join5, resolve } from "path";
+
+// src/versions.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join4 } from "path";
+
+// src/skills.ts
+import { createHash } from "crypto";
+import { cpSync, existsSync as existsSync2, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "fs";
+import { basename, join as join3, relative, sep as sep2 } from "path";
+import { parse as parseYaml } from "yaml";
+var IGNORED = /* @__PURE__ */ new Set([".DS_Store", ".git", "node_modules"]);
+function readSkillInfo(dir) {
+  const skillMd = join3(dir, "SKILL.md");
+  const fallback = { name: basename(dir), description: "" };
+  if (!existsSync2(skillMd)) return fallback;
+  const match = readFileSync(skillMd, "utf-8").match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return fallback;
+  try {
+    const fm = parseYaml(match[1]);
+    return {
+      name: typeof fm?.name === "string" && fm.name ? fm.name : fallback.name,
+      description: typeof fm?.description === "string" ? fm.description.trim() : ""
+    };
+  } catch {
+    return fallback;
+  }
+}
+function isSkillDir(dir) {
+  return existsSync2(join3(dir, "SKILL.md"));
+}
+function listFiles(dir) {
+  return readdirSync(dir).filter((entry) => !IGNORED.has(entry)).flatMap((entry) => {
+    const full = join3(dir, entry);
+    return statSync(full).isDirectory() ? listFiles(full) : [full];
+  });
+}
+function treeHash(dir) {
+  if (!existsSync2(dir)) return null;
+  const hash = createHash("sha256");
+  const files = listFiles(dir).map((f) => ({ path: relative(dir, f).split(sep2).join("/"), full: f })).sort((a, b) => a.path.localeCompare(b.path));
+  for (const file of files) {
+    hash.update(file.path).update("\0").update(createHash("sha256").update(readFileSync(file.full)).digest("hex")).update("\n");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function copySkill(from, to) {
+  rmSync(to, { recursive: true, force: true });
+  cpSync(realpathSync(from), to, { recursive: true, dereference: true, filter: (src) => !IGNORED.has(basename(src)) });
+}
+function skillDirsIn(dir) {
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((d) => (d.isDirectory() || d.isSymbolicLink()) && isSkillDir(join3(dir, d.name))).map((d) => join3(dir, d.name)).sort();
+}
+
+// src/versions.ts
+function storeDir(name) {
+  return join4(skilllibHome(), "store", name);
+}
+function indexFile(name) {
+  return join4(storeDir(name), "versions.json");
+}
+function versionHistory(name) {
+  try {
+    return JSON.parse(readFileSync2(indexFile(name), "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function versionDir(name, version) {
+  return join4(storeDir(name), String(version));
+}
+var latestCache = /* @__PURE__ */ new Map();
+function forgetLatest(name) {
+  if (name) latestCache.delete(name);
+  else latestCache.clear();
+}
+function latestVersion(name) {
+  if (latestCache.has(name)) return latestCache.get(name) ?? null;
+  const source = join4(libraryDir(), name);
+  const hash = treeHash(source);
+  let result = null;
+  if (hash) {
+    const history = versionHistory(name);
+    const last = history[history.length - 1];
+    if (last?.hash === hash && existsSync3(versionDir(name, last.version))) {
+      result = last;
+    } else {
+      const next = { version: (last?.version ?? 0) + 1, hash, date: (/* @__PURE__ */ new Date()).toISOString() };
+      mkdirSync(storeDir(name), { recursive: true });
+      copySkill(source, versionDir(name, next.version));
+      writeFileSync(indexFile(name), JSON.stringify([...history, next], null, 2) + "\n");
+      result = next;
+    }
+  }
+  latestCache.set(name, result);
+  return result;
+}
+function versionForHash(name, hash) {
+  return [...versionHistory(name)].reverse().find((v) => v.hash === hash) ?? null;
+}
+function getVersion(name, version) {
+  return versionHistory(name).find((v) => v.version === version) ?? null;
+}
+
+// src/project.ts
+function findProjectRoot(from = process.cwd()) {
+  let dir = resolve(from);
+  let gitRoot = null;
+  while (true) {
+    if (existsSync4(join5(dir, MANIFEST_FILE))) return dir;
+    if (!gitRoot && existsSync4(join5(dir, ".git"))) gitRoot = dir;
+    const parent = dirname(dir);
+    if (parent === dir) return gitRoot ?? resolve(from);
+    dir = parent;
+  }
+}
+function projectSkillsDir(root) {
+  return join5(root, PROJECT_SKILLS_DIR);
+}
+function agentsSkillsDir(root) {
+  return join5(root, AGENTS_SKILLS_DIR);
+}
+function readManifest(root) {
+  const path = join5(root, MANIFEST_FILE);
+  if (!existsSync4(path)) return { skills: {} };
+  const data = JSON.parse(readFileSync3(path, "utf-8"));
+  const skills = Object.fromEntries(
+    Object.entries(data.skills ?? {}).flatMap(([name, value]) => {
+      if (name.startsWith("@")) return [];
+      if (typeof value === "string") return [[name, { version: versionForHash(name, value)?.version ?? 0, hash: value }]];
+      if (value && typeof value === "object" && "hash" in value) {
+        const dep = value;
+        return [
+          [
+            name,
+            {
+              version: Number(dep.version ?? 0),
+              hash: String(dep.hash),
+              ...typeof dep.dir === "string" ? { dir: dep.dir } : {},
+              ...Array.isArray(dep.links) ? { links: dep.links.map(String) } : {}
+            }
+          ]
+        ];
+      }
+      return [];
+    })
+  );
+  return { ...data, skills };
+}
+function writeManifest(root, manifest) {
+  const skills = Object.fromEntries(Object.entries(manifest.skills).sort(([a], [b]) => a.localeCompare(b)));
+  writeFileSync2(join5(root, MANIFEST_FILE), JSON.stringify({ ...manifest, skills }, null, 2) + "\n");
+}
+function projectsFile() {
+  return join5(skilllibHome(), "projects.json");
+}
+function knownProjects() {
+  const path = projectsFile();
+  if (!existsSync4(path)) return [];
+  const list2 = JSON.parse(readFileSync3(path, "utf-8"));
+  return list2.filter((p) => existsSync4(p) && isProjectCandidate(p));
+}
+function isProjectCandidate(root) {
+  return resolve(root) !== homedir3();
+}
+function rememberProjects(roots) {
+  const incoming = roots.map((r) => resolve(r)).filter(isProjectCandidate);
+  const all = [.../* @__PURE__ */ new Set([...knownProjects(), ...incoming])].sort();
+  mkdirSync2(skilllibHome(), { recursive: true });
+  writeFileSync2(projectsFile(), JSON.stringify(all, null, 2) + "\n");
+}
+
+// src/config.ts
+function configFile() {
+  return join6(skilllibHome(), "config.json");
+}
+function readConfig() {
+  try {
+    const data = JSON.parse(readFileSync4(configFile(), "utf-8"));
+    return { ...data, roots: data.roots ?? [], hidden: data.hidden ?? [] };
+  } catch {
+    return { roots: [], hidden: [] };
+  }
+}
+function writeConfig(config) {
+  mkdirSync3(skilllibHome(), { recursive: true });
+  writeFileSync3(configFile(), JSON.stringify(config, null, 2) + "\n");
+}
+function expandHome(path) {
+  return resolve2(path.replace(/^~(?=$|\/)/, homedir4()));
+}
+function addRoot(path) {
+  const root = expandHome(path);
+  const config = readConfig();
+  if (!config.roots.includes(root)) writeConfig({ ...config, roots: [...config.roots, root].sort() });
+  return root;
+}
+function removeRoot(path) {
+  const root = expandHome(path);
+  const config = readConfig();
+  if (!config.roots.includes(root)) return false;
+  writeConfig({ ...config, roots: config.roots.filter((r) => r !== root) });
+  return true;
+}
+function setHidden(project, hidden) {
+  const config = readConfig();
+  const rest = config.hidden.filter((h) => h !== project);
+  writeConfig({ ...config, hidden: hidden ? [...rest, project].sort() : rest });
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "vendor", "target", "Library", "Applications", "Pictures", "Music", "Movies"]);
+function findProjects(dir, depth = 4) {
+  if (depth < 0 || !existsSync5(dir)) return [];
+  if (isProjectCandidate(dir)) {
+    const isRepo = existsSync5(join6(dir, ".git"));
+    const hasSkills = ALL_PROJECT_DIRS.some((d) => skillDirsIn(join6(dir, d)).length > 0) || existsSync5(join6(dir, MANIFEST_FILE));
+    if (isRepo || hasSkills) return [dir];
+  }
+  let entries = [];
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !SKIP_DIRS.has(d.name)).map((d) => join6(dir, d.name));
+  } catch {
+    return [];
+  }
+  return entries.flatMap((e) => findProjects(e, depth - 1));
+}
+function discoverProjects() {
+  const { roots } = readConfig();
+  rememberProjects(roots.flatMap((r) => findProjects(r)));
+  return visibleProjects();
+}
+function visibleProjects() {
+  const hidden = new Set(readConfig().hidden);
+  return knownProjects().filter((p) => !hidden.has(p));
+}
+function enabledHarnesses() {
+  return readConfig().harnesses ?? HARNESSES.filter((h) => h.installed()).map((h) => h.id);
+}
+function harnessesChosen() {
+  return readConfig().harnesses !== void 0;
+}
+function setHarnesses(ids) {
+  writeConfig({ ...readConfig(), harnesses: HARNESSES.map((h) => h.id).filter((id) => ids.includes(id)) });
+}
+function allowTrackedLinks(root) {
+  const config = readConfig();
+  writeConfig({ ...config, agentsDirOk: [.../* @__PURE__ */ new Set([...config.agentsDirOk ?? [], root])].sort() });
+}
+
+// src/sources.ts
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, join as join7, resolve as resolve3 } from "path";
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function skillsShLock() {
+  return readJson(join7(resolve3(claudeDir(), ".."), ".agents", ".skill-lock.json"))?.skills ?? {};
+}
+function realpathOrNull(path) {
+  try {
+    return realpathSync2(path);
+  } catch {
+    return null;
+  }
+}
+function harnessesReading(dir, enabled) {
+  return enabled.filter((id) => HARNESSES.find((h) => h.id === id)?.globalDirs().includes(dir));
+}
+function globalSkillDirs() {
+  return [...new Set(HARNESSES.flatMap((h) => h.globalDirs()))].filter((d) => d.startsWith(userHome()));
+}
+function globalFolderSkills(enabled) {
+  const lock = skillsShLock();
+  const agentsDir = join7(userHome(), ".agents", "skills");
+  const entries = globalSkillDirs().flatMap((dir) => {
+    if (!existsSync6(dir)) return [];
+    return readdirSync3(dir).filter((name) => !name.startsWith(".") && name !== "synced").flatMap((name) => {
+      const path = join7(dir, name);
+      const isLink2 = lstatSync(path).isSymbolicLink();
+      const broken = !existsSync6(join7(path, "SKILL.md"));
+      if (!isLink2 && broken) return [];
+      return [{ dir, name, path, isLink: isLink2, broken, real: realpathOrNull(path) }];
+    });
+  });
+  const realOf = new Map(entries.filter((e) => !e.isLink && e.real).map((e) => [e.real, e]));
+  const linksTo = /* @__PURE__ */ new Map();
+  const skills = [];
+  for (const e of entries) {
+    const target = e.isLink && e.real ? realOf.get(e.real) : void 0;
+    if (target) {
+      linksTo.set(target.path, [...linksTo.get(target.path) ?? [], e]);
+      continue;
+    }
+    const target_ = e.isLink ? readlinkSync(e.path) : "";
+    const inAgents = e.dir === agentsDir || target_.includes(".agents/skills");
+    const locked = lock[e.name]?.source;
+    skills.push({
+      name: e.name,
+      kind: locked || e.isLink && inAgents ? "skills.sh" : "global",
+      origin: locked ?? (e.isLink && inAgents ? "skills.sh (not in its lock file)" : e.isLink ? `link \u2192 ${target_}` : `${tildify2(e.dir)} (origin unknown)`),
+      path: e.path,
+      description: e.broken ? "" : readSkillInfo(e.path).description,
+      movable: true,
+      broken: e.broken,
+      harnesses: e.broken ? [] : harnessesReading(e.dir, enabled),
+      links: []
+    });
+  }
+  for (const skill of skills) {
+    const links = linksTo.get(skill.path) ?? [];
+    skill.links = links.map((l) => l.path);
+    const reading = /* @__PURE__ */ new Set([...skill.harnesses, ...links.flatMap((l) => harnessesReading(l.dir, enabled))]);
+    skill.harnesses = enabled.filter((id) => reading.has(id));
+  }
+  return skills;
+}
+function tildify2(p) {
+  return p.startsWith(userHome()) ? "~" + p.slice(userHome().length) : p;
+}
+function cursorBuiltInSkills(enabled) {
+  if (!enabled.includes("cursor")) return [];
+  return skillDirsIn(join7(userHome(), ".cursor", "skills-cursor")).map((path) => ({
+    name: basename2(path),
+    kind: "built-in",
+    origin: "Cursor",
+    path,
+    description: readSkillInfo(path).description,
+    movable: false,
+    broken: false,
+    harnesses: ["cursor"],
+    links: []
+  }));
+}
+function claudeAiSkills() {
+  const synced = join7(claudeDir(), "skills", "synced");
+  if (!existsSync6(synced)) return [];
+  return readdirSync3(synced).filter((d) => !d.startsWith(".")).flatMap(
+    (bucket) => skillDirsIn(join7(synced, bucket)).map((path) => ({
+      name: basename2(path),
+      kind: "claude.ai",
+      origin: "claude.ai account",
+      path,
+      description: readSkillInfo(path).description,
+      movable: false,
+      broken: false,
+      harnesses: ["claude-code"],
+      links: []
+    }))
+  );
+}
+function pluginSkills() {
+  const plugins = join7(claudeDir(), "plugins");
+  const enabled = readJson(join7(claudeDir(), "settings.json"))?.enabledPlugins ?? {};
+  const installed = readJson(join7(plugins, "installed_plugins.json"))?.plugins ?? {};
+  const fromMarketplaces = Object.entries(enabled).filter(([, on]) => on).flatMap(([id]) => {
+    const [name = "", marketplace = ""] = id.split("@");
+    const candidates = [
+      ...(installed[id] ?? []).flatMap((i) => i.installPath ? [i.installPath] : []),
+      join7(plugins, "marketplaces", marketplace, "plugins", name),
+      join7(plugins, "marketplaces", marketplace, "external_plugins", name),
+      join7(plugins, "marketplaces", marketplace)
+    ];
+    const root = candidates.find((c) => existsSync6(join7(c, "skills")));
+    return root ? skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: id })) : [];
+  });
+  const syncedDir = join7(plugins, "synced");
+  const fromSynced = existsSync6(syncedDir) ? readdirSync3(syncedDir).filter((b) => !b.startsWith(".")).flatMap(
+    (bucket) => readdirSync3(join7(syncedDir, bucket), { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => {
+      const root = join7(syncedDir, bucket, d.name);
+      const name = readJson(join7(root, ".claude-plugin", "plugin.json"))?.name ?? d.name;
+      return skillDirsIn(join7(root, "skills")).map((path) => ({ path, origin: `${name} (claude.ai)` }));
+    })
+  ) : [];
+  return [...fromMarketplaces, ...fromSynced].map(({ path, origin }) => ({
+    name: basename2(path),
+    kind: "plugin",
+    origin,
+    path,
+    description: readSkillInfo(path).description,
+    movable: false,
+    broken: false,
+    harnesses: ["claude-code"],
+    links: []
+  }));
+}
+function machineSkills(enabled = enabledHarnesses()) {
+  const claude = enabled.includes("claude-code");
+  return [
+    ...globalFolderSkills(enabled),
+    ...claude ? claudeAiSkills() : [],
+    ...claude ? pluginSkills() : [],
+    ...cursorBuiltInSkills(enabled)
+  ].sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+  );
+}
+function originsFile() {
+  return join7(skilllibHome(), "origins.json");
+}
+function libraryOrigins() {
+  return readJson(originsFile()) ?? {};
+}
+function recordOrigin(name, origin) {
+  const origins = libraryOrigins();
+  if (origins[name] === origin) return;
+  mkdirSync4(skilllibHome(), { recursive: true });
+  writeFileSync4(originsFile(), JSON.stringify({ ...origins, [name]: origin }, null, 2) + "\n");
+}
+function originFor(dir) {
+  const match = machineSkills().find((s) => resolve3(s.path) === resolve3(dir));
+  if (match) return match.kind === "global" ? "global folder" : `${match.kind}: ${match.origin}`;
+  const project = dir.split(/[\\/]\.(?:claude|agents)[\\/]skills[\\/]/)[0];
+  return project && project !== dir ? `project: ${basename2(project)}` : dir;
+}
+
+// src/library.ts
+function librarySkills() {
+  return skillDirsIn(libraryDir()).map((dir) => ({
+    name: basename3(dir),
+    description: readSkillInfo(dir).description,
+    dir,
+    hash: treeHash(dir) ?? ""
+  }));
+}
+function librarySkillDir(name) {
+  return join8(libraryDir(), name);
+}
+function realpathOrNull2(path) {
+  try {
+    return realpathSync3(path);
+  } catch {
+    return null;
+  }
+}
+function isLink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function linkDir(target, link2) {
+  if (process.platform === "win32") symlinkSync(target, link2, "junction");
+  else symlinkSync(relative2(dirname2(link2), target), link2);
+}
+function entryExists(path) {
+  return isLink(path) || existsSync7(path);
+}
+function visibilityOf(root, name, enabled = enabledHarnesses()) {
+  return enabled.map((id) => ({
+    id,
+    paths: harness(id).projectDirs.filter((dir) => existsSync7(join8(root, dir, name, "SKILL.md"))).length
+  }));
+}
+function dependencyDirs(dep) {
+  const wanted = installDirs(enabledHarnesses());
+  if (!dep) return wanted;
+  const primary = dep.dir ?? PROJECT_SKILLS_DIR;
+  return [primary, .../* @__PURE__ */ new Set([...dep.links ?? [], ...wanted.filter((d) => d !== primary)])];
+}
+function isGitTracked(root, dir) {
+  try {
+    const out = execFileSync("git", ["ls-files", "--", dir], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function projectStatus(root) {
+  const { skills } = readManifest(root);
+  const enabled = enabledHarnesses();
+  const managed = Object.entries(skills).map(([name, dep]) => {
+    const location = dep.dir ?? PROJECT_SKILLS_DIR;
+    const path = join8(root, location, name);
+    const local = treeHash(path);
+    const latest = latestVersion(name);
+    const edited = local !== dep.hash;
+    const behind = latest !== null && latest.hash !== dep.hash && latest.version > dep.version;
+    const state = local === null ? "folder missing" : latest === null ? "not in library" : local === latest.hash ? "ok" : edited && behind ? "edited locally, update available" : edited ? "edited locally" : behind ? "update available" : "ok";
+    return {
+      name,
+      managed: true,
+      state,
+      version: dep.version || null,
+      latest: latest?.version ?? null,
+      location,
+      path,
+      visibility: visibilityOf(root, name, enabled)
+    };
+  });
+  const seen = new Set(Object.keys(skills));
+  const unmanaged = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of ALL_PROJECT_DIRS) {
+    for (const path of skillDirsIn(join8(root, dir))) {
+      const name = basename3(path);
+      if (seen.has(name)) continue;
+      byName.set(name, [...byName.get(name) ?? [], path]);
+    }
+  }
+  for (const [name, paths] of byName) {
+    const real = paths.find((p) => !isLink(p)) ?? paths[0];
+    const location = relative2(root, join8(real, "..")).split(sep3).join("/");
+    const latest = latestVersion(name);
+    const local = treeHash(real);
+    const sameAsLibrary = latest !== null && (latest.hash === local || versionForHash(name, local ?? "") !== null);
+    const committed = location === AGENTS_SKILLS_DIR;
+    const state = committed ? latest === null ? "repo skill" : sameAsLibrary ? "repo skill, in library" : "repo skill, differs from library" : latest === null ? "local only" : sameAsLibrary ? "untracked copy of library skill" : "untracked, differs from library";
+    unmanaged.push({
+      name,
+      managed: false,
+      state,
+      version: null,
+      latest: latest?.version ?? null,
+      location,
+      path: real,
+      visibility: visibilityOf(root, name, enabled)
+    });
+  }
+  return [...managed, ...unmanaged].sort((a, b) => a.name.localeCompare(b.name));
+}
+function linkEverywhere(root, name, location, { allowTracked = false } = {}) {
+  const enabled = enabledHarnesses();
+  const result = { created: [], blocked: [] };
+  for (const id of enabled) {
+    if (visibilityOf(root, name, [id])[0].paths > 0) continue;
+    const dir = harness(id).projectDirs[0];
+    const link2 = join8(root, dir, name);
+    if (entryExists(link2)) continue;
+    if (!allowTracked && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
+      result.blocked.push(dir);
+      continue;
+    }
+    mkdirSync5(join8(root, dir), { recursive: true });
+    linkDir(join8(root, location, name), link2);
+    result.created.push(dir);
+  }
+  return result;
+}
+function unlinkEverywhere(root, name) {
+  return ALL_PROJECT_DIRS.filter((dir) => {
+    const link2 = join8(root, dir, name);
+    if (!isLink(link2)) return false;
+    unlinkSync(link2);
+    return true;
+  });
+}
+function relinkDependency(root, name, { allowTracked = false } = {}) {
+  const manifest = readManifest(root);
+  const dep = manifest.skills[name];
+  if (!dep) return { created: [], blocked: [] };
+  const result = linkEverywhere(root, name, dep.dir ?? PROJECT_SKILLS_DIR, { allowTracked });
+  if (result.created.length) {
+    manifest.skills[name] = { ...dep, links: [.../* @__PURE__ */ new Set([...dep.links ?? [], ...result.created])] };
+    writeManifest(root, manifest);
+  }
+  return result;
+}
+function linkAll(root, { allowTracked = false } = {}) {
+  const linked = [];
+  const blocked = /* @__PURE__ */ new Set();
+  for (const skill of projectStatus(root)) {
+    if (!skill.visibility.some((v) => v.paths === 0) || skill.state === "folder missing") continue;
+    const res = skill.managed ? relinkDependency(root, skill.name, { allowTracked }) : linkEverywhere(root, skill.name, skill.location, { allowTracked });
+    if (res.created.length) linked.push({ name: skill.name, into: res.created });
+    for (const dir of res.blocked) blocked.add(dir);
+  }
+  return { linked, blocked: [...blocked] };
+}
+function addSkill(root, name, { force = false, version, allowTracked = false } = {}) {
+  const target = version === void 0 ? latestVersion(name) : getVersion(name, version);
+  if (!target) return { name, action: "skipped", reason: version === void 0 ? "not in the library" : `version ${version} doesn't exist` };
+  const manifest = readManifest(root);
+  const recorded = manifest.skills[name];
+  const [primary = PROJECT_SKILLS_DIR, ...linkDirs] = dependencyDirs(recorded);
+  const to = join8(root, primary, name);
+  const local = isLink(to) && !recorded ? null : treeHash(to);
+  const knownContent = local !== null && (local === recorded?.hash || versionForHash(name, local) !== null);
+  if (local !== null && local !== target.hash && !knownContent && !force) {
+    return {
+      name,
+      action: "skipped",
+      reason: recorded ? "has local edits (use --force to overwrite, or save them to the library first)" : `${primary}/${name} already exists with different content (use --force to replace it)`
+    };
+  }
+  if (local !== target.hash || isLink(to)) {
+    mkdirSync5(join8(root, primary), { recursive: true });
+    if (isLink(to)) unlinkSync(to);
+    copySkill(versionDir(name, target.version), to);
+  }
+  const links = [];
+  const blocked = [];
+  for (const dir of linkDirs) {
+    const link2 = join8(root, dir, name);
+    if (isLink(link2) && realpathOrNull2(link2) === realpathOrNull2(to)) {
+      links.push(dir);
+      continue;
+    }
+    if (entryExists(link2)) continue;
+    if (!allowTracked && !recorded?.links?.includes(dir) && isGitTracked(root, dir) && !readConfig().agentsDirOk?.includes(root)) {
+      blocked.push(dir);
+      continue;
+    }
+    mkdirSync5(join8(root, dir), { recursive: true });
+    linkDir(to, link2);
+    links.push(dir);
+  }
+  manifest.skills[name] = {
+    version: target.version,
+    hash: target.hash,
+    ...primary !== PROJECT_SKILLS_DIR ? { dir: primary } : {},
+    ...links.length ? { links } : {}
+  };
+  writeManifest(root, manifest);
+  return {
+    name,
+    action: recorded || local !== null ? "updated" : "installed",
+    ...recorded ? { from: recorded.version } : {},
+    to: target.version,
+    ...blocked.length ? { blocked } : {}
+  };
+}
+function removeSkill(root, name, { force = false } = {}) {
+  const manifest = readManifest(root);
+  const recorded = manifest.skills[name];
+  if (!recorded) return { name, action: "skipped", reason: "not managed by skilllib in this project" };
+  const dir = join8(root, recorded.dir ?? PROJECT_SKILLS_DIR, name);
+  const local = treeHash(dir);
+  if (local !== null && local !== recorded.hash && !versionForHash(name, local) && !force) {
+    return { name, action: "skipped", reason: "has local edits (use --force to delete anyway)" };
+  }
+  for (const linkDir2 of recorded.links ?? []) {
+    const link2 = join8(root, linkDir2, name);
+    if (isLink(link2)) unlinkSync(link2);
+  }
+  rmSync2(dir, { recursive: true, force: true });
+  delete manifest.skills[name];
+  writeManifest(root, manifest);
+  return { name, action: "removed" };
+}
+function syncProject(root, { force = false } = {}) {
+  const { skills } = readManifest(root);
+  return Object.entries(skills).flatMap(([name, dep]) => {
+    const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
+    const linksOk = (dep.links ?? []).every((d) => existsSync7(join8(root, d, name, "SKILL.md")));
+    if (local === dep.hash && linksOk) return [];
+    const pinned = dep.version > 0 && getVersion(name, dep.version) ? dep.version : void 0;
+    if (local !== null && local !== dep.hash && !force) return [{ name, action: "skipped", reason: "has local edits (use --force to reset them)" }];
+    const change = addSkill(root, name, { force: true, version: pinned });
+    return change.action === "skipped" ? [change] : [{ ...change, action: local === null ? "installed" : "updated" }];
+  });
+}
+function updateProject(root, names, { force = false } = {}) {
+  const { skills } = readManifest(root);
+  return Object.keys(skills).filter((name) => !names || names.includes(name)).flatMap((name) => {
+    const latest = latestVersion(name);
+    if (!latest) return [{ name, action: "skipped", reason: "no longer in the library" }];
+    const dep = skills[name];
+    const local = treeHash(join8(root, dep.dir ?? PROJECT_SKILLS_DIR, name));
+    if (dep.hash === latest.hash && local === latest.hash) return [];
+    const change = addSkill(root, name, { force });
+    return change.action === "skipped" || change.from !== change.to || local !== latest.hash ? [change] : [];
+  });
+}
+function importSkill(dir, { force = false } = {}) {
+  const name = basename3(dir);
+  const to = librarySkillDir(name);
+  const existing = treeHash(to);
+  const incoming = treeHash(dir);
+  if (existing === incoming) return { name, status: "unchanged" };
+  if (existing !== null && !force) return { name, status: "exists" };
+  mkdirSync5(libraryDir(), { recursive: true });
+  const origin = originFor(dir);
+  copySkill(dir, to);
+  recordOrigin(name, origin);
+  forgetLatest(name);
+  latestVersion(name);
+  return { name, status: existing === null ? "added" : "updated" };
+}
+function backupIndexFile(bucket) {
+  return join8(skilllibHome(), bucket, "index.json");
+}
+function readBackupIndex(bucket) {
+  try {
+    return JSON.parse(readFileSync6(backupIndexFile(bucket), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function stash(dir, bucket) {
+  let at = Date.now();
+  const entryAt = (ms) => `${basename3(dir)}-${new Date(ms).toISOString().replace(/[:.]/g, "-")}`;
+  while (entryExists(join8(skilllibHome(), bucket, entryAt(at)))) at++;
+  const entry = entryAt(at);
+  const target = join8(skilllibHome(), bucket, entry);
+  mkdirSync5(join8(skilllibHome(), bucket), { recursive: true });
+  renameSync(dir, target);
+  writeFileSync5(backupIndexFile(bucket), JSON.stringify({ ...readBackupIndex(bucket), [entry]: dir }, null, 2) + "\n");
+  return target;
+}
+function projectsUsing(name) {
+  return knownProjects().filter((p) => name in readManifest(p).skills);
+}
+function deleteLibrarySkill(name) {
+  const using = projectsUsing(name);
+  if (using.length > 0) return { ok: false, reason: `still installed in ${using.map((p) => basename3(p)).join(", ")}` };
+  const dir = librarySkillDir(name);
+  if (!existsSync7(dir)) return { ok: false, reason: "not in the library" };
+  forgetLatest(name);
+  return { ok: true, movedTo: stash(dir, "trash") };
+}
+function deleteGlobal(path, links = []) {
+  return unloadGlobal(path, links, { requireLibrary: false });
+}
+function unloadGlobal(path, links = [], { requireLibrary = true } = {}) {
+  const name = basename3(path);
+  if (!entryExists(path) || name === "synced") return { ok: false, reason: "not a global skill" };
+  const broken = !existsSync7(join8(path, "SKILL.md"));
+  if (requireLibrary && !broken && latestVersion(name) === null) return { ok: false, reason: "import it into the library first" };
+  for (const link2 of links) if (isLink(link2)) stash(link2, "global-backup");
+  return { ok: true, movedTo: stash(path, "global-backup") };
+}
+function createSkill(name, description) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) return { ok: false, reason: "use lowercase letters, digits and dashes" };
+  const dir = librarySkillDir(name);
+  if (existsSync7(dir)) return { ok: false, reason: `${name} already exists` };
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(
+    join8(dir, "SKILL.md"),
+    `---
+name: ${name}
+description: ${description || "Describe when Claude should use this skill."}
+---
+
+# ${name}
+
+Instructions for Claude go here.
+`
+  );
+  forgetLatest(name);
+  return { ok: true, dir };
+}
+function listBackups() {
+  return ["trash", "global-backup"].flatMap((kind) => {
+    const dir = join8(skilllibHome(), kind);
+    if (!existsSync7(dir)) return [];
+    const index = readBackupIndex(kind);
+    return readdirSync4(dir).flatMap((entry) => {
+      const match = entry.match(/^(.*)-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-\d{3}Z$/);
+      if (!match) return [];
+      const name = match[1];
+      const from = index[entry] ?? (kind === "trash" ? librarySkillDir(name) : join8(claudeDir(), "skills", name));
+      return [{ name, kind, path: join8(dir, entry), movedAt: `${match[2]} ${match[3]}:${match[4]}`, from }];
+    });
+  }).sort((a, b) => b.movedAt.localeCompare(a.movedAt));
+}
+function restoreBackup(backup) {
+  const to = backup.from;
+  let taken = existsSync7(to);
+  try {
+    taken = taken || lstatSync2(to) !== null;
+  } catch {
+  }
+  if (taken) return { ok: false, reason: `${backup.name} already exists there` };
+  mkdirSync5(join8(to, ".."), { recursive: true });
+  renameSync(backup.path, to);
+  forgetLatest(backup.name);
+  return { ok: true, to };
+}
+
+// src/usage.ts
+import { createReadStream, existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join9 } from "path";
+import { createInterface } from "readline";
+var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
+  "add-dir",
+  "agents",
+  "bug",
+  "clear",
+  "compact",
+  "config",
+  "context",
+  "cost",
+  "doctor",
+  "exit",
+  "export",
+  "fast",
+  "feedback",
+  "goal",
+  "help",
+  "hooks",
+  "ide",
+  "init",
+  "install-github-app",
+  "login",
+  "logout",
+  "mcp",
+  "memory",
+  "model",
+  "output-style",
+  "permissions",
+  "plugin",
+  "pr-comments",
+  "privacy-settings",
+  "release-notes",
+  "resume",
+  "rewind",
+  "status",
+  "statusline",
+  "terminal-setup",
+  "todos",
+  "upgrade",
+  "usage",
+  "vim"
+]);
+function skillNameFromPath(filePath) {
+  const match = filePath.replace(/\\/g, "/").match(/\/\.(?:claude|agents)\/skills\/([^/]+)\//);
+  return match ? match[1] : null;
+}
+function usesFromTranscriptLine(line) {
+  if (!line.includes('"Skill"') && !line.includes("<command-name>") && !line.includes("/skills/")) return [];
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const cwd = record.cwd ?? "";
+  const at = record.timestamp ?? "";
+  const content = record.message?.content;
+  if (record.type === "assistant" && Array.isArray(content)) {
+    return content.flatMap((block) => {
+      if (!block || typeof block !== "object" || block.type !== "tool_use") return [];
+      const key = String(block.id);
+      if (block.name === "Skill" && typeof block.input?.skill === "string") {
+        return [{ skill: block.input.skill, source: "invoked", cwd, at, key }];
+      }
+      if (block.name === "Read" && typeof block.input?.file_path === "string") {
+        const skill = skillNameFromPath(block.input.file_path);
+        return skill ? [{ skill, source: "file read", cwd, at, key }] : [];
+      }
+      return [];
+    });
+  }
+  if (record.type === "user" && typeof content === "string") {
+    const match = content.match(/<command-name>\/?([\w.:-]+)<\/command-name>/);
+    if (!match || BUILTIN_COMMANDS.has(match[1])) return [];
+    return [{ skill: match[1], source: "slash", cwd, at, key: record.uuid ?? `${at}:${match[1]}` }];
+  }
+  return [];
+}
+function transcriptFiles(sinceMs) {
+  const base = join9(claudeDir(), "projects");
+  if (!existsSync8(base)) return [];
+  return readdirSync5(base).flatMap((project) => {
+    const dir = join9(base, project);
+    if (!statSync2(dir).isDirectory()) return [];
+    return readdirSync5(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join9(dir, f)).filter((f) => statSync2(f).mtimeMs >= sinceMs);
+  });
+}
+async function scanUsage(days) {
+  const sinceMs = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of transcriptFiles(sinceMs)) {
+    const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+    for await (const line of lines) {
+      for (const use of usesFromTranscriptLine(line)) {
+        if (Date.parse(use.at) >= sinceMs) seen.set(use.key, use);
+      }
+    }
+  }
+  return [...seen.values()];
+}
+function summarize(uses, projectOf = () => null) {
+  const bySkill = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const summary = bySkill.get(use.skill) ?? { skill: use.skill, uses: 0, lastUsed: "", projects: /* @__PURE__ */ new Set() };
+    summary.uses += 1;
+    if (use.at > summary.lastUsed) summary.lastUsed = use.at;
+    const project = projectOf(use.cwd);
+    if (project) summary.projects.add(project);
+    bySkill.set(use.skill, summary);
+  }
+  return [...bySkill.values()].sort((a, b) => b.uses - a.uses);
+}
+
+// src/health.ts
+import { basename as basename4, join as join10 } from "path";
+function findIssues(projects2, machine, libraryNames, statusOf = projectStatus) {
+  const issues = [];
+  for (const skill of machine.filter((m) => m.broken)) {
+    issues.push({
+      id: `broken:${skill.name}`,
+      severity: "problem",
+      title: `${skill.name}: broken link in ${skill.path.replace(/\/[^/]+$/, "").replace(/^\/Users\/[^/]+/, "~")}`,
+      detail: "It points at a folder that no longer exists, so it loads nothing.",
+      fix: {
+        label: "Remove the link",
+        run: () => {
+          const r = unloadGlobal(skill.path);
+          return r.ok ? `Removed broken link ${skill.name}` : `${skill.name}: ${r.reason}`;
+        }
+      }
+    });
+  }
+  const loaded = machine.filter((m) => !m.broken);
+  const byName = /* @__PURE__ */ new Map();
+  for (const m of loaded) byName.set(m.name, [...byName.get(m.name) ?? [], m]);
+  for (const [name, copies] of byName) {
+    const harnesses = HARNESSES.filter((h) => copies.filter((c) => c.harnesses.includes(h.id)).length > 1).map((h) => h.name);
+    if (harnesses.length === 0) continue;
+    const movable = copies.find((c) => c.movable);
+    issues.push({
+      id: `dup:${name}`,
+      severity: "problem",
+      title: `${name}: loaded twice in ${harnesses.join(" and ")}`,
+      detail: copies.map((c) => `${c.kind} (${c.origin})`).join(" and "),
+      fix: movable && copies.some((c) => !c.movable) ? {
+        label: "Keep the vendor copy, stop loading yours globally",
+        run: () => {
+          if (!libraryNames.has(name)) importSkill(movable.path);
+          const r = unloadGlobal(movable.path, movable.links);
+          return r.ok ? `${name} now loads once` : `${name}: ${r.reason}`;
+        }
+      } : void 0
+    });
+  }
+  const globalNames = new Set(loaded.map((m) => m.name));
+  for (const root of projects2) {
+    const where = basename4(root);
+    const status2 = statusOf(root);
+    const behind = status2.filter((s) => s.state === "update available" || s.state === "folder missing");
+    if (behind.length > 0) {
+      issues.push({
+        id: `sync:${root}`,
+        severity: "problem",
+        title: `${where}: ${behind.length} skill${behind.length === 1 ? "" : "s"} out of date`,
+        detail: behind.map((s) => s.name).join(", "),
+        fix: {
+          label: "Sync the project",
+          run: () => {
+            const changes = syncProject(root);
+            return `${where}: ${changes.filter((c) => c.action !== "skipped").length} updated`;
+          }
+        }
+      });
+    }
+    for (const s of status2) {
+      if (s.state === "local only") {
+        issues.push({
+          id: `local:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name}: only exists in ${where}`,
+          detail: "Import it into the library to reuse it in other projects and keep it backed up.",
+          fix: {
+            label: "Import into the library",
+            run: () => {
+              importSkill(join10(projectSkillsDir(root), s.name));
+              addSkill(root, s.name);
+              return `${s.name} imported and tracked in ${where}`;
+            }
+          }
+        });
+      } else if (s.state === "untracked copy of library skill") {
+        issues.push({
+          id: `adopt:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name} in ${where} isn't tracked`,
+          detail: "It's identical to the library copy; track it so future library changes reach it.",
+          fix: { label: "Track it", run: () => `${addSkill(root, s.name).name} tracked in ${where}` }
+        });
+      }
+      if (globalNames.has(s.name) && s.managed) {
+        issues.push({
+          id: `twice:${root}:${s.name}`,
+          severity: "suggestion",
+          title: `${s.name}: in ${where} and also loaded globally`,
+          detail: "The project copy is enough; the global one loads it in every other project too.",
+          fix: machine.some((m) => m.name === s.name && m.movable) ? {
+            label: "Stop loading it globally",
+            run: () => {
+              const g = machine.find((m) => m.name === s.name && m.movable);
+              if (!libraryNames.has(s.name)) importSkill(g.path);
+              const r = unloadGlobal(g.path, g.links);
+              return r.ok ? `${s.name} no longer loads globally` : `${s.name}: ${r.reason}`;
+            }
+          } : void 0
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/commands.ts
+var USAGE_DAYS = 30;
+function parseArgs(argv) {
+  const daysIdx = argv.indexOf("--days");
+  const days = daysIdx >= 0 ? Number(argv[daysIdx + 1]) : USAGE_DAYS;
+  return {
+    positional: argv.filter((a, i) => !a.startsWith("--") && argv[i - 1] !== "--days"),
+    force: argv.includes("--force"),
+    all: argv.includes("--all"),
+    global: argv.includes("--global"),
+    fix: argv.includes("--fix"),
+    allowTracked: argv.includes("--allow-tracked"),
+    days: Number.isFinite(days) && days > 0 ? days : USAGE_DAYS
+  };
+}
+function colorState(state) {
+  if (state === "ok") return green(state);
+  if (state === "folder missing" || state === "not in library") return red(state);
+  if (state === "local only") return dim(state);
+  return yellow(state);
+}
+function printChanges(changes) {
+  for (const c of changes) {
+    if (c.blocked?.length) {
+      warn(`${c.name}: git tracks ${c.blocked.join(", ")} here, so no link was added there. Re-run with --allow-tracked to add it.`);
+    }
+    if (c.action === "skipped") warn(`${c.name}: ${c.reason}`);
+    else {
+      const icon = c.action === "removed" ? red("-") : green(c.action === "installed" ? "+" : "\u2191");
+      const versions = c.action === "removed" ? "" : c.from && c.from !== c.to ? ` v${c.from} \u2192 v${c.to}` : c.to ? ` v${c.to}` : "";
+      info(`  ${icon} ${c.name}${versions} ${dim(c.action)}`);
+    }
+  }
+}
+function projectOfFactory(projects2) {
+  const sorted = [...projects2].sort((a, b) => b.length - a.length);
+  return (cwd) => {
+    if (!cwd) return null;
+    const known = sorted.find((p) => cwd === p || cwd.startsWith(p + sep4));
+    if (known) return known;
+    const repo = cwd.split(`${sep4}.claude${sep4}worktrees${sep4}`)[0];
+    return isProjectCandidate(repo) ? repo : null;
+  };
+}
+async function usageBySkill(days, onlyProject) {
+  const projectOf = projectOfFactory(onlyProject ? [onlyProject, ...knownProjects()] : knownProjects());
+  const uses = await scanUsage(days);
+  const scoped = onlyProject ? uses.filter((u) => projectOf(u.cwd) === onlyProject) : uses;
+  return new Map(summarize(scoped, projectOf).map((s) => [s.skill, s]));
+}
+function lastUsed(summary) {
+  return summary ? summary.lastUsed.slice(0, 10) : "-";
+}
+async function status(args) {
+  const root = findProjectRoot();
+  const skills = projectStatus(root);
+  info(`${basename5(root)} ${dim(tildify(root))}
+`);
+  if (skills.length === 0) {
+    info("No skills in this project yet. Add one from your library with: skilllib add <name>");
+    return;
+  }
+  const usage2 = await usageBySkill(args.days, root);
+  table(
+    skills.map((s) => ({
+      Skill: s.name,
+      Status: colorState(s.state),
+      [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0),
+      "Last used": lastUsed(usage2.get(s.name))
+    }))
+  );
+  const states = new Set(skills.map((s) => s.state));
+  const hints = [];
+  if (states.has("update available")) hints.push("`skilllib update` to install the newest versions");
+  if (states.has("folder missing")) hints.push("`skilllib sync` to restore missing skills");
+  if (states.has("edited locally") || states.has("edited locally, update available"))
+    hints.push("`skilllib import .claude/skills/<name> --force` to save local edits to the library");
+  if (states.has("local only")) hints.push("`skilllib import .claude/skills/<name>` to add a local skill to the library");
+  if (states.has("untracked copy of library skill") || states.has("untracked, differs from library"))
+    hints.push("`skilllib add <name>` to manage an untracked skill (--force if it differs)");
+  if (hints.length > 0) info("\n" + hints.map((h) => dim(`\u2192 ${h}`)).join("\n"));
+  rememberProjects([root]);
+}
+async function list(args) {
+  const skills = librarySkills();
+  if (skills.length === 0) {
+    info(`Your library (${tildify(libraryDir())}) is empty.`);
+    info("Import skills with `skilllib import <skill-dir>`, or find existing ones with `skilllib scan ~/Projects`.");
+  } else {
+    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) ?? [], basename5(project)]);
+      }
+    }
+    const usage2 = await usageBySkill(args.days);
+    const origins = libraryOrigins();
+    info(`Library ${dim(tildify(libraryDir()))}
+`);
+    table(
+      skills.map((s) => ({
+        Skill: s.name,
+        Description: truncate(s.description, 50),
+        From: dim(truncate(origins[s.name] ?? "", 30)),
+        Projects: (installs.get(s.name) ?? []).join(", ") || dim("none"),
+        [`Uses (${args.days}d)`]: String(usage2.get(s.name)?.uses ?? 0)
+      }))
+    );
+  }
+  const libraryNames = new Set(skills.map((s) => s.name));
+  const globals = machineSkills().filter((m) => m.movable && !m.broken);
+  if (globals.length > 0) {
+    info("");
+    warn(`${globals.length} of your global skill(s) still load in every project`);
+    const missing = globals.filter((g) => !libraryNames.has(g.name));
+    info(
+      dim(
+        missing.length > 0 ? `\u2192 \`skilllib import --global\` copies ${missing.length} of them into the library` : "\u2192 all are in your library; run `skilllib` \u2192 Global skills to stop loading them everywhere"
+      )
+    );
+  }
+}
+function projects() {
+  const roots = visibleProjects();
+  if (roots.length === 0) {
+    info("No known projects. Run `skilllib scan <dir>` to find them, or `skilllib add` inside one.");
+    return;
+  }
+  table(
+    roots.map((root) => {
+      const skills = projectStatus(root);
+      const managed = skills.filter((s) => s.managed);
+      const attention = skills.filter((s) => s.state !== "ok" && s.state !== "local only").length;
+      return {
+        Project: basename5(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),
+        Status: attention === 0 ? green("ok") : yellow(`${attention} need attention`)
+      };
+    })
+  );
+}
+function add(args) {
+  if (args.positional.length === 0) {
+    error("Usage: skilllib add <skill-name>... [--force]");
+    process.exit(1);
+  }
+  const root = findProjectRoot();
+  if (args.allowTracked) allowTrackedLinks(root);
+  printChanges(args.positional.map((name) => addSkill(root, name, { force: args.force })));
+  rememberProjects([root]);
+}
+function remove(args) {
+  if (args.positional.length === 0) {
+    error("Usage: skilllib remove <skill-name>... [--force]");
+    process.exit(1);
+  }
+  const root = findProjectRoot();
+  printChanges(args.positional.map((name) => removeSkill(root, name, { force: args.force })));
+}
+function sync(args) {
+  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  for (const root of roots) {
+    if (args.allowTracked) allowTrackedLinks(root);
+    const changes = syncProject(root, { force: args.force });
+    if (args.all) info(`${basename5(root)} ${dim(tildify(root))}`);
+    if (changes.length === 0) success("Installed versions match skilllib.json");
+    else printChanges(changes);
+  }
+  if (!args.all) rememberProjects(roots);
+}
+function update(args) {
+  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  for (const root of roots) {
+    if (args.allowTracked) allowTrackedLinks(root);
+    const changes = updateProject(root, args.positional.length ? args.positional : void 0, { force: args.force });
+    if (args.all) info(`${basename5(root)} ${dim(tildify(root))}`);
+    if (changes.length === 0) success("Everything is on the latest version");
+    else printChanges(changes);
+  }
+}
+function outdated(args) {
+  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  const rows = roots.flatMap(
+    (root) => projectStatus(root).filter((s) => s.managed && s.latest !== null && s.version !== null && s.latest > s.version).map((s) => ({ Project: basename5(root), Skill: s.name, Installed: `v${s.version}`, Latest: `v${s.latest}`, Status: colorState(s.state) }))
+  );
+  if (rows.length === 0) return success("Everything is on the latest version");
+  table(rows);
+  info(dim(`
+\u2192 skilllib update${args.all ? " --all" : ""}`));
+}
+function importSkills(args) {
+  const dirs = args.global ? machineSkills().filter((m) => m.movable && !m.broken).map((m) => m.path) : args.positional.map((p) => resolve4(p));
+  if (dirs.length === 0) {
+    error("Usage: skilllib import <skill-dir>... [--force] | skilllib import --global");
+    process.exit(1);
+  }
+  for (const dir of dirs) {
+    if (!isSkillDir(dir)) {
+      warn(`${tildify(dir)}: no SKILL.md, skipping`);
+      continue;
+    }
+    const { name, status: result } = importSkill(dir, { force: args.force });
+    if (result === "exists") {
+      warn(`${name}: the library already has a different version (use --force to replace it)`);
+      continue;
+    }
+    success(`${name} ${dim(result === "unchanged" ? "already in library" : result === "added" ? "added to library" : "library updated")}`);
+    const skillsDir = resolve4(dir, "..");
+    const root = resolve4(skillsDir, "..", "..");
+    if (skillsDir === join11(root, ".claude", "skills") && isProjectCandidate(root)) {
+      if (readManifest(root).skills[name]?.hash !== treeHash(dir)) {
+        const change = addSkill(root, name);
+        if (change.action !== "skipped") info(dim(`  ${basename5(root)} now depends on ${name} v${change.to}`));
+      }
+      rememberProjects([root]);
+    }
+  }
+}
+function scan(args) {
+  for (const p of args.positional) addRoot(p);
+  const { roots } = readConfig();
+  if (roots.length === 0) {
+    info("No project folders yet. Run `skilllib scan ~/Projects` (or wherever your repos live).");
+    return;
+  }
+  const found = discoverProjects();
+  const library = new Set(librarySkills().map((s) => s.name));
+  const skillNames = (root) => [...skillDirsIn(projectSkillsDir(root)), ...skillDirsIn(agentsSkillsDir(root))].map((d) => basename5(d));
+  const withSkills = found.filter((root) => skillNames(root).length > 0);
+  info(`Scanned ${roots.map((r) => tildify(r)).join(", ")}: ${found.length} project(s), ${withSkills.length} with skills
+`);
+  table(
+    withSkills.map((root) => ({
+      Project: basename5(root),
+      Path: dim(tildify(root)),
+      Skills: [...new Set(skillNames(root))].map((n) => library.has(n) ? n : yellow(n)).join(", ")
+    }))
+  );
+  if (withSkills.length > 0) info(`
+${yellow("Yellow")} skills aren't in your library yet (import them from \`skilllib\` \u2192 3 Sources or 5 Health).`);
+}
+function folders(args) {
+  const [action, ...paths] = args.positional;
+  if (action === "add") {
+    for (const p of paths) success(`Added ${tildify(addRoot(p))}`);
+    discoverProjects();
+  } else if (action === "remove" || action === "rm") {
+    for (const p of paths) {
+      if (removeRoot(p)) success(`Removed ${tildify(expandHome(p))}`);
+      else warn(`${tildify(expandHome(p))} wasn't a project folder`);
+    }
+  }
+  const { roots, hidden } = readConfig();
+  info(roots.length ? `Project folders:
+${roots.map((r) => `  ${tildify(r)}`).join("\n")}` : "No project folders. Add one: skilllib folders add ~/Projects");
+  if (hidden.length) info(dim(`Hidden projects: ${hidden.map((h) => tildify(h)).join(", ")}  (skilllib unhide <path>)`));
+}
+function unhide(args) {
+  for (const p of args.positional) {
+    setHidden(expandHome(p), false);
+    success(`${tildify(expandHome(p))} is visible again`);
+  }
+}
+function newSkill(args) {
+  const [name, ...rest] = args.positional;
+  if (!name) {
+    error("Usage: skilllib new <name> [description]");
+    process.exit(1);
+  }
+  const r = createSkill(name, rest.join(" "));
+  if (!r.ok) {
+    error(`Can't create ${name}: ${r.reason}`);
+    process.exit(1);
+  }
+  success(`Created ${tildify(join11(r.dir, "SKILL.md"))}`);
+}
+function restore(args) {
+  const backups = listBackups();
+  const name = args.positional[0];
+  if (!name) {
+    if (backups.length === 0) return info("Nothing to restore.");
+    table(backups.map((b) => ({ Skill: b.name, From: b.kind === "trash" ? "library (deleted)" : "~/.claude/skills", Moved: b.movedAt })));
+    info(dim("\n\u2192 skilllib restore <name>"));
+    return;
+  }
+  const backup = backups.find((b) => b.name === name);
+  if (!backup) {
+    error(`No backup named ${name}`);
+    process.exit(1);
+  }
+  const r = restoreBackup(backup);
+  if (r.ok) success(`Restored ${name} to ${tildify(r.to)}`);
+  else error(`Can't restore ${name}: ${r.reason}`);
+}
+function doctor(args) {
+  const projects2 = visibleProjects();
+  const issues = findIssues(projects2, machineSkills(), new Set(librarySkills().map((s) => s.name)));
+  if (issues.length === 0) return success("Everything looks good");
+  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 (args.fix && issue.fix) info(`  ${green("\u2713")} ${issue.fix.run()}`);
+  }
+  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 5 Health."));
+}
+async function usage(args) {
+  const summaries = summarize(await scanUsage(args.days), projectOfFactory(knownProjects()));
+  if (summaries.length === 0) {
+    info(`No skill usage in Claude Code transcripts from the last ${args.days} days.`);
+    return;
+  }
+  const library = new Set(librarySkills().map((s) => s.name));
+  info(`Skill usage, last ${args.days} days ${dim(`(from ${tildify(join11(claudeDir(), "projects"))})`)}
+`);
+  table(
+    summaries.map((s) => ({
+      Skill: s.skill,
+      Uses: String(s.uses),
+      Projects: [...s.projects].map((p) => basename5(p)).join(", ") || dim("-"),
+      "Last used": lastUsed(s),
+      Library: library.has(s.skill) ? green("yes") : dim("no")
+    }))
+  );
+  const unused = librarySkills().filter((s) => !summaries.some((u) => u.skill === s.name));
+  if (unused.length > 0) {
+    info("");
+    warn(`Library skills unused in the last ${args.days} days: ${unused.map((s) => s.name).join(", ")}`);
+  }
+}
+function show(args) {
+  const name = args.positional[0];
+  const dir = name ? join11(libraryDir(), name) : "";
+  if (!name || !isSkillDir(dir)) {
+    error(name ? `${name} is not in the library` : "Usage: skilllib show <skill-name>");
+    process.exit(1);
+  }
+  const { description } = readSkillInfo(dir);
+  info(`${name} ${dim(tildify(dir))}`);
+  if (description) info(`
+${description}`);
+  const using = knownProjects().filter((p) => name in readManifest(p).skills);
+  info(`
+Installed in: ${using.map((p) => tildify(p)).join(", ") || "no projects"}`);
+}
+function harnessesCommand(args) {
+  const ids = HARNESSES.map((h) => h.id);
+  if (args.positional.length) {
+    const unknown = args.positional.filter((p) => !ids.includes(p));
+    if (unknown.length) {
+      error(`Unknown harness: ${unknown.join(", ")}. Choose from: ${ids.join(", ")}`);
+      process.exit(1);
+    }
+    setHarnesses(args.positional);
+    success(`Using ${args.positional.join(", ")}`);
+  }
+  const enabled = enabledHarnesses();
+  for (const h of HARNESSES) {
+    info(`${enabled.includes(h.id) ? green("\u25C9") : dim("\u25CB")} ${h.name.padEnd(12)} ${dim(`reads ${h.projectDirs.join(", ")}${h.installed() ? " \xB7 detected" : ""}`)}`);
+  }
+  info(dim(`
+New installs go to ${installDirs(enabled).join(" (real copy) + ")}${installDirs(enabled).length > 1 ? " (link)" : ""}.`));
+}
+function link(args) {
+  const roots = args.all ? visibleProjects() : [findProjectRoot()];
+  for (const root of roots) {
+    if (args.allowTracked) allowTrackedLinks(root);
+    const res = linkAll(root);
+    const label = args.all ? `${basename5(root)}: ` : "";
+    if (res.linked.length) success(`${label}linked ${res.linked.length} skill(s) for your other agents`);
+    else if (!args.all) success("Every skill here is already usable by all your agents");
+    if (res.blocked.length) warn(`${label}git tracks ${res.blocked.join(", ")}; re-run with --allow-tracked to link there too`);
+  }
+}
+
+export {
+  userHome,
+  skilllibHome,
+  MANIFEST_FILE,
+  HARNESSES,
+  ALL_PROJECT_DIRS,
+  installDirs,
+  readSkillInfo,
+  versionHistory,
+  forgetLatest,
+  latestVersion,
+  findProjectRoot,
+  isProjectCandidate,
+  readConfig,
+  addRoot,
+  removeRoot,
+  setHidden,
+  discoverProjects,
+  visibleProjects,
+  enabledHarnesses,
+  harnessesChosen,
+  setHarnesses,
+  allowTrackedLinks,
+  machineSkills,
+  libraryOrigins,
+  librarySkills,
+  librarySkillDir,
+  visibilityOf,
+  projectStatus,
+  linkEverywhere,
+  unlinkEverywhere,
+  relinkDependency,
+  linkAll,
+  addSkill,
+  removeSkill,
+  syncProject,
+  updateProject,
+  importSkill,
+  projectsUsing,
+  deleteLibrarySkill,
+  deleteGlobal,
+  unloadGlobal,
+  createSkill,
+  listBackups,
+  restoreBackup,
+  error,
+  scanUsage,
+  summarize,
+  findIssues,
+  parseArgs,
+  projectOfFactory,
+  status,
+  list,
+  projects,
+  add,
+  remove,
+  sync,
+  update,
+  outdated,
+  importSkills,
+  scan,
+  folders,
+  unhide,
+  newSkill,
+  restore,
+  doctor,
+  usage,
+  show,
+  harnessesCommand,
+  link
+};