skill-master 0.1.4 → 0.1.6

package/dist/cli.js

@@ -111,6 +111,12 @@ var SkillParseError = class extends SkillManagerError {
     this.name = "SkillParseError";
   }
 };
+var SourceParseError = class extends SkillManagerError {
+  constructor(source, detail) {
+    super(`Failed to parse source "${source}"${detail ? ": " + detail : ""}`);
+    this.name = "SourceParseError";
+  }
+};
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -152,20 +158,89 @@ function tableRow(...cols) {
 
 // src/core/git-source.ts
 var execFileAsync = promisify(execFile);
+function parseSource(source) {
+  if (source.startsWith("git@") || source.startsWith("git://")) {
+    return { type: "git", url: source };
+  }
+  if (source.startsWith("https://") || source.startsWith("http://")) {
+    const ghTree = source.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.+))?/);
+    if (ghTree) {
+      const url = `https://github.com/${ghTree[1]}/${ghTree[2]}.git`;
+      return { type: "git", url, ref: ghTree[3], subpath: ghTree[4] };
+    }
+    const ghBlob = source.match(/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)/);
+    if (ghBlob) {
+      const url = `https://github.com/${ghBlob[1]}/${ghBlob[2]}.git`;
+      const filePath = ghBlob[4];
+      const subpath = filePath.includes("/") ? filePath.slice(0, filePath.lastIndexOf("/")) : void 0;
+      return { type: "git", url, ref: ghBlob[3], subpath };
+    }
+    const glTree = source.match(/gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)(?:\/(.+))?/);
+    if (glTree) {
+      const url = `https://gitlab.com/${glTree[1]}/${glTree[2]}.git`;
+      return { type: "git", url, ref: glTree[3], subpath: glTree[4] };
+    }
+    if (source.includes("github.com/") || source.includes("gitlab.com/")) {
+      return { type: "git", url: source };
+    }
+    return { type: "git", url: source };
+  }
+  if (source.includes("github.com/") || source.includes("gitlab.com/")) {
+    return parseSource("https://" + source);
+  }
+  if (existsSync2(source) || source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
+    return { type: "local", path: source };
+  }
+  let skillFilter;
+  let shorthand = source;
+  const atIdx = shorthand.indexOf("@");
+  if (atIdx > 0 && !shorthand.includes("/") === false) {
+    const lastAt = shorthand.lastIndexOf("@");
+    if (lastAt > 0) {
+      const afterAt = shorthand.slice(lastAt + 1);
+      const beforeAt = shorthand.slice(0, lastAt);
+      if (afterAt && !afterAt.includes("/")) {
+        skillFilter = afterAt;
+        shorthand = beforeAt;
+      }
+    }
+  }
+  if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(shorthand)) {
+    return {
+      type: "git",
+      url: `https://github.com/${shorthand}.git`,
+      skillFilter
+    };
+  }
+  const segments = shorthand.split("/");
+  if (segments.length >= 3 && /^[a-zA-Z0-9_.-]+$/.test(segments[0]) && /^[a-zA-Z0-9_.-]+$/.test(segments[1])) {
+    const owner = segments[0];
+    const repo = segments[1];
+    const subpath = segments.slice(2).join("/");
+    return {
+      type: "git",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath,
+      skillFilter
+    };
+  }
+  throw new SourceParseError(source, "Unable to determine source type");
+}
 function isGitUrl(source) {
-  return source.startsWith("https://") || source.startsWith("http://") || source.startsWith("git@") || source.startsWith("git://") || source.includes("github.com/") || source.includes("gitlab.com/") || /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(source);
+  try {
+    return parseSource(source).type === "git";
+  } catch {
+    return false;
+  }
 }
 function normalizeGitUrl(source) {
-  if (source.startsWith("https://") || source.startsWith("http://") || source.startsWith("git@") || source.startsWith("git://")) {
-    if (source.startsWith("https://") && !source.endsWith(".git")) {
-      return source + ".git";
-    }
-    return source;
+  const parsed = parseSource(source);
+  if (parsed.type !== "git" || !parsed.url) return source;
+  let url = parsed.url;
+  if (url.startsWith("https://") && !url.endsWith(".git")) {
+    url += ".git";
   }
-  if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(source)) {
-    return `https://github.com/${source}.git`;
-  }
-  return source;
+  return url;
 }
 function parseGitUrl(url) {
   const treeMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/(.+)/);
