synskill 0.1.4

package/bin/synskill.js

@@ -0,0 +1,2259 @@
+#!/usr/bin/env node
+/*
+ * This file is generated. Do not edit directly.
+ * Edit the source entrypoint and run `npm run build` to rebuild.
+ */
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/args.js
+var require_args = __commonJS({
+  "src/args.js"(exports2, module2) {
+    "use strict";
+    var KNOWN_COMMANDS = /* @__PURE__ */ new Set(["install", "add", "list", "update", "help", "version"]);
+    function parseArgs2(argv) {
+      let command = "";
+      const options = {
+        dest: "",
+        global: false,
+        projectPath: void 0,
+        skills: [],
+        all: false,
+        copy: false,
+        force: false,
+        noPull: false,
+        yes: false,
+        filter: "",
+        details: false,
+        repoUrl: ""
+      };
+      const args = [...argv];
+      if (args[0] && !args[0].startsWith("-")) {
+        const firstToken = args.shift();
+        if (KNOWN_COMMANDS.has(firstToken)) {
+          command = firstToken;
+        } else {
+          command = "install";
+          options.skills.push(firstToken);
+        }
+      }
+      while (args.length) {
+        const arg = args.shift();
+        switch (arg) {
+          case "--dest":
+            options.dest = args.shift() || "";
+            break;
+          case "--global":
+            options.global = true;
+            break;
+          case "--project": {
+            const next = args[0];
+            if (next && !next.startsWith("-")) {
+              options.projectPath = args.shift();
+            } else {
+              options.projectPath = "";
+            }
+            break;
+          }
+          case "--skills":
+            options.skills = splitList(args.shift() || "");
+            break;
+          case "--all":
+            options.all = true;
+            break;
+          case "--copy":
+            options.copy = true;
+            break;
+          case "--force":
+            options.force = true;
+            break;
+          case "--no-pull":
+            options.noPull = true;
+            break;
+          case "--yes":
+          case "-y":
+            options.yes = true;
+            break;
+          case "--filter":
+          case "--search":
+            options.filter = args.shift() || "";
+            break;
+          case "--details":
+          case "--full":
+            options.details = true;
+            break;
+          case "--repo-url":
+            options.repoUrl = args.shift() || "";
+            break;
+          case "--help":
+          case "-h":
+            command = "help";
+            break;
+          case "--version":
+          case "-v":
+            command = "version";
+            break;
+          default:
+            if (!arg.startsWith("-") && (command === "install" || command === "add" || command === "")) {
+              options.skills.push(arg);
+              break;
+            }
+            if (arg.startsWith("--skills=")) {
+              options.skills = splitList(arg.split("=").slice(1).join("="));
+              break;
+            }
+            if (arg.startsWith("--project=")) {
+              options.projectPath = arg.split("=").slice(1).join("=") || "";
+              break;
+            }
+            if (arg.startsWith("--filter=")) {
+              options.filter = arg.split("=").slice(1).join("=") || "";
+              break;
+            }
+            if (arg.startsWith("--repo-url=")) {
+              options.repoUrl = arg.split("=").slice(1).join("=") || "";
+              break;
+            }
+            break;
+        }
+      }
+      return { command, options };
+    }
+    function splitList(value) {
+      return String(value).replace(/[; ]/g, ",").split(",").map((entry) => entry.trim()).filter(Boolean);
+    }
+    module2.exports = {
+      KNOWN_COMMANDS,
+      parseArgs: parseArgs2,
+      splitList
+    };
+  }
+});
+
+// src/constants.js
+var require_constants = __commonJS({
+  "src/constants.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var path2 = require("path");
+    var CLI_NAME2 = "synskill";
+    var DEFAULT_BRANCH2 = "main";
+    var DEFAULT_REPO_URL2 = decodeObfuscatedString(
+      [20, 16, 26, 51, 9, 0, 24, 14, 88, 0, 10, 6, 28, 75, 28, 11, 9, 73, 25, 8, 22, 9, 95, 16, 22, 76, 27, 28, 29, 24, 30, 0, 14, 68, 31, 7, 68, 15, 13, 16, 70, 2, 26, 13],
+      "synskill-cache"
+    );
+    var PRIVATE_REPO_ENV_VAR2 = decodeObfuscatedString(
+      [32, 32, 32, 50, 59, 58, 41, 51, 126, 46, 39, 58, 63, 42, 49, 33, 46, 57, 35, 51, 120, 55, 34],
+      "synskill-env"
+    );
+    var CACHE_DIR_NAME = ".synskill";
+    var LEGACY_CACHE_DIR_NAMES = [
+      decodeObfuscatedString([93, 10, 23, 29, 10, 25, 31, 9, 0, 16, 10, 10, 4, 9, 0], "synskill-cache")
+    ];
+    var LEGACY_CACHE_METADATA_NAMES = [
+      decodeObfuscatedString(
+        [93, 10, 23, 29, 10, 25, 31, 9, 0, 30, 14, 29, 13, 31, 10, 67, 16, 10, 10, 4, 9, 3, 7, 22, 27, 15],
+        "synskill-meta"
+      )
+    ];
+    var LEGACY_REPO_PACKAGE_NAMES = [
+      decodeObfuscatedString([0, 0, 0, 18, 27, 26, 9, 65, 94, 27, 2, 11, 31, 10], "synskill-pkg")
+    ];
+    var LEGACY_REPO_ENTRY_FILES = [
+      decodeObfuscatedString([0, 0, 0, 18, 27, 26, 9, 65, 94, 14, 7, 24, 30, 10, 93, 19, 29], "synskill-entry")
+    ];
+    var CACHE_METADATA_FILE = ".synskill-cache.json";
+    var CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+    var INSTALL_TARGETS2 = [
+      {
+        key: "agents",
+        name: "GitHub Copilot, Cursor, Codex, OpenCode",
+        folder: ".agents"
+      },
+      {
+        key: "claude",
+        name: "Claude Code",
+        folder: ".claude"
+      }
+    ];
+    function userHome() {
+      return process.env.USERPROFILE || os.homedir();
+    }
+    function getCacheDir(homeDir = userHome()) {
+      return path2.join(homeDir, CACHE_DIR_NAME);
+    }
+    function getCacheMetadataPath(cacheDir) {
+      return path2.join(cacheDir, CACHE_METADATA_FILE);
+    }
+    function decodeObfuscatedString(bytes, key) {
+      let value = "";
+      for (let index = 0; index < bytes.length; index += 1) {
+        value += String.fromCharCode(bytes[index] ^ key.charCodeAt(index % key.length));
+      }
+      return value;
+    }
+    module2.exports = {
+      CACHE_DIR_NAME,
+      CACHE_METADATA_FILE,
+      CACHE_TTL_MS,
+      CLI_NAME: CLI_NAME2,
+      DEFAULT_BRANCH: DEFAULT_BRANCH2,
+      DEFAULT_REPO_URL: DEFAULT_REPO_URL2,
+      INSTALL_TARGETS: INSTALL_TARGETS2,
+      LEGACY_CACHE_DIR_NAMES,
+      LEGACY_CACHE_METADATA_NAMES,
+      LEGACY_REPO_ENTRY_FILES,
+      LEGACY_REPO_PACKAGE_NAMES,
+      PRIVATE_REPO_ENV_VAR: PRIVATE_REPO_ENV_VAR2,
+      getCacheDir,
+      getCacheMetadataPath,
+      userHome
+    };
+  }
+});
+
+// src/git.js
+var require_git = __commonJS({
+  "src/git.js"(exports2, module2) {
+    "use strict";
+    var { spawnSync } = require("child_process");
+    var path2 = require("path");
+    var { DEFAULT_REPO_URL: DEFAULT_REPO_URL2, PRIVATE_REPO_ENV_VAR: PRIVATE_REPO_ENV_VAR2 } = require_constants();
+    var inheritedGitConfigCache = /* @__PURE__ */ new Map();
+    var GitCommandError = class extends Error {
+      constructor(message, details = {}) {
+        super(message);
+        this.name = "GitCommandError";
+        this.code = details.code || "";
+        this.stderr = details.stderr || "";
+        this.stdout = details.stdout || "";
+        this.args = details.args || [];
+        this.repoUrl = details.repoUrl || "";
+        this.isAuthError = Boolean(details.isAuthError);
+        this.isMissingGit = Boolean(details.isMissingGit);
+      }
+    };
+    function runGit(args, options = {}) {
+      const commandArgs = [...getInheritedGitConfigArgs(options.gitConfigContextCwd), ...args];
+      const result = spawnSync("git", commandArgs, {
+        cwd: options.cwd || void 0,
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GCM_INTERACTIVE: "Never"
+        }
+      });
+      if (result.error) {
+        const isMissingGit = result.error.code === "ENOENT";
+        throw new GitCommandError(
+          isMissingGit ? "Git is not installed or not available in PATH." : result.error.message,
+          {
+            code: result.error.code,
+            args: commandArgs,
+            isMissingGit
+          }
+        );
+      }
+      if (result.status !== 0) {
+        const stderr = (result.stderr || "").trim();
+        const stdout = (result.stdout || "").trim();
+        throw new GitCommandError(stderr || stdout || "git command failed", {
+          code: String(result.status),
+          stderr,
+          stdout,
+          args: commandArgs,
+          repoUrl: options.repoUrl,
+          isAuthError: isGitAuthError(stderr || stdout)
+        });
+      }
+      return {
+        stdout: (result.stdout || "").trim(),
+        stderr: (result.stderr || "").trim()
+      };
+    }
+    function getInheritedGitConfigArgs(contextCwd) {
+      return getInheritedGitConfigEntries(contextCwd).flatMap(({ key, value }) => ["-c", `${key}=${value}`]);
+    }
+    function getInheritedGitConfigEntries(contextCwd) {
+      if (!contextCwd) {
+        return [];
+      }
+      const normalizedCwd = path2.resolve(contextCwd);
+      if (inheritedGitConfigCache.has(normalizedCwd)) {
+        return inheritedGitConfigCache.get(normalizedCwd);
+      }
+      const result = spawnSync(
+        "git",
+        ["-C", normalizedCwd, "config", "--get-regexp", "^(core\\.sshcommand|url\\..*\\.insteadof)$"],
+        {
+          encoding: "utf8",
+          env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            GCM_INTERACTIVE: "Never"
+          }
+        }
+      );
+      if (result.error || result.status !== 0) {
+        inheritedGitConfigCache.set(normalizedCwd, []);
+        return [];
+      }
+      const entries = [];
+      const seen = /* @__PURE__ */ new Set();
+      String(result.stdout || "").split(/\r?\n/).filter(Boolean).forEach((line) => {
+        const separatorIndex = line.search(/\s/);
+        if (separatorIndex <= 0) {
+          return;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = normalizeInheritedConfigValue(key, line.slice(separatorIndex).trim());
+        if (!key || !value) {
+          return;
+        }
+        const entryKey = `${key}\0${value}`;
+        if (seen.has(entryKey)) {
+          return;
+        }
+        seen.add(entryKey);
+        entries.push({ key, value });
+      });
+      inheritedGitConfigCache.set(normalizedCwd, entries);
+      return entries;
+    }
+    function syncInheritedGitConfig(repoCwd, contextCwd) {
+      const entries = getInheritedGitConfigEntries(contextCwd);
+      if (!repoCwd || entries.length === 0) {
+        return;
+      }
+      const normalizedRepoCwd = path2.resolve(repoCwd);
+      for (const { key, value } of entries) {
+        if (key.endsWith(".insteadof")) {
+          const existingValues = getLocalGitConfigValues(normalizedRepoCwd, key);
+          if (existingValues.includes(value)) {
+            continue;
+          }
+          setLocalGitConfigValue(normalizedRepoCwd, key, value, { append: true });
+          continue;
+        }
+        setLocalGitConfigValue(normalizedRepoCwd, key, value);
+      }
+    }
+    function isGitAuthError(message) {
+      const text = String(message || "").toLowerCase();
+      return [
+        "permission denied",
+        "authentication failed",
+        "could not read username",
+        "could not read from remote repository",
+        "publickey",
+        "repository not found",
+        "access denied",
+        "not authorized"
+      ].some((fragment) => text.includes(fragment));
+    }
+    function normalizeInheritedConfigValue(key, value) {
+      if (!value) {
+        return "";
+      }
+      if (key === "core.sshcommand" && /\s/.test(value)) {
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          return value;
+        }
+        return `"${value}"`;
+      }
+      return value;
+    }
+    function getLocalGitConfigValues(repoCwd, key) {
+      const result = spawnSync("git", ["-C", repoCwd, "config", "--local", "--get-all", key], {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GCM_INTERACTIVE: "Never"
+        }
+      });
+      if (result.error || result.status !== 0) {
+        return [];
+      }
+      return String(result.stdout || "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    }
+    function setLocalGitConfigValue(repoCwd, key, value, options = {}) {
+      const args = ["-C", repoCwd, "config", "--local"];
+      if (options.append) {
+        args.push("--add");
+      }
+      args.push(key, value);
+      const result = spawnSync("git", args, {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GCM_INTERACTIVE: "Never"
+        }
+      });
+      if (result.error) {
+        const isMissingGit = result.error.code === "ENOENT";
+        throw new GitCommandError(
+          isMissingGit ? "Git is not installed or not available in PATH." : result.error.message,
+          {
+            code: result.error.code,
+            args,
+            isMissingGit
+          }
+        );
+      }
+      if (result.status !== 0) {
+        const stderr = (result.stderr || "").trim();
+        const stdout = (result.stdout || "").trim();
+        throw new GitCommandError(stderr || stdout || "git config failed", {
+          code: String(result.status),
+          stderr,
+          stdout,
+          args
+        });
+      }
+    }
+    function formatGitAccessError2(repoUrl, error) {
+      const repoLabel = repoUrl && repoUrl !== DEFAULT_REPO_URL2 ? repoUrl : "the private repository";
+      if (!(error instanceof GitCommandError)) {
+        return `Failed to access ${repoLabel}: ${error.message || String(error)}`;
+      }
+      if (error.isMissingGit) {
+        return "Git is required for synskill. Install Git and make sure it is available in PATH.";
+      }
+      if (error.isAuthError) {
+        if (repoUrl && repoUrl !== DEFAULT_REPO_URL2) {
+          return [
+            `Failed to access ${repoLabel}.`,
+            "Git could not fetch the external skill source.",
+            `Verify the repository is reachable with: git ls-remote ${repoUrl}`,
+            "If the repository is private, configure the required Git credentials before retrying."
+          ].join("\n");
+        }
+        return [
+          `Failed to access ${repoLabel}.`,
+          "Git authentication did not succeed.",
+          `Use a repo URL you can access via --repo-url or ${PRIVATE_REPO_ENV_VAR2}.`,
+          "For SSH, verify your key with: ssh -T git@bitbucket.org",
+          "For HTTPS, configure a credential helper or app password before retrying."
+        ].join("\n");
+      }
+      return `Failed to access ${repoLabel}:
+${error.message}`;
+    }
+    module2.exports = {
+      GitCommandError,
+      formatGitAccessError: formatGitAccessError2,
+      getInheritedGitConfigArgs,
+      runGit,
+      syncInheritedGitConfig
+    };
+  }
+});
+
+// src/installer.js
+var require_installer = __commonJS({
+  "src/installer.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path2 = require("path");
+    var { INSTALL_TARGETS: INSTALL_TARGETS2, userHome } = require_constants();
+    function buildInstallPlan2(options = {}, targetKeys = [], scope, mode = "symlink") {
+      if (options.dest) {
+        return {
+          mode: "copy",
+          scope: "dest",
+          targets: [
+            {
+              key: "dest",
+              baseDir: absPath(options.dest)
+            }
+          ]
+        };
+      }
+      const selectedTargets = targetKeys.length ? INSTALL_TARGETS2.filter((target) => targetKeys.includes(target.key)) : INSTALL_TARGETS2;
+      const resolvedScope = scope || (options.global ? "global" : options.projectPath !== void 0 ? "project" : "global");
+      const baseDir = resolvedScope === "global" ? userHome() : absPath(options.projectPath || process.cwd());
+      return {
+        mode,
+        scope: resolvedScope,
+        baseDir,
+        targets: selectedTargets.map((target) => ({
+          key: target.key,
+          baseDir: path2.join(baseDir, target.folder, "skills")
+        }))
+      };
+    }
+    function hasExistingSkills2(plan, skills) {
+      for (const skill of skills) {
+        for (const target of plan.targets) {
+          if (fs.existsSync(path2.join(target.baseDir, skill.name))) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    async function installSkills2(skills, plan, force) {
+      const results = [];
+      for (const skill of skills) {
+        const sourceDir = path2.resolve(skill.path);
+        const useSymlink = plan.mode === "symlink" && !skill.external;
+        for (const target of plan.targets) {
+          const targetDir = path2.join(target.baseDir, skill.name);
+          if (fs.existsSync(targetDir)) {
+            if (force) {
+              await fs.promises.rm(targetDir, { recursive: true, force: true });
+            } else {
+              results.push({
+                skill: skill.name,
+                path: targetDir,
+                skipped: true,
+                mode: plan.mode
+              });
+              continue;
+            }
+          }
+          if (!useSymlink) {
+            await copyDir(skill.path, targetDir);
+            results.push({
+              skill: skill.name,
+              path: targetDir,
+              skipped: false,
+              mode: "copy"
+            });
+            continue;
+          }
+          const symlinkCreated = await createSymlink(sourceDir, targetDir);
+          if (!symlinkCreated) {
+            await copyDir(skill.path, targetDir);
+            results.push({
+              skill: skill.name,
+              path: targetDir,
+              skipped: false,
+              mode: "copy",
+              symlinkFailed: true,
+              sourcePath: sourceDir
+            });
+            continue;
+          }
+          results.push({
+            skill: skill.name,
+            path: targetDir,
+            skipped: false,
+            mode: "symlink",
+            sourcePath: sourceDir
+          });
+        }
+      }
+      return results;
+    }
+    async function createSymlink(target, linkPath) {
+      try {
+        const linkDir = path2.dirname(linkPath);
+        await fs.promises.mkdir(linkDir, { recursive: true });
+        if (fs.existsSync(linkPath)) {
+          await fs.promises.rm(linkPath, { recursive: true, force: true });
+        }
+        const linkTarget = process.platform === "win32" ? path2.resolve(target) : path2.relative(linkDir, target);
+        const linkType = process.platform === "win32" ? "junction" : "dir";
+        await fs.promises.symlink(linkTarget, linkPath, linkType);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async function copyDir(source, destination) {
+      if (fs.existsSync(destination)) {
+        await fs.promises.rm(destination, { recursive: true, force: true });
+      }
+      await fs.promises.mkdir(destination, { recursive: true });
+      const entries = await fs.promises.readdir(source, { withFileTypes: true });
+      for (const entry of entries) {
+        const sourcePath = path2.join(source, entry.name);
+        const destinationPath = path2.join(destination, entry.name);
+        if (entry.isDirectory()) {
+          await copyDir(sourcePath, destinationPath);
+        } else {
+          await fs.promises.copyFile(sourcePath, destinationPath);
+        }
+      }
+    }
+    function absPath(value) {
+      if (!value) {
+        throw new Error("Path is empty.");
+      }
+      return path2.isAbsolute(value) ? value : path2.resolve(process.cwd(), value);
+    }
+    module2.exports = {
+      absPath,
+      buildInstallPlan: buildInstallPlan2,
+      createSymlink,
+      copyDir,
+      hasExistingSkills: hasExistingSkills2,
+      installSkills: installSkills2
+    };
+  }
+});
+
+// src/external-skills.js
+var require_external_skills = __commonJS({
+  "src/external-skills.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var os = require("os");
+    var path2 = require("path");
+    var { runGit } = require_git();
+    var EXTERNAL_SKILLS = [
+      {
+        name: "skill-creator",
+        description: "Guided skill authoring flow from anthropics/skills. Use when creating a new skill or updating an existing skill that extends Codex with reusable workflows, scripts, references, or assets.",
+        shortDescription: "Create or update skills from the upstream Anthropic skills repo.",
+        repository: "anthropics/skills",
+        external: {
+          repoUrl: "https://github.com/anthropics/skills.git",
+          ref: "main",
+          path: "skills/skill-creator",
+          url: "https://github.com/anthropics/skills/tree/main/skills/skill-creator"
+        }
+      }
+    ];
+    function cloneExternalSkill(skill) {
+      return {
+        ...skill,
+        external: { ...skill.external },
+        path: ""
+      };
+    }
+    function getExternalSkills() {
+      return EXTERNAL_SKILLS.map(cloneExternalSkill);
+    }
+    function getExplicitExternalSkills2(names = []) {
+      const requested = new Set((names || []).map((name) => String(name).toLowerCase()));
+      return EXTERNAL_SKILLS.filter((skill) => requested.has(skill.name.toLowerCase())).map(cloneExternalSkill);
+    }
+    function isExplicitExternalSkillName(name) {
+      const normalized = String(name || "").toLowerCase();
+      return EXTERNAL_SKILLS.some((skill) => skill.name.toLowerCase() === normalized);
+    }
+    async function materializeSkillSources2(skills, deps = {}) {
+      const externalSkills = skills.filter((skill) => skill && skill.external);
+      if (!externalSkills.length) {
+        return {
+          skills,
+          cleanup: async () => {
+          }
+        };
+      }
+      const tempBaseDir = deps.tempBaseDir || fs.mkdtempSync(path2.join(deps.tempParentDir || os.tmpdir(), "synskill-external-"));
+      const groupedSkills = groupByRepo(externalSkills);
+      const preparedByName = /* @__PURE__ */ new Map();
+      try {
+        for (let index = 0; index < groupedSkills.length; index += 1) {
+          const group = groupedSkills[index];
+          const checkoutDir = path2.join(tempBaseDir, `repo-${index}`);
+          checkoutRepoGroup(group, checkoutDir, deps);
+          for (const skill of group.skills) {
+            const skillPath = path2.join(checkoutDir, ...skill.external.path.split("/"));
+            if (!fs.existsSync(path2.join(skillPath, "SKILL.md"))) {
+              throw new Error(
+                `External skill "${skill.name}" was not found at ${skill.external.url || skill.external.path}.`
+              );
+            }
+            preparedByName.set(skill.name.toLowerCase(), {
+              ...skill,
+              path: skillPath
+            });
+          }
+        }
+        return {
+          skills: skills.map((skill) => preparedByName.get(skill.name.toLowerCase()) || skill),
+          cleanup: async () => {
+            fs.rmSync(tempBaseDir, { recursive: true, force: true });
+          }
+        };
+      } catch (error) {
+        fs.rmSync(tempBaseDir, { recursive: true, force: true });
+        throw error;
+      }
+    }
+    function groupByRepo(skills) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const skill of skills) {
+        const key = `${skill.external.repoUrl}#${skill.external.ref || "main"}`;
+        if (!groups.has(key)) {
+          groups.set(key, {
+            repoUrl: skill.external.repoUrl,
+            ref: skill.external.ref || "main",
+            paths: /* @__PURE__ */ new Set(),
+            skills: []
+          });
+        }
+        const group = groups.get(key);
+        group.paths.add(skill.external.path);
+        group.skills.push(skill);
+      }
+      return Array.from(groups.values());
+    }
+    function checkoutRepoGroup(group, checkoutDir, deps = {}) {
+      const runGitCommand = deps.runGitCommand || runGit;
+      const repoUrl = group.repoUrl;
+      const ref = group.ref || "main";
+      const sparsePaths = Array.from(group.paths);
+      fs.rmSync(checkoutDir, { recursive: true, force: true });
+      fs.mkdirSync(path2.dirname(checkoutDir), { recursive: true });
+      try {
+        runGitCommand(
+          ["clone", "--depth", "1", "--filter=blob:none", "--sparse", "--branch", ref, repoUrl, checkoutDir],
+          { repoUrl }
+        );
+        runGitCommand(["sparse-checkout", "set", "--cone", ...sparsePaths], {
+          cwd: checkoutDir,
+          repoUrl
+        });
+        return;
+      } catch {
+        fs.rmSync(checkoutDir, { recursive: true, force: true });
+      }
+      runGitCommand(["clone", "--depth", "1", "--branch", ref, repoUrl, checkoutDir], { repoUrl });
+    }
+    module2.exports = {
+      EXTERNAL_SKILLS,
+      getExternalSkills,
+      getExplicitExternalSkills: getExplicitExternalSkills2,
+      isExplicitExternalSkillName,
+      materializeSkillSources: materializeSkillSources2
+    };
+  }
+});
+
+// src/skill-catalog.js
+var require_skill_catalog = __commonJS({
+  "src/skill-catalog.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path2 = require("path");
+    var { isExplicitExternalSkillName } = require_external_skills();
+    function findSkills2(repoRoot) {
+      const fromJson = loadSkillsJson(repoRoot);
+      if (fromJson.length) {
+        return fromJson;
+      }
+      const skillsRoot = path2.join(repoRoot, "skills");
+      const base = dirExists(skillsRoot) ? skillsRoot : repoRoot;
+      const entries = fs.readdirSync(base, { withFileTypes: true });
+      const skills = entries.filter((entry) => entry.isDirectory() && fs.existsSync(path2.join(base, entry.name, "SKILL.md"))).filter((entry) => !isExplicitExternalSkillName(entry.name)).map((entry) => {
+        const skillPath = path2.join(base, entry.name);
+        const skillFile = path2.join(skillPath, "SKILL.md");
+        const { description } = readFrontmatter(skillFile);
+        return {
+          name: entry.name,
+          path: skillPath,
+          description,
+          shortDescription: buildShortDescription(description),
+          repository: "any"
+        };
+      }).sort((a, b) => a.name.localeCompare(b.name));
+      if (!skills.length) {
+        throw new Error("No skills found in the private skills repository.");
+      }
+      return skills;
+    }
+    function loadSkillsJson(repoRoot) {
+      const skillsFile = path2.join(repoRoot, "skills.json");
+      if (!fs.existsSync(skillsFile)) {
+        return [];
+      }
+      try {
+        const raw = fs.readFileSync(skillsFile, "utf8");
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+          return [];
+        }
+        return data.filter((skill) => skill && typeof skill.name === "string").map((skill) => ({
+          name: skill.name,
+          description: skill.description || "",
+          shortDescription: skill.shortDescription || buildShortDescription(skill.description),
+          repository: skill.repository || "any",
+          path: skill.path ? path2.join(repoRoot, skill.path) : path2.join(repoRoot, "skills", skill.name)
+        })).filter((skill) => !isExplicitExternalSkillName(skill.name)).filter((skill) => fs.existsSync(skill.path)).sort((a, b) => a.name.localeCompare(b.name));
+      } catch {
+        return [];
+      }
+    }
+    function applyListFilter2(skills, options = {}) {
+      const query = String(options.filter || "").trim().toLowerCase();
+      if (!query) {
+        return skills;
+      }
+      return skills.filter(
+        (skill) => [skill.name, skill.description, skill.shortDescription, skill.repository].filter(Boolean).some((field) => String(field).toLowerCase().includes(query))
+      );
+    }
+    function splitRepositoryField(repository) {
+      const values = Array.isArray(repository) ? repository : String(repository || "any").split(",");
+      const seen = /* @__PURE__ */ new Set();
+      const result = [];
+      values.forEach((value) => {
+        const normalized = String(value || "").trim();
+        if (!normalized) {
+          return;
+        }
+        const key = normalized.toLowerCase();
+        if (seen.has(key)) {
+          return;
+        }
+        seen.add(key);
+        result.push(normalized);
+      });
+      return result.length ? result : ["any"];
+    }
+    function filterSkillsByName2(skills, names) {
+      const nameSet = new Set((names || []).map((name) => String(name).toLowerCase()));
+      const selected = skills.filter((skill) => nameSet.has(skill.name.toLowerCase()));
+      if (!selected.length) {
+        throw new Error(`No matching skills selected: ${(names || []).join(", ")}`);
+      }
+      return selected;
+    }
+    function buildShortDescription(description) {
+      if (!description) {
+        return "";
+      }
+      let base = String(description).replace(/\s+/g, " ").trim();
+      const cutTokens = [" Use when ", " Use after ", " Use for ", " Use if ", " Use to "];
+      for (const token of cutTokens) {
+        const index = base.indexOf(token);
+        if (index > 0) {
+          base = base.slice(0, index).trim();
+          break;
+        }
+      }
+      base = base.replace(/\s*\([^)]*\)\s*/g, " ").replace(/\s+/g, " ").trim();
+      const trimTokens = [" including ", " such as ", " e.g. ", " e.g., ", " for example "];
+      for (const token of trimTokens) {
+        const index = base.toLowerCase().indexOf(token.trim());
+        if (index > 0) {
+          base = base.slice(0, index).trim();
+          break;
+        }
+      }
+      if (base.includes(". ")) {
+        base = base.split(". ")[0].trim();
+      }
+      if (base.length > 90) {
+        const commaCut = base.split(",")[0].trim();
+        if (commaCut.length >= 40) {
+          base = commaCut;
+        }
+      }
+      if (base.length > 90) {
+        const andCut = base.split(" and ")[0].trim();
+        if (andCut.length >= 40) {
+          base = andCut;
+        }
+      }
+      if (base.length > 90) {
+        base = `${base.slice(0, 87).trimEnd()}...`;
+      }
+      return base;
+    }
+    function readFrontmatter(filePath) {
+      if (!fs.existsSync(filePath)) {
+        return { description: "" };
+      }
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split(/\r?\n/);
+      if (!lines.length || lines[0].trim() !== "---") {
+        return { description: "" };
+      }
+      const data = {};
+      for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() === "---") {
+          break;
+        }
+        if (/^\s/.test(line)) {
+          continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex === -1) {
+          continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        let value = line.slice(separatorIndex + 1).trim();
+        if (!value) {
+          continue;
+        }
+        value = unquote(value);
+        data[key] = value;
+      }
+      return { description: data.description || "" };
+    }
+    function unquote(value) {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+      }
+      return value;
+    }
+    function dirExists(targetPath) {
+      try {
+        return fs.statSync(targetPath).isDirectory();
+      } catch {
+        return false;
+      }
+    }
+    module2.exports = {
+      applyListFilter: applyListFilter2,
+      buildShortDescription,
+      filterSkillsByName: filterSkillsByName2,
+      findSkills: findSkills2,
+      loadSkillsJson,
+      splitRepositoryField
+    };
+  }
+});
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports2, module2) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
+
+// src/theme.js
+var require_theme = __commonJS({
+  "src/theme.js"(exports2, module2) {
+    "use strict";
+    var pc = require_picocolors();
+    function colorDepth() {
+      if (!pc.isColorSupported) {
+        return 1;
+      }
+      if (process.stdout && typeof process.stdout.getColorDepth === "function") {
+        try {
+          return process.stdout.getColorDepth();
+        } catch {
+          return 4;
+        }
+      }
+      return 4;
+    }
+    function applyAnsi(text, open, close) {
+      return pc.isColorSupported ? `${open}${text}${close}` : text;
+    }
+    function colorize(text, rgb, ansi256, fallback) {
+      const value = String(text);
+      const depth = colorDepth();
+      if (depth >= 24) {
+        return applyAnsi(value, `\x1B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`, "\x1B[39m");
+      }
+      if (depth >= 8) {
+        return applyAnsi(value, `\x1B[38;5;${ansi256}m`, "\x1B[39m");
+      }
+      return fallback(value);
+    }
+    function accent2(text) {
+      return colorize(text, [217, 95, 43], 166, pc.yellow);
+    }
+    function warm2(text) {
+      return colorize(text, [246, 211, 196], 224, pc.yellowBright);
+    }
+    function muted2(text) {
+      return colorize(text, [108, 100, 92], 241, (value) => pc.dim(value));
+    }
+    function strong2(text) {
+      return pc.bold(pc.white(String(text)));
+    }
+    function success2(text) {
+      return accent2(text);
+    }
+    function danger2(text) {
+      return pc.red(String(text));
+    }
+    function info(text) {
+      return muted2(text);
+    }
+    function highlightMatch(text, query, baseColor = (value) => value) {
+      const value = String(text || "");
+      const needle = String(query || "").trim().toLowerCase();
+      if (!needle) {
+        return baseColor(value);
+      }
+      const lower = value.toLowerCase();
+      const parts = [];
+      let start = 0;
+      let matchIndex = lower.indexOf(needle);
+      while (matchIndex !== -1) {
+        if (matchIndex > start) {
+          parts.push(baseColor(value.slice(start, matchIndex)));
+        }
+        parts.push(accent2(pc.bold(value.slice(matchIndex, matchIndex + needle.length))));
+        start = matchIndex + needle.length;
+        matchIndex = lower.indexOf(needle, start);
+      }
+      if (start < value.length) {
+        parts.push(baseColor(value.slice(start)));
+      }
+      return parts.join("");
+    }
+    module2.exports = {
+      accent: accent2,
+      danger: danger2,
+      highlightMatch,
+      info,
+      muted: muted2,
+      strong: strong2,
+      success: success2,
+      warm: warm2
+    };
+  }
+});
+
+// src/search-multiselect.js
+var require_search_multiselect = __commonJS({
+  "src/search-multiselect.js"(exports2, module2) {
+    "use strict";
+    var readline = require("readline");
+    var { Writable } = require("stream");
+    var { accent: accent2, danger: danger2, highlightMatch, muted: muted2, strong: strong2, warm: warm2 } = require_theme();
+    var RAIL = muted2("\u2502");
+    var RAIL_END = muted2("\u2514");
+    var HEADER_MARKER = muted2("\u2022");
+    var ACTIVE_CURSOR = accent2("\u203A");
+    var SELECTED_DOT = accent2("\u25CF");
+    var UNSELECTED_DOT = muted2("\u25CB");
+    var silentOutput = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    var cancelSymbol2 = Symbol("cancel");
+    var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+    async function searchMultiselect(options) {
+      return runListPrompt({
+        ...options,
+        searchable: true,
+        multiple: true
+      });
+    }
+    async function multiselectPrompt(options) {
+      return runListPrompt({
+        ...options,
+        multiple: true
+      });
+    }
+    async function selectPrompt(options) {
+      return runListPrompt(options);
+    }
+    async function confirmPrompt(options) {
+      return selectPrompt({
+        message: options.message,
+        items: [
+          { value: true, label: options.active || "Yes" },
+          { value: false, label: options.inactive || "No" }
+        ],
+        initialValue: options.initialValue ? true : false,
+        instructions: "Use arrows to choose, then press enter to confirm.",
+        emptyText: "No choices available."
+      });
+    }
+    function summarizeLabels(labels) {
+      if (!labels.length) {
+        return muted2("(none)");
+      }
+      if (labels.length <= 3) {
+        return labels.join(", ");
+      }
+      return `${labels.slice(0, 3).join(", ")} +${labels.length - 3} more`;
+    }
+    async function runListPrompt(options) {
+      const {
+        message,
+        items,
+        maxVisible = 8,
+        required = false,
+        searchable = false,
+        multiple = false,
+        initialValues = [],
+        initialValue,
+        instructions = "",
+        emptyText = "No options available."
+      } = options;
+      if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== "function") {
+        throw new Error("Interactive selection requires a TTY terminal.");
+      }
+      return new Promise((resolve) => {
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: silentOutput,
+          terminal: false
+        });
+        process.stdin.setRawMode(true);
+        readline.emitKeypressEvents(process.stdin, rl);
+        let query = "";
+        let cursor = 0;
+        let lastHeight = 0;
+        let errorMessage = "";
+        const selected = new Set(multiple ? initialValues : []);
+        const defaultIndex = initialValue === void 0 ? 0 : Math.max(
+          items.findIndex((item) => item.value === initialValue),
+          0
+        );
+        cursor = defaultIndex;
+        const filterItems = () => {
+          if (!searchable) {
+            return items;
+          }
+          const normalized = query.toLowerCase();
+          if (!normalized) {
+            return items;
+          }
+          return items.filter(
+            (item) => [item.label, item.hint].filter(Boolean).some((field) => String(field).toLowerCase().includes(normalized))
+          );
+        };
+        const syncCursor = () => {
+          const filtered = filterItems();
+          if (!filtered.length) {
+            cursor = 0;
+            return filtered;
+          }
+          cursor = Math.max(0, Math.min(cursor, filtered.length - 1));
+          return filtered;
+        };
+        const clear = () => {
+          if (!lastHeight) {
+            return;
+          }
+          process.stdout.write(`\x1B[${lastHeight}A`);
+          for (let index = 0; index < lastHeight; index += 1) {
+            process.stdout.write("\x1B[2K\x1B[1B");
+          }
+          process.stdout.write(`\x1B[${lastHeight}A`);
+        };
+        const measureRenderedHeight = (lines) => {
+          const columns = Math.max(process.stdout.columns || 80, 1);
+          return lines.reduce((total, line) => {
+            const visible = String(line || "").replace(ANSI_PATTERN, "");
+            return total + Math.max(1, Math.ceil(visible.length / columns));
+          }, 0);
+        };
+        const renderInstructions = () => {
+          if (instructions) {
+            return muted2(instructions);
+          }
+          const parts = [];
+          if (searchable) {
+            parts.push("type to filter");
+          }
+          parts.push("arrows to move");
+          if (multiple) {
+            parts.push("space to toggle");
+            parts.push("a all");
+          }
+          parts.push(multiple ? "enter confirm" : "enter select");
+          parts.push("esc cancel");
+          return muted2(parts.join(" | "));
+        };
+        const withRail = (content = "") => content ? `${RAIL}  ${content}` : RAIL;
+        const withBranch = (content = "") => content ? `${RAIL_END}  ${content}` : RAIL_END;
+        const renderBadge = (badge, activeQuery) => {
+          const label = highlightMatch(badge, activeQuery, warm2);
+          return `${accent2("[")}${label}${accent2("]")}`;
+        };
+        const renderRow = (item, isActive, isSelected, activeQuery) => {
+          const label = highlightMatch(
+            item.label,
+            activeQuery,
+            isActive ? (value) => strong2(value) : (value) => muted2(value)
+          );
+          const cursorDot = isActive ? ACTIVE_CURSOR : " ";
+          const selectDot = multiple ? isSelected ? SELECTED_DOT : UNSELECTED_DOT : isActive ? SELECTED_DOT : UNSELECTED_DOT;
+          return withRail(`${cursorDot} ${selectDot} ${label}`);
+        };
+        const renderDetails = (item, isActive, activeQuery) => {
+          const badges = Array.isArray(item.badges) ? item.badges : [];
+          if (!item.hint && !badges.length) {
+            return [];
+          }
+          const lines = [];
+          if (badges.length) {
+            lines.push(withRail(`    ${badges.map((badge) => renderBadge(badge, activeQuery)).join(" ")}`));
+          }
+          if (item.hint) {
+            lines.push(
+              withRail(`    ${highlightMatch(item.hint, activeQuery, isActive ? warm2 : muted2)}`)
+            );
+          }
+          return lines;
+        };
+        const renderSummary = () => {
+          if (!multiple) {
+            const filtered = filterItems();
+            const current = filtered[cursor];
+            if (!current) {
+              return withBranch(muted2("(none)"));
+            }
+            return withBranch(`${warm2("Current:")} ${strong2(current.label)}`);
+          }
+          const summary = summarizeLabels(
+            items.filter((item) => selected.has(item.value)).map((item) => item.label)
+          );
+          return withBranch(`${warm2("Selected:")} ${summary}`);
+        };
+        const render = (mode = "active") => {
+          clear();
+          const filtered = syncCursor();
+          const lines = [];
+          lines.push(`${HEADER_MARKER} ${strong2(message)}`);
+          if (mode === "submit") {
+            const submitted = multiple ? summarizeLabels(items.filter((item) => selected.has(item.value)).map((item) => item.label)) : filtered[cursor] ? filtered[cursor].label : "";
+            lines.push(withBranch(warm2(submitted || "(none)")));
+          } else if (mode === "cancel") {
+            lines.push(withBranch(danger2("Cancelled")));
+          } else {
+            lines.push(withRail(renderInstructions()));
+            if (searchable) {
+              lines.push(withRail(`${muted2("Filter:")} ${query ? warm2(query) : muted2("(none)")}`));
+            }
+            if (errorMessage) {
+              lines.push(withRail(danger2(errorMessage)));
+            }
+            lines.push(RAIL);
+            if (!filtered.length) {
+              lines.push(withRail(muted2(emptyText)));
+            } else {
+              const visibleCount = Math.min(maxVisible, filtered.length);
+              const start = Math.max(
+                0,
+                Math.min(cursor - Math.floor(visibleCount / 2), filtered.length - visibleCount)
+              );
+              const visible = filtered.slice(start, start + visibleCount);
+              visible.forEach((item, index) => {
+                const actualIndex = start + index;
+                const isActive = actualIndex === cursor;
+                const isSelected = multiple && selected.has(item.value);
+                lines.push(renderRow(item, isActive, isSelected, query));
+                const detailLines = renderDetails(item, isActive, query);
+                if (detailLines.length && isActive) {
+                  lines.push(...detailLines);
+                }
+              });
+              if (filtered.length > visibleCount) {
+                lines.push(RAIL);
+                lines.push(
+                  withRail(muted2(`Showing ${start + 1}-${start + visible.length} of ${filtered.length}`))
+                );
+              }
+            }
+            lines.push(renderSummary());
+          }
+          process.stdout.write(`${lines.join("\n")}
+`);
+          lastHeight = measureRenderedHeight(lines);
+        };
+        const cleanup = () => {
+          process.stdin.removeListener("keypress", onKeypress);
+          process.stdin.setRawMode(false);
+          rl.close();
+        };
+        const submit = () => {
+          const filtered = syncCursor();
+          if (multiple) {
+            if (required && selected.size === 0) {
+              errorMessage = "Select at least one option.";
+              render();
+              return;
+            }
+            render("submit");
+            cleanup();
+            resolve(items.filter((item) => selected.has(item.value)).map((item) => item.value));
+            return;
+          }
+          if (required && !filtered[cursor]) {
+            errorMessage = "Select an option before continuing.";
+            render();
+            return;
+          }
+          render("submit");
+          cleanup();
+          resolve(filtered[cursor] ? filtered[cursor].value : cancelSymbol2);
+        };
+        const cancel2 = () => {
+          render("cancel");
+          cleanup();
+          resolve(cancelSymbol2);
+        };
+        const onKeypress = (input, key = {}) => {
+          const filtered = syncCursor();
+          if (key.ctrl && key.name === "c") {
+            cancel2();
+            return;
+          }
+          if (key.name === "return") {
+            submit();
+            return;
+          }
+          if (key.name === "escape") {
+            if (searchable && query) {
+              query = "";
+              errorMessage = "";
+              render();
+              return;
+            }
+            cancel2();
+            return;
+          }
+          if (key.name === "up" || key.name === "left") {
+            errorMessage = "";
+            cursor = Math.max(0, cursor - 1);
+            render();
+            return;
+          }
+          if (key.name === "down" || key.name === "right") {
+            errorMessage = "";
+            cursor = Math.min(Math.max(filtered.length - 1, 0), cursor + 1);
+            render();
+            return;
+          }
+          if (multiple && key.name === "space") {
+            const item = filtered[cursor];
+            if (item) {
+              if (selected.has(item.value)) {
+                selected.delete(item.value);
+              } else {
+                selected.add(item.value);
+              }
+              errorMessage = "";
+            }
+            render();
+            return;
+          }
+          if (multiple && input === "a") {
+            const allSelected = items.length > 0 && items.every((item) => selected.has(item.value));
+            selected.clear();
+            if (!allSelected) {
+              items.forEach((item) => selected.add(item.value));
+            }
+            errorMessage = "";
+            render();
+            return;
+          }
+          if (searchable && key.name === "backspace") {
+            query = query.slice(0, -1);
+            cursor = 0;
+            errorMessage = "";
+            render();
+            return;
+          }
+          if (searchable && input && input.length === 1 && !key.ctrl && !key.meta) {
+            query += input;
+            cursor = 0;
+            errorMessage = "";
+            render();
+          }
+        };
+        process.stdin.on("keypress", onKeypress);
+        render();
+      });
+    }
+    module2.exports = {
+      cancelSymbol: cancelSymbol2,
+      confirmPrompt,
+      multiselectPrompt,
+      searchMultiselect,
+      selectPrompt
+    };
+  }
+});
+
+// src/prompts.js
+var require_prompts = __commonJS({
+  "src/prompts.js"(exports2, module2) {
+    "use strict";
+    var { INSTALL_TARGETS: INSTALL_TARGETS2 } = require_constants();
+    var { splitRepositoryField } = require_skill_catalog();
+    var {
+      cancelSymbol: cancelSymbol2,
+      confirmPrompt,
+      multiselectPrompt,
+      searchMultiselect,
+      selectPrompt
+    } = require_search_multiselect();
+    var { accent: accent2, danger: danger2, muted: muted2, strong: strong2, success: success2, warm: warm2 } = require_theme();
+    var STATUS_MARKER = muted2("\u2022");
+    async function promptForSkills2(skills, options = {}) {
+      const items = skills.map((skill) => ({
+        value: skill,
+        label: skill.name,
+        hint: options.details ? skill.description : skill.shortDescription || skill.description,
+        badges: splitRepositoryField(skill.repository)
+      }));
+      return searchMultiselect({
+        message: "Select skills to install",
+        items,
+        required: true,
+        emptyText: "No skills match the current filter."
+      });
+    }
+    async function promptForTargets2() {
+      return multiselectPrompt({
+        message: "Choose install targets",
+        items: INSTALL_TARGETS2.map((target) => ({
+          value: target.key,
+          label: target.name,
+          hint: `${target.folder}/skills`
+        })),
+        initialValues: INSTALL_TARGETS2.filter((target) => target.key !== "claude").map((target) => target.key),
+        required: true,
+        instructions: "Use arrows to move, space to toggle, a for all, then press enter to confirm."
+      });
+    }
+    async function promptForScope2() {
+      return selectPrompt({
+        message: "Install location",
+        items: [
+          {
+            value: "global",
+            label: "Global",
+            hint: "Available everywhere on this machine"
+          },
+          {
+            value: "project",
+            label: "Project",
+            hint: "Available only in the current project folder"
+          }
+        ],
+        required: true
+      });
+    }
+    async function promptForInstallMode2() {
+      return selectPrompt({
+        message: "Installation method",
+        items: [
+          {
+            value: "symlink",
+            label: "Symlink",
+            hint: "Link each selected target directly to the source skill directory"
+          },
+          {
+            value: "copy",
+            label: "Copy",
+            hint: "Copy files directly into each selected target"
+          }
+        ],
+        required: true
+      });
+    }
+    async function confirmOverwrite2() {
+      return confirmPrompt({
+        message: "Overwrite existing installed skills?",
+        active: "Overwrite",
+        inactive: "Skip existing",
+        initialValue: false
+      });
+    }
+    async function createSpinner2() {
+      return createInlineSpinner();
+    }
+    async function intro2() {
+      console.log(`${STATUS_MARKER} ${muted2("synskill installer")}`);
+    }
+    async function outro2(message) {
+      console.log(`${STATUS_MARKER} ${success2(message)}`);
+    }
+    function createInlineSpinner() {
+      const frames = ["-", "\\", "|", "/"];
+      let timer = null;
+      let frameIndex = 0;
+      let activeMessage = "";
+      let visible = false;
+      const render = (message) => {
+        const frame = muted2(frames[frameIndex % frames.length]);
+        process.stdout.write(`\r\x1B[2K${frame} ${strong2(message)}`);
+      };
+      const clear = () => {
+        if (!visible) {
+          return;
+        }
+        process.stdout.write("\r\x1B[2K");
+        visible = false;
+      };
+      const stopTimer = () => {
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+      };
+      return {
+        start(message = "") {
+          stopTimer();
+          activeMessage = message;
+          frameIndex = 0;
+          visible = true;
+          render(activeMessage);
+          timer = setInterval(() => {
+            frameIndex += 1;
+            render(activeMessage);
+          }, 80);
+        },
+        stop(message = activeMessage, state = "success") {
+          stopTimer();
+          clear();
+          const painter = state === "error" ? danger2 : state === "warning" ? warm2 : success2;
+          console.log(`${STATUS_MARKER} ${painter(message)}`);
+        },
+        message(message = "") {
+          activeMessage = message;
+          if (timer) {
+            render(activeMessage);
+          } else {
+            console.log(`${STATUS_MARKER} ${strong2(activeMessage)}`);
+          }
+        }
+      };
+    }
+    module2.exports = {
+      cancelSymbol: cancelSymbol2,
+      confirmOverwrite: confirmOverwrite2,
+      createSpinner: createSpinner2,
+      intro: intro2,
+      outro: outro2,
+      promptForInstallMode: promptForInstallMode2,
+      promptForScope: promptForScope2,
+      promptForSkills: promptForSkills2,
+      promptForTargets: promptForTargets2
+    };
+  }
+});
+
+// src/repo-cache.js
+var require_repo_cache = __commonJS({
+  "src/repo-cache.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path2 = require("path");
+    var {
+      CACHE_TTL_MS,
+      DEFAULT_BRANCH: DEFAULT_BRANCH2,
+      DEFAULT_REPO_URL: DEFAULT_REPO_URL2,
+      getCacheDir,
+      getCacheMetadataPath,
+      LEGACY_CACHE_DIR_NAMES,
+      LEGACY_CACHE_METADATA_NAMES,
+      LEGACY_REPO_ENTRY_FILES,
+      LEGACY_REPO_PACKAGE_NAMES,
+      PRIVATE_REPO_ENV_VAR: PRIVATE_REPO_ENV_VAR2
+    } = require_constants();
+    var { GitCommandError, formatGitAccessError: formatGitAccessError2, runGit, syncInheritedGitConfig } = require_git();
+    function getConfiguredRepoUrl2(options = {}, env = process.env) {
+      return options.repoUrl || env[PRIVATE_REPO_ENV_VAR2] || DEFAULT_REPO_URL2;
+    }
+    function readCacheMetadata(cacheDir) {
+      const metadataPath = getCacheMetadataPath(cacheDir);
+      try {
+        const raw = fs.readFileSync(metadataPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+          return null;
+        }
+        return {
+          repoUrl: typeof parsed.repoUrl === "string" ? parsed.repoUrl : "",
+          branch: typeof parsed.branch === "string" ? parsed.branch : DEFAULT_BRANCH2,
+          lastFetchedAt: Number.isFinite(parsed.lastFetchedAt) ? parsed.lastFetchedAt : 0
+        };
+      } catch {
+        return null;
+      }
+    }
+    function writeCacheMetadata(cacheDir, metadata) {
+      const metadataPath = getCacheMetadataPath(cacheDir);
+      fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+    }
+    function isCacheStale(metadata, now = Date.now()) {
+      if (!metadata || !metadata.lastFetchedAt) {
+        return true;
+      }
+      return now - metadata.lastFetchedAt >= CACHE_TTL_MS;
+    }
+    function dirHasSkillEntries(base) {
+      if (!isDirectory(base)) {
+        return false;
+      }
+      const entries = fs.readdirSync(base, { withFileTypes: true });
+      return entries.some(
+        (entry) => entry.isDirectory() && fs.existsSync(path2.join(base, entry.name, "SKILL.md"))
+      );
+    }
+    function dirHasSkills(root) {
+      return dirHasSkillEntries(path2.join(root, "skills")) || dirHasSkillEntries(root);
+    }
+    function dirHasRepoMarkers(root) {
+      if (fs.existsSync(path2.join(root, "skills.json"))) {
+        return true;
+      }
+      const pkgPath = path2.join(root, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+          if (pkg && (pkg.name === "synskill" || LEGACY_REPO_PACKAGE_NAMES.includes(pkg.name))) {
+            return true;
+          }
+        } catch {
+          return false;
+        }
+      }
+      if (fs.existsSync(path2.join(root, "src", "synskill.js"))) {
+        return true;
+      }
+      return LEGACY_REPO_ENTRY_FILES.some((entryFile) => fs.existsSync(path2.join(root, "src", entryFile)));
+    }
+    function findLocalRepoRoot(startDir) {
+      let dir = path2.resolve(startDir);
+      while (true) {
+        if (dirHasSkills(dir) && dirHasRepoMarkers(dir)) {
+          return dir;
+        }
+        const parent = path2.dirname(dir);
+        if (parent === dir) {
+          return null;
+        }
+        dir = parent;
+      }
+    }
+    function ensureRepoCache(options = {}, deps = {}) {
+      const cacheDir = deps.cacheDir || getCacheDir(deps.homeDir);
+      const gitConfigContextCwd = deps.gitConfigContextCwd || process.cwd();
+      migrateLegacyCache(cacheDir);
+      const repoUrl = options.repoUrl || DEFAULT_REPO_URL2;
+      const branch = options.branch || DEFAULT_BRANCH2;
+      const now = deps.now || Date.now();
+      const logger = deps.logger || null;
+      const forceRefresh = Boolean(options.forceRefresh);
+      const noPull = Boolean(options.noPull);
+      const metadata = readCacheMetadata(cacheDir);
+      const gitDir = path2.join(cacheDir, ".git");
+      const hasGitRepo = isDirectory(gitDir);
+      const remoteUrl = hasGitRepo ? readOriginUrl(cacheDir) : "";
+      if (!hasGitRepo) {
+        recreateCacheDir(cacheDir);
+        cloneRepo(cacheDir, repoUrl, branch, gitConfigContextCwd);
+        const nextMetadata = { repoUrl, branch, lastFetchedAt: now };
+        writeCacheMetadata(cacheDir, nextMetadata);
+        return { path: cacheDir, status: "cloned", metadata: nextMetadata };
+      }
+      if (metadata && metadata.repoUrl && metadata.repoUrl !== repoUrl || remoteUrl && remoteUrl !== repoUrl) {
+        recreateCacheDir(cacheDir);
+        cloneRepo(cacheDir, repoUrl, branch, gitConfigContextCwd);
+        const nextMetadata = { repoUrl, branch, lastFetchedAt: now };
+        writeCacheMetadata(cacheDir, nextMetadata);
+        return { path: cacheDir, status: "recloned", metadata: nextMetadata };
+      }
+      if (forceRefresh) {
+        refreshRepo(cacheDir, repoUrl, branch, gitConfigContextCwd);
+        const nextMetadata = { repoUrl, branch, lastFetchedAt: now };
+        writeCacheMetadata(cacheDir, nextMetadata);
+        return { path: cacheDir, status: "refreshed", metadata: nextMetadata };
+      }
+      if (noPull) {
+        return {
+          path: cacheDir,
+          status: "reused",
+          metadata: metadata || { repoUrl, branch, lastFetchedAt: 0 }
+        };
+      }
+      if (!isCacheStale(metadata, now)) {
+        return { path: cacheDir, status: "reused", metadata };
+      }
+      try {
+        refreshRepo(cacheDir, repoUrl, branch, gitConfigContextCwd);
+        const nextMetadata = { repoUrl, branch, lastFetchedAt: now };
+        writeCacheMetadata(cacheDir, nextMetadata);
+        return { path: cacheDir, status: "refreshed", metadata: nextMetadata };
+      } catch (error) {
+        if (!(error instanceof GitCommandError)) {
+          throw error;
+        }
+        if (logger && typeof logger.warn === "function") {
+          logger.warn(
+            `${formatGitAccessError2(repoUrl, error)}
+Using the existing local cache at ${cacheDir}.`
+          );
+        }
+        return {
+          path: cacheDir,
+          status: "stale",
+          metadata: metadata || { repoUrl, branch, lastFetchedAt: 0 },
+          warning: error
+        };
+      }
+    }
+    function resolveRepoRoot2(options = {}, deps = {}) {
+      const cwd = deps.cwd || process.cwd();
+      const gitConfigContextCwd = deps.gitConfigContextCwd || cwd;
+      const preferLocal = options.preferLocal !== false;
+      const env = deps.env || process.env;
+      const repoUrl = getConfiguredRepoUrl2(options, env);
+      if (preferLocal && !options.repoUrl && !env[PRIVATE_REPO_ENV_VAR2]) {
+        const localRepoRoot = findLocalRepoRoot(cwd);
+        if (localRepoRoot) {
+          return { path: localRepoRoot, status: "local", repoUrl: "" };
+        }
+      }
+      const cacheResult = ensureRepoCache(
+        {
+          repoUrl,
+          branch: options.branch || DEFAULT_BRANCH2,
+          noPull: options.noPull,
+          forceRefresh: options.forceRefresh
+        },
+        { ...deps, gitConfigContextCwd }
+      );
+      return {
+        path: cacheResult.path,
+        status: cacheResult.status,
+        repoUrl,
+        warning: cacheResult.warning
+      };
+    }
+    function cloneRepo(cacheDir, repoUrl, branch, gitConfigContextCwd) {
+      runGit(["clone", "--depth", "1", "--branch", branch, repoUrl, cacheDir], {
+        repoUrl,
+        gitConfigContextCwd
+      });
+      syncInheritedGitConfig(cacheDir, gitConfigContextCwd);
+    }
+    function refreshRepo(cacheDir, repoUrl, branch, gitConfigContextCwd) {
+      syncInheritedGitConfig(cacheDir, gitConfigContextCwd);
+      runGit(["fetch", "--depth", "1", "origin", branch], {
+        cwd: cacheDir,
+        repoUrl,
+        gitConfigContextCwd
+      });
+      runGit(["reset", "--hard", "FETCH_HEAD"], {
+        cwd: cacheDir,
+        repoUrl,
+        gitConfigContextCwd
+      });
+      runGit(["clean", "-fd", "-e", path2.basename(getCacheMetadataPath(cacheDir))], {
+        cwd: cacheDir,
+        repoUrl,
+        gitConfigContextCwd
+      });
+    }
+    function readOriginUrl(cacheDir) {
+      try {
+        const result = runGit(["config", "--get", "remote.origin.url"], { cwd: cacheDir });
+        return result.stdout || "";
+      } catch {
+        return "";
+      }
+    }
+    function recreateCacheDir(cacheDir) {
+      fs.rmSync(cacheDir, { recursive: true, force: true });
+      fs.mkdirSync(path2.dirname(cacheDir), { recursive: true });
+    }
+    function migrateLegacyCache(cacheDir) {
+      const parentDir = path2.dirname(cacheDir);
+      if (fs.existsSync(cacheDir)) {
+        migrateLegacyMetadata(cacheDir);
+        return;
+      }
+      for (const legacyDirName of LEGACY_CACHE_DIR_NAMES) {
+        const legacyCacheDir = path2.join(parentDir, legacyDirName);
+        if (cacheDir === legacyCacheDir || !fs.existsSync(legacyCacheDir)) {
+          continue;
+        }
+        fs.renameSync(legacyCacheDir, cacheDir);
+        migrateLegacyMetadata(cacheDir);
+        return;
+      }
+    }
+    function migrateLegacyMetadata(cacheDir) {
+      for (const legacyMetadataName of LEGACY_CACHE_METADATA_NAMES) {
+        const legacyMetadataPath = path2.join(cacheDir, legacyMetadataName);
+        if (fs.existsSync(legacyMetadataPath) && !fs.existsSync(getCacheMetadataPath(cacheDir))) {
+          fs.renameSync(legacyMetadataPath, getCacheMetadataPath(cacheDir));
+          return;
+        }
+      }
+    }
+    function isDirectory(targetPath) {
+      try {
+        return fs.statSync(targetPath).isDirectory();
+      } catch {
+        return false;
+      }
+    }
+    module2.exports = {
+      dirHasRepoMarkers,
+      dirHasSkillEntries,
+      ensureRepoCache,
+      findLocalRepoRoot,
+      getConfiguredRepoUrl: getConfiguredRepoUrl2,
+      isCacheStale,
+      readCacheMetadata,
+      resolveRepoRoot: resolveRepoRoot2,
+      writeCacheMetadata
+    };
+  }
+});
+
+// src/synskill.js
+var { readFileSync } = require("fs");
+var path = require("path");
+var { parseArgs } = require_args();
+var {
+  CLI_NAME,
+  DEFAULT_BRANCH,
+  DEFAULT_REPO_URL,
+  INSTALL_TARGETS,
+  PRIVATE_REPO_ENV_VAR
+} = require_constants();
+var { formatGitAccessError } = require_git();
+var { buildInstallPlan, hasExistingSkills, installSkills } = require_installer();
+var {
+  cancelSymbol,
+  confirmOverwrite,
+  createSpinner,
+  intro,
+  outro,
+  promptForInstallMode,
+  promptForScope,
+  promptForSkills,
+  promptForTargets
+} = require_prompts();
+var { getConfiguredRepoUrl, resolveRepoRoot } = require_repo_cache();
+var { getExplicitExternalSkills, materializeSkillSources } = require_external_skills();
+var { applyListFilter, filterSkillsByName, findSkills } = require_skill_catalog();
+var { accent, danger, muted, strong, success, warm } = require_theme();
+function usage() {
+  console.log(`${CLI_NAME}`);
+  console.log("");
+  console.log("Commands:");
+  console.log("  install   Install skills (default)");
+  console.log("  add       Alias for install");
+  console.log("  list      List available skills from the private skills repo");
+  console.log("  update    Refresh the local private skills cache");
+  console.log("  help      Show this help");
+  console.log("");
+  console.log("Install options:");
+  console.log("  --dest <path>        Install into a single destination");
+  console.log("  --global             Install to user-level locations");
+  console.log("  --project [path]     Install to project-level locations (default: current directory)");
+  console.log("  [skill ...]          Install one or more skills by positional name");
+  console.log("  --skills <list>      Comma list of skill names to install");
+  console.log("  --all                Install all skills");
+  console.log("  --copy               Copy files instead of symlinking targets to the source skill directory");
+  console.log("  --force              Overwrite existing skills");
+  console.log("  --no-pull            Use the local cache as-is");
+  console.log("  --yes, -y            Skip prompts (defaults to all skills + global + .agents only)");
+  console.log("  --filter <text>      Filter skills by name, description, or repository");
+  console.log("  --details            Show full descriptions");
+  console.log("  --repo-url <git-url> Override the private skills repo URL");
+  console.log("");
+  console.log("List options:");
+  console.log("  --filter <text>      Filter skills by name, description, or repository");
+  console.log("  --details            Show full descriptions");
+  console.log("  --repo-url <git-url> Override the private skills repo URL");
+  console.log("");
+  console.log("Environment:");
+  console.log(`  ${PRIVATE_REPO_ENV_VAR}   Override the private skills repo URL`);
+  console.log("");
+  console.log("Examples:");
+  console.log(`  npx ${CLI_NAME}`);
+  console.log(`  npx ${CLI_NAME} pr-review --project`);
+  console.log(`  npx ${CLI_NAME} skill-creator --global`);
+  console.log(`  npx ${CLI_NAME} install pr-review --project`);
+  console.log(`  npx ${CLI_NAME} add pr-review --project`);
+  console.log(`  npx ${CLI_NAME} list --filter review`);
+  console.log(`  npx ${CLI_NAME} install --skills pr-review --project`);
+  console.log(`  npx ${CLI_NAME} update`);
+}
+async function main() {
+  const { command, options } = parseArgs(process.argv.slice(2));
+  const effectiveCommand = command || "install";
+  switch (effectiveCommand) {
+    case "install":
+    case "add":
+      await runInstall(options);
+      break;
+    case "list":
+      await runList(options);
+      break;
+    case "update":
+      await runUpdate(options);
+      break;
+    case "help":
+      usage();
+      break;
+    case "version":
+      console.log(getVersion());
+      break;
+    default:
+      console.error(`Unknown command: ${effectiveCommand}`);
+      usage();
+      process.exitCode = 1;
+  }
+}
+async function runInstall(options) {
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  const spinner = interactive ? await createSpinner() : null;
+  let preparedSkills = null;
+  try {
+    if (interactive && !options.yes) {
+      await intro();
+    }
+    const explicitExternalSkills = getExplicitExternalSkills(options.skills);
+    const explicitExternalNames = new Set(
+      explicitExternalSkills.map((skill) => skill.name.toLowerCase())
+    );
+    const onlyExplicitExternalSkills = options.skills.length > 0 && options.skills.every((skillName) => explicitExternalNames.has(String(skillName).toLowerCase()));
+    let availableSkills = explicitExternalSkills;
+    if (!onlyExplicitExternalSkills) {
+      const repoRoot = await withSpinner(
+        spinner,
+        "Resolving private skills repo",
+        () => resolveRepoRoot({ ...options, preferLocal: true })
+      );
+      logRepoStatus(repoRoot, options);
+      const skills = await withSpinner(spinner, "Loading skills", () => findSkills(repoRoot.path));
+      availableSkills = mergeExplicitSkills(skills, explicitExternalSkills);
+    }
+    const filteredSkills = applyListFilter(availableSkills, options);
+    if (options.filter && !filteredSkills.length) {
+      throw new Error("No skills match the current filter.");
+    }
+    const selectedSkills = await resolveSelectedSkills(filteredSkills, options, interactive);
+    const scope = await resolveInstallScope(options, interactive);
+    const targetKeys = await resolveTargetKeys(options, interactive);
+    const installMode = await resolveInstallMode(options, targetKeys, interactive);
+    const installPlan = buildInstallPlan(options, targetKeys, scope, installMode);
+    let force = options.force;
+    if (!force && hasExistingSkills(installPlan, selectedSkills)) {
+      if (!interactive || options.yes) {
+        console.log(
+          warm("Some skills already exist and will be skipped. Use --force to overwrite them.")
+        );
+      } else {
+        const overwrite = await confirmOverwrite();
+        if (overwrite === cancelSymbol) {
+          cancel();
+          return;
+        }
+        force = overwrite;
+      }
+    }
+    preparedSkills = await withSpinner(
+      spinner,
+      "Preparing selected skills",
+      () => materializeSkillSources(selectedSkills)
+    );
+    const results = await withSpinner(
+      spinner,
+      "Installing skills",
+      () => installSkills(preparedSkills.skills, installPlan, force)
+    );
+    printInstallResults(results);
+    if (interactive && !options.yes) {
+      await outro("Installation complete. Restart your editor to load new skills.");
+    } else {
+      console.log(success("Done. Restart your editor to load new skills."));
+    }
+  } catch (error) {
+    handleRunError(options, error);
+  } finally {
+    if (preparedSkills) {
+      await preparedSkills.cleanup();
+    }
+  }
+}
+function mergeExplicitSkills(skills, explicitSkills) {
+  if (!explicitSkills.length) {
+    return skills;
+  }
+  const merged = new Map(skills.map((skill) => [skill.name.toLowerCase(), skill]));
+  explicitSkills.forEach((skill) => {
+    merged.set(skill.name.toLowerCase(), skill);
+  });
+  return Array.from(merged.values()).sort((left, right) => left.name.localeCompare(right.name));
+}
+async function runList(options) {
+  const spinner = process.stdout.isTTY ? await createSpinner() : null;
+  try {
+    const repoRoot = await withSpinner(
+      spinner,
+      "Resolving private skills repo",
+      () => resolveRepoRoot({ ...options, preferLocal: true })
+    );
+    logRepoStatus(repoRoot, options);
+    let skills = await withSpinner(spinner, "Loading skills", () => findSkills(repoRoot.path));
+    skills = applyListFilter(skills, options);
+    if (!skills.length) {
+      console.log(muted("No skills found."));
+      return;
+    }
+    console.log(strong("Available skills:"));
+    for (const skill of skills) {
+      const description = options.details ? skill.description : skill.shortDescription || skill.description;
+      const repository = skill.repository || "any";
+      const suffix = description ? ` - ${description}` : "";
+      console.log(` ${accent(">")} ${strong(skill.name)}${muted(suffix ? suffix : "")} ${warm(`[${repository}]`)}`);
+    }
+  } catch (error) {
+    handleRunError(options, error);
+  }
+}
+async function runUpdate(options) {
+  const spinner = process.stdout.isTTY ? await createSpinner() : null;
+  try {
+    await withSpinner(
+      spinner,
+      "Refreshing private skills cache",
+      () => resolveRepoRoot({
+        ...options,
+        repoUrl: getConfiguredRepoUrl(options),
+        branch: DEFAULT_BRANCH,
+        forceRefresh: true,
+        preferLocal: false
+      })
+    );
+    console.log(success("Private skills cache refreshed."));
+  } catch (error) {
+    handleRunError(options, error);
+  }
+}
+async function resolveSelectedSkills(skills, options, interactive) {
+  if (options.all || options.yes) {
+    return skills;
+  }
+  if (options.skills.length) {
+    return filterSkillsByName(skills, options.skills);
+  }
+  if (skills.length === 1) {
+    return skills;
+  }
+  if (!interactive) {
+    throw new Error(
+      "Interactive skill selection is unavailable without a TTY. Use --skills, --all, or --yes."
+    );
+  }
+  const selected = await promptForSkills(skills, options);
+  if (selected === cancelSymbol) {
+    cancel();
+    process.exit(0);
+  }
+  return selected;
+}
+async function resolveTargetKeys(options, interactive) {
+  if (options.dest) {
+    return [];
+  }
+  if (options.yes || !interactive) {
+    return ["agents"];
+  }
+  const selected = await promptForTargets();
+  if (selected === cancelSymbol) {
+    cancel();
+    process.exit(0);
+  }
+  return selected;
+}
+async function resolveInstallScope(options, interactive) {
+  if (options.dest) {
+    return "dest";
+  }
+  if (options.global) {
+    return "global";
+  }
+  if (options.projectPath !== void 0) {
+    return "project";
+  }
+  if (options.yes) {
+    return "global";
+  }
+  if (!interactive) {
+    throw new Error("Install scope requires a TTY. Use --global, --project, --dest, or --yes.");
+  }
+  const scope = await promptForScope();
+  if (scope === cancelSymbol) {
+    cancel();
+    process.exit(0);
+  }
+  return scope;
+}
+async function resolveInstallMode(options, targetKeys, interactive) {
+  if (options.dest || options.copy) {
+    return "copy";
+  }
+  const needsChoice = targetKeys.includes("claude");
+  if (!needsChoice || options.yes || !interactive) {
+    return "symlink";
+  }
+  const installMode = await promptForInstallMode();
+  if (installMode === cancelSymbol) {
+    cancel();
+    process.exit(0);
+  }
+  return installMode;
+}
+function printInstallResults(results) {
+  const installed = results.filter((result) => !result.skipped);
+  const skipped = results.filter((result) => result.skipped);
+  if (installed.length) {
+    console.log(success(`Installed ${installed.length} target${installed.length === 1 ? "" : "s"}:`));
+    installed.forEach((result) => {
+      console.log(`  ${accent(">")} ${strong(result.skill)} ${warm(`[${formatResultMode(result)}]`)} ${muted(`-> ${result.path}`)}`);
+    });
+  }
+  if (skipped.length) {
+    console.log(warm(`Skipped ${skipped.length} existing target${skipped.length === 1 ? "" : "s"}:`));
+    skipped.forEach((result) => {
+      console.log(`  ${accent(">")} ${strong(result.skill)} ${warm(`[${formatResultMode(result)}]`)} ${muted(`-> ${result.path}`)}`);
+    });
+  }
+}
+function formatResultMode(result) {
+  if (result.symlinkFailed) {
+    return "copy-fallback";
+  }
+  return result.mode || "copy";
+}
+function logRepoStatus(repoRoot, options) {
+  if (repoRoot.status === "local") {
+    printDetailLine(`Using the local skills repo at ${repoRoot.path}`);
+    return;
+  }
+  const repoUrl = repoRoot.repoUrl || getConfiguredRepoUrl(options);
+  const repoLabel = repoUrl && repoUrl !== DEFAULT_REPO_URL ? repoUrl : "the private skills repo";
+  switch (repoRoot.status) {
+    case "cloned":
+      printDetailLine(`Cloned ${repoLabel}.`);
+      break;
+    case "recloned":
+      printDetailLine(`Recreated the cached ${repoLabel}.`);
+      break;
+    case "refreshed":
+      printDetailLine("Refreshed the cached private skills repo.");
+      break;
+    case "stale":
+      printDetailLine("Using the existing cached private skills repo because refresh failed.", warm);
+      break;
+    default:
+      printDetailLine("Using the existing cached private skills repo.");
+      break;
+  }
+}
+function printDetailLine(message, tone = muted) {
+  console.log(`${muted("\u2502")}  ${tone(message)}`);
+}
+async function withSpinner(spinner, message, action) {
+  if (spinner) {
+    spinner.start(message);
+  }
+  try {
+    const result = await action();
+    if (spinner) {
+      spinner.stop(message, "success");
+    }
+    return result;
+  } catch (error) {
+    if (spinner) {
+      spinner.stop(message, "error");
+    }
+    throw error;
+  }
+}
+function handleRunError(options, error) {
+  const repoUrl = error && typeof error === "object" && typeof error.repoUrl === "string" && error.repoUrl ? error.repoUrl : getConfiguredRepoUrl(options);
+  const message = error && typeof error === "object" && error.isAuthError !== void 0 ? formatGitAccessError(repoUrl, error) : error.message || String(error);
+  console.error(danger(`Error: ${message}`));
+  process.exitCode = 1;
+}
+function cancel() {
+}
+function getVersion() {
+  try {
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+main().catch((error) => {
+  console.error(danger(`Error: ${error.message || String(error)}`));
+  process.exit(1);
+});