@@ -261,8 +336,20 @@ function inferCapabilities(allowedTools) {
   return [...caps];
 }
 async function findSkillDirectory(dir) {
+  const dirs = await findAllSkillDirectories(dir);
+  return dirs.length > 0 ? dirs[0] : null;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build"]);
+async function findAllSkillDirectories(dir, fullDepth = false) {
+  if (fullDepth) {
+    const results2 = /* @__PURE__ */ new Set();
+    await walkForSkills(dir, 0, 5, results2);
+    return [...results2];
+  }
+  const results = [];
   if (existsSync3(join2(dir, "SKILL.md"))) {
-    return dir;
+    results.push(dir);
+    return results;
   }
   const skillsRoot = join2(dir, ".claude", "skills");
   if (existsSync3(skillsRoot)) {
@@ -272,7 +359,7 @@ async function findSkillDirectory(dir) {
         if (entry.isDirectory()) {
           const skillMdPath = join2(skillsRoot, entry.name, "SKILL.md");
           if (existsSync3(skillMdPath)) {
-            return join2(skillsRoot, entry.name);
+            results.push(join2(skillsRoot, entry.name));
           }
         }
       }
@@ -285,13 +372,28 @@ async function findSkillDirectory(dir) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         const skillMdPath = join2(dir, entry.name, "SKILL.md");
         if (existsSync3(skillMdPath)) {
-          return join2(dir, entry.name);
+          results.push(join2(dir, entry.name));
         }
       }
     }
   } catch {
   }
-  return null;
+  return results;
+}
+async function walkForSkills(dir, depth, maxDepth, results) {
+  if (depth > maxDepth) return;
+  if (existsSync3(join2(dir, "SKILL.md"))) {
+    results.add(dir);
+  }
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name)) {
+        await walkForSkills(join2(dir, entry.name), depth + 1, maxDepth, results);
+      }
+    }
+  } catch {
+  }
 }
 async function readSkillMd(dir) {
   const content = await readTextSafe(join2(dir, "SKILL.md"));
@@ -606,6 +708,9 @@ function detectPlatform(cwd) {
 function getAgentSkillPath(cwd, agent, name) {
   return join3(cwd, AGENTS[agent].skillsDir, name);
 }
+function getAgentGlobalSkillPath(agent, name) {
+  return join3(AGENTS[agent].globalSkillsDir, name);
+}
 
 // src/utils/paths.ts
 var AGENTS_HOME = join4(homedir2(), ".agents");
@@ -720,12 +825,38 @@ function getEnvEditPath(skillName) {
 // src/core/registry.ts
 import { existsSync as existsSync5 } from "fs";
 function createEmptyRegistry() {
-  return { version: 1, skills: {} };
+  return { version: 2, skills: {} };
+}
+function migrateEntryV1(v1) {
+  return {
+    source: v1.source,
+    version: v1.version,
+    installed_at: v1.installed_at,
+    updated_at: v1.updated_at,
+    agents: [{
+      agent: v1.agent,
+      agent_path: v1.agent_path,
+      global: v1.agent_path.includes("/.agents/") || v1.agent_path.includes("\\.agents\\")
+    }],
+    env_keys: v1.env_keys,
+    capabilities: v1.capabilities,
+    canonical_path: v1.canonical_path
+  };
 }
-function validateRegistry(data) {
-  if (!data || typeof data !== "object") return false;
+function validateAndMigrate(data) {
+  if (!data || typeof data !== "object") return null;
   const reg = data;
-  return reg.version === 1 && typeof reg.skills === "object" && reg.skills !== null;
+  if (typeof reg.skills !== "object" || reg.skills === null) return null;
+  if (reg.version === 2) return data;
+  if (reg.version === 1) {
+    const v1Skills = reg.skills;
+    const v2Skills = {};
+    for (const [name, entry] of Object.entries(v1Skills)) {
+      v2Skills[name] = migrateEntryV1(entry);
+    }
+    return { version: 2, skills: v2Skills };
+  }
+  return null;
 }
 async function readRegistry() {
   if (!existsSync5(REGISTRY_PATH)) {
@@ -735,14 +866,46 @@ async function readRegistry() {
   if (!data) {
     throw new RegistryCorruptError("Failed to parse registry.json");
   }
-  if (!validateRegistry(data)) {
+  const registry = validateAndMigrate(data);
+  if (!registry) {
     throw new RegistryCorruptError("Invalid registry structure");
   }
-  return data;
+  if (data.version !== registry.version) {
+    await atomicWriteJson(REGISTRY_PATH, registry);
+  }
+  return registry;
 }
 async function updateRegistry(skillName, entry) {
   const registry = await readRegistry();
-  registry.skills[skillName] = entry;
+  const existing = registry.skills[skillName];
+  if (existing) {
+    for (const newAgent of entry.agents) {
+      const idx = existing.agents.findIndex((a) => a.agent === newAgent.agent);
+      if (idx >= 0) {
+        existing.agents[idx] = newAgent;
+      } else {
+        existing.agents.push(newAgent);
+      }
+    }
+    existing.source = entry.source;
+    existing.version = entry.version;
+    existing.updated_at = entry.updated_at;
+    existing.env_keys = entry.env_keys;
+    existing.capabilities = entry.capabilities;
+    existing.canonical_path = entry.canonical_path;
+  } else {
+    registry.skills[skillName] = entry;
+  }
+  await atomicWriteJson(REGISTRY_PATH, registry);
+}
+async function removeAgentFromRegistry(skillName, agent) {
+  const registry = await readRegistry();
+  const entry = registry.skills[skillName];
+  if (!entry) return;
+  entry.agents = entry.agents.filter((a) => a.agent !== agent);
+  if (entry.agents.length === 0) {
+    delete registry.skills[skillName];
+  }
   await atomicWriteJson(REGISTRY_PATH, registry);
 }
 async function removeFromRegistry(skillName) {
@@ -762,7 +925,7 @@ async function getRegistryEntry(skillName) {
 // src/core/installer.ts
 var TOTAL_STEPS = 9;
 async function installSkill(options) {
-  const { source, cwd, copy = false, force = false } = options;
+  const { source, cwd, copy = false, force = false, global: isGlobal = false } = options;
   step(1, TOTAL_STEPS, "Fetching skill source...");
   let sourceDir;
   if (source.type === "git") {
@@ -791,7 +954,7 @@ async function installSkill(options) {
   const agent = options.agent ?? detectPlatform(cwd);
   info(`Target platform: ${agent}`);
   step(5, TOTAL_STEPS, "Backing up .env...");
-  const agentSkillDir = getAgentSkillPath(cwd, agent, skillName);
+  const agentSkillDir = isGlobal ? getAgentGlobalSkillPath(agent, skillName) : getAgentSkillPath(cwd, agent, skillName);
   const envBackup = await backupEnv(skillName, agentSkillDir);
   if (envBackup) {
     success(`Backed up ${Object.keys(envBackup).length} env key(s)`);
@@ -817,7 +980,7 @@ async function installSkill(options) {
     }
   }
   step(8, TOTAL_STEPS, `Linking to ${agent} skills directory...`);
-  const agentPath = getAgentSkillPath(cwd, agent, skillName);
+  const agentPath = isGlobal ? getAgentGlobalSkillPath(agent, skillName) : getAgentSkillPath(cwd, agent, skillName);
   const linkType = await symlinkOrCopy(canonicalPath, agentPath, copy);
   success(`${linkType === "symlink" ? "Symlinked" : "Copied"} to ${agentPath}`);
   step(9, TOTAL_STEPS, "Updating registry...");
@@ -825,16 +988,20 @@ async function installSkill(options) {
   const envExampleContent = await readTextSafe(join6(canonicalPath, ".env.example"));
   const envKeys = envExampleContent ? extractEnvKeys(envExampleContent) : [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const agentInstall = {
+    agent,
+    agent_path: agentPath,
+    global: isGlobal
+  };
   const entry = {
     source: source.type === "git" ? source.url : source.path,
     version: parsed.frontmatter.version,
     installed_at: now,
     updated_at: now,
-    agent,
+    agents: [agentInstall],
     env_keys: envKeys,
     capabilities,
-    canonical_path: canonicalPath,
-    agent_path: agentPath
+    canonical_path: canonicalPath
   };
   await updateRegistry(skillName, entry);
   blank();
@@ -842,6 +1009,8 @@ async function installSkill(options) {
 }
 
 // src/commands/add.ts
+import { existsSync as existsSync7 } from "fs";
+import { basename as basename2, join as join7 } from "path";
 function parseAddFlags(args) {
   const flags = {
     global: false,
@@ -852,7 +1021,8 @@ function parseAddFlags(args) {
     all: false,
     fullDepth: false,
     copy: false,
-    force: false
+    force: false,
+    help: false
   };
   let source = null;
   let i = 0;
@@ -870,12 +1040,17 @@ function parseAddFlags(args) {
           flags.skill.push(val);
           break;
         default:
-          break;
+          throw new Error(`Unknown option: --${key}`);
       }
       i++;
       continue;
     }
     switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        i++;
+        break;
       case "-g":
       case "--global":
         flags.global = true;
@@ -926,6 +1101,8 @@ function parseAddFlags(args) {
       default:
         if (!arg.startsWith("-") && source === null) {
           source = arg;
+        } else if (arg.startsWith("-")) {
+          throw new Error(`Unknown option: ${arg}`);
         }
         i++;
         break;
@@ -938,40 +1115,117 @@ function parseAddFlags(args) {
   }
   return { source, flags };
 }
+function printAddHelp() {
+  console.log("Usage: skill-master add <source> [options]");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help            Show this help message");
+  console.log("  -g, --global          Install globally (~/.agents/)");
+  console.log("  -a, --agent <agents>  Target agents (space-separated)");
+  console.log("  -s, --skill <skills>  Select skills (space-separated)");
+  console.log("  -y, --yes             Skip confirmations");
+  console.log("  -l, --list            List available skills without installing");
+  console.log("  --all                 Install all skills to all agents");
+  console.log("  --full-depth          Search all subdirectories");
+  console.log("  --copy                Copy instead of symlink");
+  console.log("  --force               Force reinstall");
+}
 async function add(args) {
   if (args.length === 0) {
-    error("Usage: skill-master add <source> [options]");
-    console.log("");
-    console.log("Options:");
-    console.log("  -g, --global          Install globally (~/.agents/)");
-    console.log("  -a, --agent <agents>  Target agents (space-separated)");
-    console.log("  -s, --skill <skills>  Select skills (space-separated)");
-    console.log("  -y, --yes             Skip confirmations");
-    console.log("  -l, --list            List available skills without installing");
-    console.log("  --all                 Install all skills to all agents");
-    console.log("  --full-depth          Search all subdirectories");
-    console.log("  --copy                Copy instead of symlink");
-    console.log("  --force               Force reinstall");
+    printAddHelp();
     process.exit(1);
   }
   const { source, flags } = parseAddFlags(args);
+  if (flags.help) {
+    printAddHelp();
+    process.exit(0);
+  }
   if (!source) {
     error("No source specified. Provide a GitHub URL, owner/repo, or local path.");
     process.exit(1);
   }
-  const skillSource = isGitUrl(source) ? { type: "git", url: source } : { type: "local", path: source };
   const cwd = process.cwd();
+  const parsed = parseSource(source);
+  if (parsed.skillFilter && !flags.skill.includes(parsed.skillFilter)) {
+    flags.skill.push(parsed.skillFilter);
+  }
+  let sourceDir;
+  if (parsed.type === "git") {
+    step(1, 9, "Fetching skill source...");
+    sourceDir = await cloneRepo(parsed.url, parsed.ref);
+    if (parsed.subpath) {
+      const sub = join7(sourceDir, parsed.subpath);
+      if (existsSync7(sub)) {
+        sourceDir = sub;
+      }
+    }
+  } else {
+    sourceDir = parsed.path;
+    if (!existsSync7(sourceDir)) {
+      throw new SkillNotFoundError(sourceDir);
+    }
+  }
+  const allSkillDirs = await findAllSkillDirectories(sourceDir, flags.fullDepth);
+  if (allSkillDirs.length === 0) {
+    throw new SkillNotFoundError(`No SKILL.md found in ${sourceDir}`);
+  }
+  if (flags.list) {
+    blank();
+    tableHeader("Skill", "Version", "Description");
+    for (const dir of allSkillDirs) {
+      const sk = await readSkillMd(dir);
+      if (sk) {
+        tableRow(
+          sk.frontmatter.name,
+          sk.frontmatter.version ?? "-",
+          sk.frontmatter.description ?? "-"
+        );
+      }
+    }
+    blank();
+    return;
+  }
+  let targetDirs = allSkillDirs;
+  if (flags.skill.length > 0 && !flags.skill.includes("*")) {
+    const requested = new Set(flags.skill.map((s) => s.toLowerCase()));
+    const filtered = [];
+    for (const dir of allSkillDirs) {
+      const sk = await readSkillMd(dir);
+      if (!sk) continue;
+      const name = sk.frontmatter.name.toLowerCase();
+      const dirName = basename2(dir).toLowerCase();
+      if (requested.has(name) || requested.has(dirName)) {
+        filtered.push(dir);
+      }
+    }
+    if (filtered.length === 0) {
+      const available = [];
+      for (const dir of allSkillDirs) {
+        const sk = await readSkillMd(dir);
+        if (sk) available.push(sk.frontmatter.name);
+      }
+      error(
+        `No matching skills found for: ${flags.skill.join(", ")}
+  Available skills: ${available.join(", ")}`
+      );
+      process.exit(1);
+    }
+    targetDirs = filtered;
+  }
   const agents = flags.agent.length > 0 ? flags.agent : [void 0];
   try {
-    for (const agent of agents) {
-      await installSkill({
-        source: skillSource,
-        agent,
-        cwd,
-        copy: flags.copy,
-        force: flags.force,
-        yes: flags.yes
-      });
+    for (const dir of targetDirs) {
+      for (const agent of agents) {
+        await installSkill({
+          source: { type: "local", path: dir },
+          agent,
+          cwd,
+          global: flags.global,
+          copy: flags.copy,
+          force: flags.force,
+          yes: flags.yes
+        });
+      }
     }
   } catch (err) {
     error(err.message);
@@ -995,12 +1249,15 @@ async function update(args) {
     info(`Updating skill: ${skillName}`);
     info(`Source: ${entry.source}`);
     const source = isGitUrl(entry.source) ? { type: "git", url: entry.source } : { type: "local", path: entry.source };
-    await installSkill({
-      source,
-      agent: entry.agent,
-      cwd: process.cwd(),
-      force: true
-    });
+    for (const agentRecord of entry.agents) {
+      await installSkill({
+        source,
+        agent: agentRecord.agent,
+        cwd: process.cwd(),
+        global: agentRecord.global,
+        force: true
+      });
+    }
     success(`Skill "${skillName}" updated successfully!`);
   } catch (err) {
     error(err.message);
@@ -1016,7 +1273,8 @@ function parseRemoveFlags(args) {
     skill: [],
     yes: false,
     all: false,
-    purge: false
+    purge: false,
+    help: false
   };
   const names = [];
   let i = 0;
@@ -1034,12 +1292,17 @@ function parseRemoveFlags(args) {
           flags.skill.push(val);
           break;
         default:
-          break;
+          throw new Error(`Unknown option: --${key}`);
       }
       i++;
       continue;
     }
     switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        i++;
+        break;
       case "-g":
       case "--global":
         flags.global = true;
@@ -1077,6 +1340,8 @@ function parseRemoveFlags(args) {
       default:
         if (!arg.startsWith("-")) {
           names.push(arg);
+        } else {
+          throw new Error(`Unknown option: ${arg}`);
         }
         i++;
         break;
@@ -1087,20 +1352,28 @@ function parseRemoveFlags(args) {
   }
   return { names, flags };
 }
+function printRemoveHelp() {
+  console.log("Usage: skill-master remove [skills...] [options]");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help            Show this help message");
+  console.log("  -g, --global          Remove from global (~/.agents/)");
+  console.log("  -a, --agent <agents>  Target agents (space-separated)");
+  console.log("  -s, --skill <skills>  Select skills (space-separated)");
+  console.log("  -y, --yes             Skip confirmations");
+  console.log("  --all                 Remove all skills");
+  console.log("  --purge               Also remove config data");
+}
 async function remove(args) {
   if (args.length === 0) {
-    error("Usage: skill-master remove [skills...] [options]");
-    console.log("");
-    console.log("Options:");
-    console.log("  -g, --global          Remove from global (~/.agents/)");
-    console.log("  -a, --agent <agents>  Target agents (space-separated)");
-    console.log("  -s, --skill <skills>  Select skills (space-separated)");
-    console.log("  -y, --yes             Skip confirmations");
-    console.log("  --all                 Remove all skills");
-    console.log("  --purge               Also remove config data");
+    printRemoveHelp();
     process.exit(1);
   }
   const { names, flags } = parseRemoveFlags(args);
+  if (flags.help) {
+    printRemoveHelp();
+    process.exit(0);
+  }
   let skillNames;
   if (flags.all) {
     const registry = await listRegistry();
@@ -1121,15 +1394,39 @@ async function remove(args) {
         throw new SkillNotFoundError(skillName);
       }
       info(`Removing skill: ${skillName}`);
-      await removePath(entry.agent_path);
-      success(`Removed from ${entry.agent_path}`);
-      await removePath(entry.canonical_path);
-      success(`Removed from ${entry.canonical_path}`);
-      if (flags.purge) {
-        await removePath(getSkillConfigPath(skillName));
-        success("Purged config directory");
+      if (flags.agent.length > 0) {
+        for (const agentName of flags.agent) {
+          const agentRecord = entry.agents.find((a) => a.agent === agentName);
+          if (!agentRecord) {
+            warn(`Agent "${agentName}" not found for skill "${skillName}"`);
+            continue;
+          }
+          await removePath(agentRecord.agent_path);
+          success(`Removed ${agentName} path: ${agentRecord.agent_path}`);
+          await removeAgentFromRegistry(skillName, agentName);
+        }
+        const updated = await getRegistryEntry(skillName);
+        if (!updated) {
+          await removePath(entry.canonical_path);
+          success(`Removed canonical path: ${entry.canonical_path}`);
+          if (flags.purge) {
+            await removePath(getSkillConfigPath(skillName));
+            success("Purged config directory");
+          }
+        }
+      } else {
+        for (const agentRecord of entry.agents) {
+          await removePath(agentRecord.agent_path);
+          success(`Removed ${agentRecord.agent} path: ${agentRecord.agent_path}`);
+        }
+        await removePath(entry.canonical_path);
+        success(`Removed canonical path: ${entry.canonical_path}`);
+        if (flags.purge) {
+          await removePath(getSkillConfigPath(skillName));
+          success("Purged config directory");
+        }
+        await removeFromRegistry(skillName);
       }
-      await removeFromRegistry(skillName);
       success(`Skill "${skillName}" removed successfully!`);
     }
   } catch (err) {
@@ -1255,17 +1552,20 @@ async function list(args = []) {
   const skills = await listRegistry();
   let entries = Object.entries(skills);
   if (flags.agent.length > 0) {
-    entries = entries.filter(([, entry]) => flags.agent.includes(entry.agent));
+    entries = entries.filter(
+      ([, entry]) => entry.agents.some((a) => flags.agent.includes(a.agent))
+    );
   }
   if (entries.length === 0) {
     info("No skills installed");
     return;
   }
   blank();
-  tableHeader("Skill", "Version", "Platform", "Installed");
+  tableHeader("Skill", "Version", "Platform(s)", "Installed");
   for (const [name, entry] of entries) {
     const date = new Date(entry.installed_at).toLocaleDateString();
-    tableRow(name, entry.version ?? "-", entry.agent, date);
+    const platforms = entry.agents.map((a) => a.agent).join(", ");
+    tableRow(name, entry.version ?? "-", platforms, date);
   }
   blank();
 }
@@ -1286,12 +1586,14 @@ async function info2(args) {
     blank();
     info(`Skill: ${skillName}`);
     kv("Version", entry.version ?? "-");
-    kv("Platform", entry.agent);
+    kv("Platform(s)", entry.agents.map((a) => a.agent).join(", "));
     kv("Source", entry.source);
     kv("Installed", new Date(entry.installed_at).toLocaleString());
     kv("Updated", new Date(entry.updated_at).toLocaleString());
     kv("Canonical Path", entry.canonical_path);
-    kv("Agent Path", entry.agent_path);
+    for (const a of entry.agents) {
+      kv(`  ${a.agent} Path`, `${a.agent_path}${a.global ? " (global)" : ""}`);
+    }
     kv("Capabilities", entry.capabilities.join(", "));
     kv("Env Keys", entry.env_keys.join(", ") || "none");
     kv("Env Status", envStatus);
@@ -1303,7 +1605,7 @@ async function info2(args) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 async function doctor() {
   blank();
   info("Running diagnostics...");
@@ -1312,7 +1614,7 @@ async function doctor() {
   info("Checking directory structure...");
   const dirs = [AGENTS_HOME, CONFIG_DIR, SKILLS_DIR];
   for (const dir of dirs) {
-    if (existsSync7(dir)) {
+    if (existsSync8(dir)) {
       success(`\u2713 ${dir}`);
     } else {
       warn(`\u2717 ${dir} (missing)`);
@@ -1321,7 +1623,7 @@ async function doctor() {
   }
   blank();
   info("Checking registry...");
-  if (existsSync7(REGISTRY_PATH)) {
+  if (existsSync8(REGISTRY_PATH)) {
     success(`\u2713 ${REGISTRY_PATH}`);
     try {
       const skills = await listRegistry();
@@ -1339,18 +1641,20 @@ async function doctor() {
     const skills = await listRegistry();
     for (const [name, entry] of Object.entries(skills)) {
       info(`Skill: ${name}`);
-      if (existsSync7(entry.canonical_path)) {
+      if (existsSync8(entry.canonical_path)) {
         success(`  \u2713 Canonical path exists`);
       } else {
         error(`  \u2717 Canonical path missing: ${entry.canonical_path}`);
         issues++;
       }
-      if (existsSync7(entry.agent_path)) {
-        const isLink = await isSymlink(entry.agent_path);
-        success(`  \u2713 Agent path exists (${isLink ? "symlink" : "copy"})`);
-      } else {
-        error(`  \u2717 Agent path missing: ${entry.agent_path}`);
-        issues++;
+      for (const agentRecord of entry.agents) {
+        if (existsSync8(agentRecord.agent_path)) {
+          const isLink = await isSymlink(agentRecord.agent_path);
+          success(`  \u2713 ${agentRecord.agent} path exists (${isLink ? "symlink" : "copy"}${agentRecord.global ? ", global" : ""})`);
+        } else {
+          error(`  \u2717 ${agentRecord.agent} path missing: ${agentRecord.agent_path}`);
+          issues++;
+        }
       }
       const envStatus = await getEnvStatus(name, entry.env_keys);
       if (envStatus === "configured") {
@@ -1424,8 +1728,8 @@ async function find(args) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join7, basename as basename2 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join8, basename as basename3 } from "path";
 var SKILL_MD_TEMPLATE = `---
 name: {{NAME}}
 version: 0.1.0
@@ -1451,14 +1755,14 @@ async function init(args) {
   let targetDir;
   let skillName;
   if (nameArg) {
-    targetDir = join7(cwd, nameArg);
+    targetDir = join8(cwd, nameArg);
     skillName = nameArg;
   } else {
     targetDir = cwd;
-    skillName = basename2(cwd);
+    skillName = basename3(cwd);
   }
-  const skillMdPath = join7(targetDir, "SKILL.md");
-  if (existsSync8(skillMdPath)) {
+  const skillMdPath = join8(targetDir, "SKILL.md");
+  if (existsSync9(skillMdPath)) {
     error(`SKILL.md already exists at ${skillMdPath}`);
     process.exit(1);
   }