@synapsync/synk 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,4066 @@
+#!/usr/bin/env node
+import { r as __toESM } from "./_chunks/rolldown-runtime.mjs";
+import { d as require_picocolors, l as pD } from "./_chunks/libs/@clack/core.mjs";
+import "./_chunks/libs/cli-cursor.mjs";
+import { t as ora } from "./_chunks/libs/ora.mjs";
+import { n as ve, r as ye, t as fe } from "./_chunks/libs/@clack/prompts.mjs";
+import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
+import "./_chunks/libs/@kwsites/file-exists.mjs";
+import "./_chunks/libs/@kwsites/promise-deferred.mjs";
+import { t as esm_default } from "./_chunks/libs/simple-git.mjs";
+import { t as require_gray_matter } from "./_chunks/libs/gray-matter.mjs";
+import "./_chunks/libs/extend-shallow.mjs";
+import "./_chunks/libs/esprima.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { homedir, platform, tmpdir } from "os";
+import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat, symlink, writeFile } from "fs/promises";
+import "crypto";
+import { execSync, spawnSync } from "child_process";
+import * as readline from "readline";
+import { Writable } from "stream";
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const logger = {
+	log(message = "") {
+		console.log(message);
+	},
+	line() {
+		console.log();
+	},
+	clear() {
+		console.clear();
+	},
+	info(message) {
+		console.log(`${import_picocolors.default.blue("ℹ")} ${message}`);
+	},
+	success(message) {
+		console.log(`${import_picocolors.default.green("✓")} ${message}`);
+	},
+	warning(message) {
+		console.log(`${import_picocolors.default.yellow("⚠")} ${message}`);
+	},
+	error(message) {
+		console.log(`${import_picocolors.default.red("✖")} ${message}`);
+	},
+	debug(message) {
+		if (process.env["DEBUG"]) console.log(`${import_picocolors.default.dim("⋯")} ${import_picocolors.default.dim(message)}`);
+	},
+	bold(message) {
+		console.log(import_picocolors.default.bold(message));
+	},
+	dim(message) {
+		console.log(import_picocolors.default.dim(message));
+	},
+	section(title) {
+		console.log();
+		console.log(import_picocolors.default.bold(import_picocolors.default.cyan(title)));
+	},
+	header(title) {
+		console.log();
+		console.log(import_picocolors.default.bold(import_picocolors.default.cyan(`  ${title}`)));
+		console.log(import_picocolors.default.dim("  " + "─".repeat(title.length + 2)));
+		console.log();
+	},
+	list(items) {
+		items.forEach((item) => console.log(`${import_picocolors.default.dim("  •")} ${item}`));
+	},
+	label(key, value) {
+		console.log(`${import_picocolors.default.dim(`${key}:`)}${" ".repeat(Math.max(1, 10 - key.length))}${value}`);
+	},
+	hint(message) {
+		console.log(import_picocolors.default.dim(message));
+	},
+	command(cmd, description) {
+		console.log(`  ${import_picocolors.default.dim("$")} ${import_picocolors.default.white(cmd)}  ${import_picocolors.default.dim(description)}`);
+	},
+	gradient(line, color) {
+		console.log(`${color}${line}`);
+	},
+	spinner(text) {
+		const s = ora({ stream: process.stdout });
+		if (text) s.start(text);
+		return s;
+	},
+	note(content, title) {
+		console.log();
+		if (title) {
+			console.log(`  ${import_picocolors.default.bold(title)}`);
+			console.log();
+		}
+		for (const line of content.split("\n")) console.log(`  ${line}`);
+		console.log();
+	},
+	intro(title) {
+		console.log();
+		console.log(import_picocolors.default.bgCyan(import_picocolors.default.black(` ${title} `)));
+	},
+	outro(message) {
+		console.log();
+		console.log(message);
+		console.log();
+	},
+	cancel(message) {
+		console.log(`${import_picocolors.default.yellow("◆")} ${message}`);
+	},
+	step(message) {
+		console.log(`${import_picocolors.default.cyan("◆")} ${message}`);
+	},
+	message(message) {
+		console.log(`  ${message}`);
+	}
+};
+function getOwnerRepo(parsed) {
+	if (parsed.type === "local") return null;
+	if (!parsed.url.startsWith("http://") && !parsed.url.startsWith("https://")) return null;
+	try {
+		let path = new URL(parsed.url).pathname.slice(1);
+		path = path.replace(/\.git$/, "");
+		if (path.includes("/")) return path;
+	} catch {}
+	return null;
+}
+function parseOwnerRepo(ownerRepo) {
+	const match = ownerRepo.match(/^([^/]+)\/([^/]+)$/);
+	if (match) return {
+		owner: match[1],
+		repo: match[2]
+	};
+	return null;
+}
+async function isRepoPrivate(owner, repo) {
+	try {
+		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}`);
+		if (!res.ok) return null;
+		return (await res.json()).private === true;
+	} catch {
+		return null;
+	}
+}
+function isLocalPath(input) {
+	return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
+}
+function isDirectSkillUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	if (!input.toLowerCase().endsWith("/skill.md")) return false;
+	if (input.includes("github.com/") && !input.includes("raw.githubusercontent.com")) {
+		if (!input.includes("/blob/") && !input.includes("/raw/")) return false;
+	}
+	if (input.includes("gitlab.com/") && !input.includes("/-/raw/")) return false;
+	return true;
+}
+function parseSource(input) {
+	if (isLocalPath(input)) {
+		const resolvedPath = resolve(input);
+		return {
+			type: "local",
+			url: resolvedPath,
+			localPath: resolvedPath
+		};
+	}
+	if (isDirectSkillUrl(input)) return {
+		type: "direct-url",
+		url: input
+	};
+	const githubTreeWithPathMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+	if (githubTreeWithPathMatch) {
+		const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			ref,
+			subpath
+		};
+	}
+	const githubTreeMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+	if (githubTreeMatch) {
+		const [, owner, repo, ref] = githubTreeMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			ref
+		};
+	}
+	const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+	if (githubRepoMatch) {
+		const [, owner, repo] = githubRepoMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo.replace(/\.git$/, "")}.git`
+		};
+	}
+	const gitlabTreeWithPathMatch = input.match(/^(https?):\/\/([^/]+)\/(.+?)\/-\/tree\/([^/]+)\/(.+)/);
+	if (gitlabTreeWithPathMatch) {
+		const [, protocol, hostname, repoPath, ref, subpath] = gitlabTreeWithPathMatch;
+		if (hostname !== "github.com" && repoPath) return {
+			type: "gitlab",
+			url: `${protocol}://${hostname}/${repoPath.replace(/\.git$/, "")}.git`,
+			ref,
+			subpath
+		};
+	}
+	const gitlabTreeMatch = input.match(/^(https?):\/\/([^/]+)\/(.+?)\/-\/tree\/([^/]+)$/);
+	if (gitlabTreeMatch) {
+		const [, protocol, hostname, repoPath, ref] = gitlabTreeMatch;
+		if (hostname !== "github.com" && repoPath) return {
+			type: "gitlab",
+			url: `${protocol}://${hostname}/${repoPath.replace(/\.git$/, "")}.git`,
+			ref
+		};
+	}
+	const gitlabRepoMatch = input.match(/gitlab\.com\/(.+?)(?:\.git)?\/?$/);
+	if (gitlabRepoMatch) {
+		const repoPath = gitlabRepoMatch[1];
+		if (repoPath.includes("/")) return {
+			type: "gitlab",
+			url: `https://gitlab.com/${repoPath}.git`
+		};
+	}
+	const atSkillMatch = input.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+	if (atSkillMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+		const [, owner, repo, skillFilter] = atSkillMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			skillFilter
+		};
+	}
+	const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+	if (shorthandMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+		const [, owner, repo, subpath] = shorthandMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			subpath
+		};
+	}
+	if (isWellKnownUrl(input)) return {
+		type: "well-known",
+		url: input
+	};
+	return {
+		type: "git",
+		url: input
+	};
+}
+function isWellKnownUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	try {
+		const parsed = new URL(input);
+		if ([
+			"github.com",
+			"gitlab.com",
+			"huggingface.co",
+			"raw.githubusercontent.com"
+		].includes(parsed.hostname)) return false;
+		if (input.toLowerCase().endsWith("/skill.md")) return false;
+		if (input.endsWith(".git")) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+const home = homedir();
+const configHome = xdgConfig ?? join(home, ".config");
+const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+const agents = {
+	amp: {
+		name: "amp",
+		displayName: "Amp",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "agents/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(configHome, "agents/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(configHome, "agents/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "amp"));
+		}
+	},
+	antigravity: {
+		name: "antigravity",
+		displayName: "Antigravity",
+		skillsDir: ".agent/skills",
+		globalSkillsDir: join(home, ".gemini/antigravity/skills"),
+		agentsDir: ".agent/agents",
+		globalAgentsDir: join(home, ".gemini/antigravity/agents"),
+		promptsDir: ".agent/prompts",
+		globalPromptsDir: join(home, ".gemini/antigravity/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"));
+		}
+	},
+	augment: {
+		name: "augment",
+		displayName: "Augment",
+		skillsDir: ".augment/skills",
+		globalSkillsDir: join(home, ".augment/skills"),
+		agentsDir: ".augment/agents",
+		globalAgentsDir: join(home, ".augment/agents"),
+		promptsDir: ".augment/prompts",
+		globalPromptsDir: join(home, ".augment/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".augment"));
+		}
+	},
+	"claude-code": {
+		name: "claude-code",
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		globalSkillsDir: join(claudeHome, "skills"),
+		agentsDir: ".claude/agents",
+		globalAgentsDir: join(claudeHome, "agents"),
+		promptsDir: ".claude/prompts",
+		globalPromptsDir: join(claudeHome, "prompts"),
+		detectInstalled: async () => {
+			return existsSync(claudeHome);
+		}
+	},
+	openclaw: {
+		name: "openclaw",
+		displayName: "OpenClaw",
+		skillsDir: "skills",
+		globalSkillsDir: existsSync(join(home, ".openclaw")) ? join(home, ".openclaw/skills") : existsSync(join(home, ".clawdbot")) ? join(home, ".clawdbot/skills") : join(home, ".moltbot/skills"),
+		agentsDir: "agents",
+		globalAgentsDir: existsSync(join(home, ".openclaw")) ? join(home, ".openclaw/agents") : existsSync(join(home, ".clawdbot")) ? join(home, ".clawdbot/agents") : join(home, ".moltbot/agents"),
+		promptsDir: "prompts",
+		globalPromptsDir: existsSync(join(home, ".openclaw")) ? join(home, ".openclaw/prompts") : existsSync(join(home, ".clawdbot")) ? join(home, ".clawdbot/prompts") : join(home, ".moltbot/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".openclaw")) || existsSync(join(home, ".clawdbot")) || existsSync(join(home, ".moltbot"));
+		}
+	},
+	cline: {
+		name: "cline",
+		displayName: "Cline",
+		skillsDir: ".cline/skills",
+		globalSkillsDir: join(home, ".cline/skills"),
+		agentsDir: ".cline/agents",
+		globalAgentsDir: join(home, ".cline/agents"),
+		promptsDir: ".cline/prompts",
+		globalPromptsDir: join(home, ".cline/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".cline"));
+		}
+	},
+	codebuddy: {
+		name: "codebuddy",
+		displayName: "CodeBuddy",
+		skillsDir: ".codebuddy/skills",
+		globalSkillsDir: join(home, ".codebuddy/skills"),
+		agentsDir: ".codebuddy/agents",
+		globalAgentsDir: join(home, ".codebuddy/agents"),
+		promptsDir: ".codebuddy/prompts",
+		globalPromptsDir: join(home, ".codebuddy/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"));
+		}
+	},
+	codex: {
+		name: "codex",
+		displayName: "Codex",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(codexHome, "skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(codexHome, "agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(codexHome, "prompts"),
+		detectInstalled: async () => {
+			return existsSync(codexHome) || existsSync("/etc/codex");
+		}
+	},
+	"command-code": {
+		name: "command-code",
+		displayName: "Command Code",
+		skillsDir: ".commandcode/skills",
+		globalSkillsDir: join(home, ".commandcode/skills"),
+		agentsDir: ".commandcode/agents",
+		globalAgentsDir: join(home, ".commandcode/agents"),
+		promptsDir: ".commandcode/prompts",
+		globalPromptsDir: join(home, ".commandcode/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".commandcode"));
+		}
+	},
+	continue: {
+		name: "continue",
+		displayName: "Continue",
+		skillsDir: ".continue/skills",
+		globalSkillsDir: join(home, ".continue/skills"),
+		agentsDir: ".continue/agents",
+		globalAgentsDir: join(home, ".continue/agents"),
+		promptsDir: ".continue/prompts",
+		globalPromptsDir: join(home, ".continue/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"));
+		}
+	},
+	crush: {
+		name: "crush",
+		displayName: "Crush",
+		skillsDir: ".crush/skills",
+		globalSkillsDir: join(home, ".config/crush/skills"),
+		agentsDir: ".crush/agents",
+		globalAgentsDir: join(home, ".config/crush/agents"),
+		promptsDir: ".crush/prompts",
+		globalPromptsDir: join(home, ".config/crush/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".config/crush"));
+		}
+	},
+	cursor: {
+		name: "cursor",
+		displayName: "Cursor",
+		skillsDir: ".cursor/skills",
+		globalSkillsDir: join(home, ".cursor/skills"),
+		agentsDir: ".cursor/agents",
+		globalAgentsDir: join(home, ".cursor/agents"),
+		promptsDir: ".cursor/prompts",
+		globalPromptsDir: join(home, ".cursor/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".cursor"));
+		}
+	},
+	droid: {
+		name: "droid",
+		displayName: "Droid",
+		skillsDir: ".factory/skills",
+		globalSkillsDir: join(home, ".factory/skills"),
+		agentsDir: ".factory/agents",
+		globalAgentsDir: join(home, ".factory/agents"),
+		promptsDir: ".factory/prompts",
+		globalPromptsDir: join(home, ".factory/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".factory"));
+		}
+	},
+	"gemini-cli": {
+		name: "gemini-cli",
+		displayName: "Gemini CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".gemini/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(home, ".gemini/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(home, ".gemini/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".gemini"));
+		}
+	},
+	"github-copilot": {
+		name: "github-copilot",
+		displayName: "GitHub Copilot",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".copilot/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(home, ".copilot/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(home, ".copilot/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"));
+		}
+	},
+	goose: {
+		name: "goose",
+		displayName: "Goose",
+		skillsDir: ".goose/skills",
+		globalSkillsDir: join(configHome, "goose/skills"),
+		agentsDir: ".goose/agents",
+		globalAgentsDir: join(configHome, "goose/agents"),
+		promptsDir: ".goose/prompts",
+		globalPromptsDir: join(configHome, "goose/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "goose"));
+		}
+	},
+	junie: {
+		name: "junie",
+		displayName: "Junie",
+		skillsDir: ".junie/skills",
+		globalSkillsDir: join(home, ".junie/skills"),
+		agentsDir: ".junie/agents",
+		globalAgentsDir: join(home, ".junie/agents"),
+		promptsDir: ".junie/prompts",
+		globalPromptsDir: join(home, ".junie/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".junie"));
+		}
+	},
+	"iflow-cli": {
+		name: "iflow-cli",
+		displayName: "iFlow CLI",
+		skillsDir: ".iflow/skills",
+		globalSkillsDir: join(home, ".iflow/skills"),
+		agentsDir: ".iflow/agents",
+		globalAgentsDir: join(home, ".iflow/agents"),
+		promptsDir: ".iflow/prompts",
+		globalPromptsDir: join(home, ".iflow/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".iflow"));
+		}
+	},
+	kilo: {
+		name: "kilo",
+		displayName: "Kilo Code",
+		skillsDir: ".kilocode/skills",
+		globalSkillsDir: join(home, ".kilocode/skills"),
+		agentsDir: ".kilocode/agents",
+		globalAgentsDir: join(home, ".kilocode/agents"),
+		promptsDir: ".kilocode/prompts",
+		globalPromptsDir: join(home, ".kilocode/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kilocode"));
+		}
+	},
+	"kimi-cli": {
+		name: "kimi-cli",
+		displayName: "Kimi Code CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".config/agents/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(home, ".config/agents/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(home, ".config/agents/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kimi"));
+		}
+	},
+	"kiro-cli": {
+		name: "kiro-cli",
+		displayName: "Kiro CLI",
+		skillsDir: ".kiro/skills",
+		globalSkillsDir: join(home, ".kiro/skills"),
+		agentsDir: ".kiro/agents",
+		globalAgentsDir: join(home, ".kiro/agents"),
+		promptsDir: ".kiro/prompts",
+		globalPromptsDir: join(home, ".kiro/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kiro"));
+		}
+	},
+	kode: {
+		name: "kode",
+		displayName: "Kode",
+		skillsDir: ".kode/skills",
+		globalSkillsDir: join(home, ".kode/skills"),
+		agentsDir: ".kode/agents",
+		globalAgentsDir: join(home, ".kode/agents"),
+		promptsDir: ".kode/prompts",
+		globalPromptsDir: join(home, ".kode/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kode"));
+		}
+	},
+	mcpjam: {
+		name: "mcpjam",
+		displayName: "MCPJam",
+		skillsDir: ".mcpjam/skills",
+		globalSkillsDir: join(home, ".mcpjam/skills"),
+		agentsDir: ".mcpjam/agents",
+		globalAgentsDir: join(home, ".mcpjam/agents"),
+		promptsDir: ".mcpjam/prompts",
+		globalPromptsDir: join(home, ".mcpjam/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".mcpjam"));
+		}
+	},
+	"mistral-vibe": {
+		name: "mistral-vibe",
+		displayName: "Mistral Vibe",
+		skillsDir: ".vibe/skills",
+		globalSkillsDir: join(home, ".vibe/skills"),
+		agentsDir: ".vibe/agents",
+		globalAgentsDir: join(home, ".vibe/agents"),
+		promptsDir: ".vibe/prompts",
+		globalPromptsDir: join(home, ".vibe/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".vibe"));
+		}
+	},
+	mux: {
+		name: "mux",
+		displayName: "Mux",
+		skillsDir: ".mux/skills",
+		globalSkillsDir: join(home, ".mux/skills"),
+		agentsDir: ".mux/agents",
+		globalAgentsDir: join(home, ".mux/agents"),
+		promptsDir: ".mux/prompts",
+		globalPromptsDir: join(home, ".mux/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".mux"));
+		}
+	},
+	opencode: {
+		name: "opencode",
+		displayName: "OpenCode",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "opencode/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(configHome, "opencode/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(configHome, "opencode/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "opencode")) || existsSync(join(claudeHome, "skills"));
+		}
+	},
+	openhands: {
+		name: "openhands",
+		displayName: "OpenHands",
+		skillsDir: ".openhands/skills",
+		globalSkillsDir: join(home, ".openhands/skills"),
+		agentsDir: ".openhands/agents",
+		globalAgentsDir: join(home, ".openhands/agents"),
+		promptsDir: ".openhands/prompts",
+		globalPromptsDir: join(home, ".openhands/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".openhands"));
+		}
+	},
+	pi: {
+		name: "pi",
+		displayName: "Pi",
+		skillsDir: ".pi/skills",
+		globalSkillsDir: join(home, ".pi/agent/skills"),
+		agentsDir: ".pi/agents",
+		globalAgentsDir: join(home, ".pi/agent/agents"),
+		promptsDir: ".pi/prompts",
+		globalPromptsDir: join(home, ".pi/agent/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".pi/agent"));
+		}
+	},
+	qoder: {
+		name: "qoder",
+		displayName: "Qoder",
+		skillsDir: ".qoder/skills",
+		globalSkillsDir: join(home, ".qoder/skills"),
+		agentsDir: ".qoder/agents",
+		globalAgentsDir: join(home, ".qoder/agents"),
+		promptsDir: ".qoder/prompts",
+		globalPromptsDir: join(home, ".qoder/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".qoder"));
+		}
+	},
+	"qwen-code": {
+		name: "qwen-code",
+		displayName: "Qwen Code",
+		skillsDir: ".qwen/skills",
+		globalSkillsDir: join(home, ".qwen/skills"),
+		agentsDir: ".qwen/agents",
+		globalAgentsDir: join(home, ".qwen/agents"),
+		promptsDir: ".qwen/prompts",
+		globalPromptsDir: join(home, ".qwen/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".qwen"));
+		}
+	},
+	replit: {
+		name: "replit",
+		displayName: "Replit",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "agents/skills"),
+		agentsDir: ".agents/agents",
+		globalAgentsDir: join(configHome, "agents/agents"),
+		promptsDir: ".agents/prompts",
+		globalPromptsDir: join(configHome, "agents/prompts"),
+		showInUniversalList: false,
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".agents"));
+		}
+	},
+	roo: {
+		name: "roo",
+		displayName: "Roo Code",
+		skillsDir: ".roo/skills",
+		globalSkillsDir: join(home, ".roo/skills"),
+		agentsDir: ".roo/agents",
+		globalAgentsDir: join(home, ".roo/agents"),
+		promptsDir: ".roo/prompts",
+		globalPromptsDir: join(home, ".roo/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".roo"));
+		}
+	},
+	trae: {
+		name: "trae",
+		displayName: "Trae",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join(home, ".trae/skills"),
+		agentsDir: ".trae/agents",
+		globalAgentsDir: join(home, ".trae/agents"),
+		promptsDir: ".trae/prompts",
+		globalPromptsDir: join(home, ".trae/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".trae"));
+		}
+	},
+	"trae-cn": {
+		name: "trae-cn",
+		displayName: "Trae CN",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join(home, ".trae-cn/skills"),
+		agentsDir: ".trae/agents",
+		globalAgentsDir: join(home, ".trae-cn/agents"),
+		promptsDir: ".trae/prompts",
+		globalPromptsDir: join(home, ".trae-cn/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".trae-cn"));
+		}
+	},
+	windsurf: {
+		name: "windsurf",
+		displayName: "Windsurf",
+		skillsDir: ".windsurf/skills",
+		globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+		agentsDir: ".windsurf/agents",
+		globalAgentsDir: join(home, ".codeium/windsurf/agents"),
+		promptsDir: ".windsurf/prompts",
+		globalPromptsDir: join(home, ".codeium/windsurf/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".codeium/windsurf"));
+		}
+	},
+	zencoder: {
+		name: "zencoder",
+		displayName: "Zencoder",
+		skillsDir: ".zencoder/skills",
+		globalSkillsDir: join(home, ".zencoder/skills"),
+		agentsDir: ".zencoder/agents",
+		globalAgentsDir: join(home, ".zencoder/agents"),
+		promptsDir: ".zencoder/prompts",
+		globalPromptsDir: join(home, ".zencoder/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".zencoder"));
+		}
+	},
+	neovate: {
+		name: "neovate",
+		displayName: "Neovate",
+		skillsDir: ".neovate/skills",
+		globalSkillsDir: join(home, ".neovate/skills"),
+		agentsDir: ".neovate/agents",
+		globalAgentsDir: join(home, ".neovate/agents"),
+		promptsDir: ".neovate/prompts",
+		globalPromptsDir: join(home, ".neovate/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".neovate"));
+		}
+	},
+	pochi: {
+		name: "pochi",
+		displayName: "Pochi",
+		skillsDir: ".pochi/skills",
+		globalSkillsDir: join(home, ".pochi/skills"),
+		agentsDir: ".pochi/agents",
+		globalAgentsDir: join(home, ".pochi/agents"),
+		promptsDir: ".pochi/prompts",
+		globalPromptsDir: join(home, ".pochi/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".pochi"));
+		}
+	},
+	adal: {
+		name: "adal",
+		displayName: "AdaL",
+		skillsDir: ".adal/skills",
+		globalSkillsDir: join(home, ".adal/skills"),
+		agentsDir: ".adal/agents",
+		globalAgentsDir: join(home, ".adal/agents"),
+		promptsDir: ".adal/prompts",
+		globalPromptsDir: join(home, ".adal/prompts"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".adal"));
+		}
+	}
+};
+async function detectInstalledAgents() {
+	return (await Promise.all(Object.entries(agents).map(async ([type, config]) => ({
+		type,
+		installed: await config.detectInstalled()
+	})))).filter((r) => r.installed).map((r) => r.type);
+}
+const AGENTS_DIR$3 = ".agents";
+const COGNITIVE_SUBDIRS = {
+	skill: "skills",
+	agent: "agents",
+	prompt: "prompts"
+};
+const COGNITIVE_FILE_NAMES = {
+	skill: "SKILL.md",
+	agent: "AGENT.md",
+	prompt: "PROMPT.md"
+};
+function getUniversalAgents() {
+	return Object.entries(agents).filter(([_, config]) => config.skillsDir === ".agents/skills" && config.showInUniversalList !== false).map(([type]) => type);
+}
+function getNonUniversalAgents() {
+	return Object.entries(agents).filter(([_, config]) => config.skillsDir !== ".agents/skills").map(([type]) => type);
+}
+function isUniversalAgent(type) {
+	return agents[type].skillsDir === ".agents/skills";
+}
+function getCognitiveDir(agentType, cognitiveType, scope) {
+	const agent = agents[agentType];
+	if (scope === "global") switch (cognitiveType) {
+		case "skill": return agent.globalSkillsDir;
+		case "agent": return agent.globalAgentsDir;
+		case "prompt": return agent.globalPromptsDir;
+	}
+	else switch (cognitiveType) {
+		case "skill": return agent.skillsDir;
+		case "agent": return agent.agentsDir;
+		case "prompt": return agent.promptsDir;
+	}
+}
+function isUniversalForType(agentType, cognitiveType) {
+	const agent = agents[agentType];
+	const universalDir = `.agents/${COGNITIVE_SUBDIRS[cognitiveType]}`;
+	switch (cognitiveType) {
+		case "skill": return agent.skillsDir === universalDir;
+		case "agent": return agent.agentsDir === universalDir;
+		case "prompt": return agent.promptsDir === universalDir;
+	}
+}
+function shortenPath$1(fullPath, cwd) {
+	const home = homedir();
+	if (fullPath === home || fullPath.startsWith(home + sep)) return "~" + fullPath.slice(home.length);
+	if (fullPath === cwd || fullPath.startsWith(cwd + sep)) return "." + fullPath.slice(cwd.length);
+	return fullPath;
+}
+function formatList$1(items, maxShow = 5) {
+	if (items.length <= maxShow) return items.join(", ");
+	const shown = items.slice(0, maxShow);
+	const remaining = items.length - maxShow;
+	return `${shown.join(", ")} +${remaining} more`;
+}
+function splitAgentsByType(agentTypes) {
+	const universal = [];
+	const symlinked = [];
+	for (const a of agentTypes) if (isUniversalAgent(a)) universal.push(agents[a].displayName);
+	else symlinked.push(agents[a].displayName);
+	return {
+		universal,
+		symlinked
+	};
+}
+function buildAgentSummaryLines(targetAgents, installMode) {
+	const lines = [];
+	const { universal, symlinked } = splitAgentsByType(targetAgents);
+	if (installMode === "symlink") {
+		if (universal.length > 0) lines.push(`  ${import_picocolors.default.green("universal:")} ${formatList$1(universal)}`);
+		if (symlinked.length > 0) lines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(symlinked)}`);
+	} else {
+		const allNames = targetAgents.map((a) => agents[a].displayName);
+		lines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(allNames)}`);
+	}
+	return lines;
+}
+function ensureUniversalAgents(targetAgents) {
+	const universalAgents = getUniversalAgents();
+	const result = [...targetAgents];
+	for (const ua of universalAgents) if (!result.includes(ua)) result.push(ua);
+	return result;
+}
+function buildResultLines(results, targetAgents) {
+	const lines = [];
+	const { universal, symlinked: symlinkAgents } = splitAgentsByType(targetAgents);
+	const successfulSymlinks = results.filter((r) => !r.symlinkFailed && !universal.includes(r.agent)).map((r) => r.agent);
+	const failedSymlinks = results.filter((r) => r.symlinkFailed).map((r) => r.agent);
+	if (universal.length > 0) lines.push(`  ${import_picocolors.default.green("universal:")} ${formatList$1(universal)}`);
+	if (successfulSymlinks.length > 0) lines.push(`  ${import_picocolors.default.dim("symlinked:")} ${formatList$1(successfulSymlinks)}`);
+	if (failedSymlinks.length > 0) lines.push(`  ${import_picocolors.default.yellow("copied:")} ${formatList$1(failedSymlinks)}`);
+	return lines;
+}
+const AGENTS_DIR$2 = ".agents";
+const LOCK_FILE$2 = ".skill-lock.json";
+const CURRENT_VERSION = 4;
+function getSkillLockPath$2() {
+	return join(homedir(), AGENTS_DIR$2, LOCK_FILE$2);
+}
+async function readSkillLock$2() {
+	const lockPath = getSkillLockPath$2();
+	try {
+		const content = await readFile(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptyLockFile();
+		if (parsed.version < CURRENT_VERSION) return createEmptyLockFile();
+		return parsed;
+	} catch (error) {
+		return createEmptyLockFile();
+	}
+}
+async function writeSkillLock(lock) {
+	const lockPath = getSkillLockPath$2();
+	await mkdir(dirname(lockPath), { recursive: true });
+	await writeFile(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+}
+function getGitHubToken() {
+	if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+	if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+	try {
+		const token = execSync("gh auth token", {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+		if (token) return token;
+	} catch {}
+	return null;
+}
+async function fetchSkillFolderHash(ownerRepo, skillPath, token) {
+	let folderPath = skillPath.replace(/\\/g, "/");
+	if (folderPath.endsWith("/SKILL.md")) folderPath = folderPath.slice(0, -9);
+	else if (folderPath.endsWith("SKILL.md")) folderPath = folderPath.slice(0, -8);
+	if (folderPath.endsWith("/")) folderPath = folderPath.slice(0, -1);
+	for (const branch of ["main", "master"]) try {
+		const url = `https://api.github.com/repos/${ownerRepo}/git/trees/${branch}?recursive=1`;
+		const headers = {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "skills-cli"
+		};
+		if (token) headers["Authorization"] = `Bearer ${token}`;
+		const response = await fetch(url, { headers });
+		if (!response.ok) continue;
+		const data = await response.json();
+		if (!folderPath) return data.sha;
+		const folderEntry = data.tree.find((entry) => entry.type === "tree" && entry.path === folderPath);
+		if (folderEntry) return folderEntry.sha;
+	} catch {
+		continue;
+	}
+	return null;
+}
+async function addCognitiveToLock(name, cognitiveType, entry) {
+	const lock = await readSkillLock$2();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const existingEntry = lock.skills[name];
+	lock.skills[name] = {
+		...entry,
+		cognitiveType,
+		installedAt: existingEntry?.installedAt ?? now,
+		updatedAt: now
+	};
+	await writeSkillLock(lock);
+}
+async function addSkillToLock(skillName, entry) {
+	return addCognitiveToLock(skillName, "skill", entry);
+}
+async function removeSkillFromLock(skillName) {
+	const lock = await readSkillLock$2();
+	if (!(skillName in lock.skills)) return false;
+	delete lock.skills[skillName];
+	await writeSkillLock(lock);
+	return true;
+}
+async function getSkillFromLock(skillName) {
+	return (await readSkillLock$2()).skills[skillName] ?? null;
+}
+function createEmptyLockFile() {
+	return {
+		version: CURRENT_VERSION,
+		skills: {},
+		dismissed: {}
+	};
+}
+async function isPromptDismissed(promptKey) {
+	return (await readSkillLock$2()).dismissed?.[promptKey] === true;
+}
+async function dismissPrompt(promptKey) {
+	const lock = await readSkillLock$2();
+	if (!lock.dismissed) lock.dismissed = {};
+	lock.dismissed[promptKey] = true;
+	await writeSkillLock(lock);
+}
+async function getLastSelectedAgents() {
+	return (await readSkillLock$2()).lastSelectedAgents;
+}
+async function saveSelectedAgents(agents) {
+	const lock = await readSkillLock$2();
+	lock.lastSelectedAgents = agents;
+	await writeSkillLock(lock);
+}
+const silentOutput = new Writable({ write(_chunk, _encoding, callback) {
+	callback();
+} });
+const S_STEP_ACTIVE = import_picocolors.default.green("◆");
+const S_STEP_CANCEL = import_picocolors.default.red("■");
+const S_STEP_SUBMIT = import_picocolors.default.green("◇");
+const S_RADIO_ACTIVE = import_picocolors.default.green("●");
+const S_RADIO_INACTIVE = import_picocolors.default.dim("○");
+const S_CHECKBOX_LOCKED = import_picocolors.default.green("✓");
+const S_BAR = import_picocolors.default.dim("│");
+const S_BAR_H = import_picocolors.default.dim("─");
+const cancelSymbol = Symbol("cancel");
+async function searchMultiselect(options) {
+	const { message, items, maxVisible = 8, initialSelected = [], required = false, lockedSection } = options;
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: silentOutput,
+			terminal: false
+		});
+		if (process.stdin.isTTY) process.stdin.setRawMode(true);
+		readline.emitKeypressEvents(process.stdin, rl);
+		let query = "";
+		let cursor = 0;
+		const selected = new Set(initialSelected);
+		let lastRenderHeight = 0;
+		const lockedValues = lockedSection ? lockedSection.items.map((i) => i.value) : [];
+		const filter = (item, q) => {
+			if (!q) return true;
+			const lowerQ = q.toLowerCase();
+			return item.label.toLowerCase().includes(lowerQ) || String(item.value).toLowerCase().includes(lowerQ);
+		};
+		const getFiltered = () => {
+			return items.filter((item) => filter(item, query));
+		};
+		const clearRender = () => {
+			if (lastRenderHeight > 0) {
+				process.stdout.write(`\x1b[${lastRenderHeight}A`);
+				for (let i = 0; i < lastRenderHeight; i++) process.stdout.write("\x1B[2K\x1B[1B");
+				process.stdout.write(`\x1b[${lastRenderHeight}A`);
+			}
+		};
+		const render = (state = "active") => {
+			clearRender();
+			const lines = [];
+			const filtered = getFiltered();
+			const icon = state === "active" ? S_STEP_ACTIVE : state === "cancel" ? S_STEP_CANCEL : S_STEP_SUBMIT;
+			lines.push(`${icon}  ${import_picocolors.default.bold(message)}`);
+			if (state === "active") {
+				if (lockedSection && lockedSection.items.length > 0) {
+					lines.push(`${S_BAR}`);
+					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold(lockedSection.title)} ${S_BAR_H.repeat(30)}`);
+					for (const item of lockedSection.items) lines.push(`${S_BAR}    ${S_CHECKBOX_LOCKED} ${item.label}`);
+					lines.push(`${S_BAR}`);
+					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold("Other agents")} ${S_BAR_H.repeat(34)}`);
+				}
+				const searchLine = `${S_BAR}  ${import_picocolors.default.dim("Search:")} ${query}${import_picocolors.default.inverse(" ")}`;
+				lines.push(searchLine);
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim("↑↓ move, space select, enter confirm")}`);
+				lines.push(`${S_BAR}`);
+				const visibleStart = Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), filtered.length - maxVisible));
+				const visibleEnd = Math.min(filtered.length, visibleStart + maxVisible);
+				const visibleItems = filtered.slice(visibleStart, visibleEnd);
+				if (filtered.length === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("No matches found")}`);
+				else {
+					for (let i = 0; i < visibleItems.length; i++) {
+						const item = visibleItems[i];
+						const actualIndex = visibleStart + i;
+						const isSelected = selected.has(item.value);
+						const isCursor = actualIndex === cursor;
+						const radio = isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE;
+						const label = isCursor ? import_picocolors.default.underline(item.label) : item.label;
+						const hint = item.hint ? import_picocolors.default.dim(` (${item.hint})`) : "";
+						const prefix = isCursor ? import_picocolors.default.cyan("❯") : " ";
+						lines.push(`${S_BAR} ${prefix} ${radio} ${label}${hint}`);
+					}
+					const hiddenBefore = visibleStart;
+					const hiddenAfter = filtered.length - visibleEnd;
+					if (hiddenBefore > 0 || hiddenAfter > 0) {
+						const parts = [];
+						if (hiddenBefore > 0) parts.push(`↑ ${hiddenBefore} more`);
+						if (hiddenAfter > 0) parts.push(`↓ ${hiddenAfter} more`);
+						lines.push(`${S_BAR}  ${import_picocolors.default.dim(parts.join("  "))}`);
+					}
+				}
+				lines.push(`${S_BAR}`);
+				const allSelectedLabels = [...lockedSection ? lockedSection.items.map((i) => i.label) : [], ...items.filter((item) => selected.has(item.value)).map((item) => item.label)];
+				if (allSelectedLabels.length === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("Selected: (none)")}`);
+				else {
+					const summary = allSelectedLabels.length <= 3 ? allSelectedLabels.join(", ") : `${allSelectedLabels.slice(0, 3).join(", ")} +${allSelectedLabels.length - 3} more`;
+					lines.push(`${S_BAR}  ${import_picocolors.default.green("Selected:")} ${summary}`);
+				}
+				lines.push(`${import_picocolors.default.dim("└")}`);
+			} else if (state === "submit") {
+				const allSelectedLabels = [...lockedSection ? lockedSection.items.map((i) => i.label) : [], ...items.filter((item) => selected.has(item.value)).map((item) => item.label)];
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim(allSelectedLabels.join(", "))}`);
+			} else if (state === "cancel") lines.push(`${S_BAR}  ${import_picocolors.default.strikethrough(import_picocolors.default.dim("Cancelled"))}`);
+			process.stdout.write(lines.join("\n") + "\n");
+			lastRenderHeight = lines.length;
+		};
+		const cleanup = () => {
+			process.stdin.removeListener("keypress", keypressHandler);
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			rl.close();
+		};
+		const submit = () => {
+			if (required && selected.size === 0 && lockedValues.length === 0) return;
+			render("submit");
+			cleanup();
+			resolve([...lockedValues, ...Array.from(selected)]);
+		};
+		const cancel = () => {
+			render("cancel");
+			cleanup();
+			resolve(cancelSymbol);
+		};
+		const keypressHandler = (_str, key) => {
+			if (!key) return;
+			const filtered = getFiltered();
+			if (key.name === "return") {
+				submit();
+				return;
+			}
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cancel();
+				return;
+			}
+			if (key.name === "up") {
+				cursor = Math.max(0, cursor - 1);
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				cursor = Math.min(filtered.length - 1, cursor + 1);
+				render();
+				return;
+			}
+			if (key.name === "space") {
+				const item = filtered[cursor];
+				if (item) if (selected.has(item.value)) selected.delete(item.value);
+				else selected.add(item.value);
+				render();
+				return;
+			}
+			if (key.name === "backspace") {
+				query = query.slice(0, -1);
+				cursor = 0;
+				render();
+				return;
+			}
+			if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+				query += key.sequence;
+				cursor = 0;
+				render();
+				return;
+			}
+		};
+		process.stdin.on("keypress", keypressHandler);
+		render();
+	});
+}
+const isCancelled = (value) => typeof value === "symbol";
+function multiselect(opts) {
+	return fe({
+		...opts,
+		options: opts.options,
+		message: `${opts.message} ${import_picocolors.default.dim("(space to toggle)")}`
+	});
+}
+async function promptForAgents(message, choices) {
+	let lastSelected;
+	try {
+		lastSelected = await getLastSelectedAgents();
+	} catch {}
+	const validAgents = choices.map((c) => c.value);
+	const defaultValues = [
+		"claude-code",
+		"opencode",
+		"codex"
+	].filter((a) => validAgents.includes(a));
+	let initialValues = [];
+	if (lastSelected && lastSelected.length > 0) initialValues = lastSelected.filter((a) => validAgents.includes(a));
+	if (initialValues.length === 0) initialValues = defaultValues;
+	const selected = await searchMultiselect({
+		message,
+		items: choices,
+		initialSelected: initialValues,
+		required: true
+	});
+	if (!isCancelled(selected)) try {
+		await saveSelectedAgents(selected);
+	} catch {}
+	return selected;
+}
+async function selectAgentsInteractive(options) {
+	const supportsGlobalFilter = (a) => !options.global || agents[a].globalSkillsDir;
+	const universalAgents = getUniversalAgents().filter(supportsGlobalFilter);
+	const otherAgents = getNonUniversalAgents().filter(supportsGlobalFilter);
+	const universalSection = {
+		title: "Universal (.agents/skills)",
+		items: universalAgents.map((a) => ({
+			value: a,
+			label: agents[a].displayName
+		}))
+	};
+	const otherChoices = otherAgents.map((a) => ({
+		value: a,
+		label: agents[a].displayName,
+		hint: options.global ? agents[a].globalSkillsDir : agents[a].skillsDir
+	}));
+	let lastSelected;
+	try {
+		lastSelected = await getLastSelectedAgents();
+	} catch {}
+	const selected = await searchMultiselect({
+		message: "Which agents do you want to install to?",
+		items: otherChoices,
+		initialSelected: lastSelected ? lastSelected.filter((a) => otherAgents.includes(a) && !universalAgents.includes(a)) : [],
+		lockedSection: universalSection
+	});
+	if (!isCancelled(selected)) try {
+		await saveSelectedAgents(selected);
+	} catch {}
+	return selected;
+}
+const CLONE_TIMEOUT_MS = 6e4;
+var GitCloneError = class extends Error {
+	url;
+	isTimeout;
+	isAuthError;
+	constructor(message, url, isTimeout = false, isAuthError = false) {
+		super(message);
+		this.name = "GitCloneError";
+		this.url = url;
+		this.isTimeout = isTimeout;
+		this.isAuthError = isAuthError;
+	}
+};
+async function cloneRepo(url, ref) {
+	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
+	const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+	const cloneOptions = ref ? [
+		"--depth",
+		"1",
+		"--branch",
+		ref
+	] : ["--depth", "1"];
+	try {
+		await git.clone(url, tempDir, cloneOptions);
+		return tempDir;
+	} catch (error) {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const isTimeout = errorMessage.includes("block timeout") || errorMessage.includes("timed out");
+		const isAuthError = errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("Permission denied") || errorMessage.includes("Repository not found");
+		if (isTimeout) throw new GitCloneError("Clone timed out after 60s. This often happens with private repos that require authentication.\n  Ensure you have access and your SSH keys or credentials are configured:\n  - For SSH: ssh-add -l (to check loaded keys)\n  - For HTTPS: gh auth status (if using GitHub CLI)", url, true, false);
+		if (isAuthError) throw new GitCloneError(`Authentication failed for ${url}.\n  - For private repos, ensure you have access\n  - For SSH: Check your keys with 'ssh -T git@github.com'\n  - For HTTPS: Run 'gh auth login' or configure git credentials`, url, false, true);
+		throw new GitCloneError(`Failed to clone ${url}: ${errorMessage}`, url, false, false);
+	}
+}
+async function cleanupTempDir(dir) {
+	const normalizedDir = normalize(resolve(dir));
+	const normalizedTmpDir = normalize(resolve(tmpdir()));
+	if (!normalizedDir.startsWith(normalizedTmpDir + sep) && normalizedDir !== normalizedTmpDir) throw new Error("Attempted to clean up directory outside of temp directory");
+	await rm(dir, {
+		recursive: true,
+		force: true
+	});
+}
+var import_gray_matter = /* @__PURE__ */ __toESM(require_gray_matter(), 1);
+function shouldInstallInternalSkills() {
+	const envValue = process.env.INSTALL_INTERNAL_SKILLS;
+	return envValue === "1" || envValue === "true";
+}
+async function hasCognitiveMd(dir, cognitiveType) {
+	try {
+		const fileName = COGNITIVE_FILE_NAMES[cognitiveType];
+		return (await stat(join(dir, fileName))).isFile();
+	} catch {
+		return false;
+	}
+}
+async function parseCognitiveMd(mdPath, cognitiveType, options) {
+	try {
+		const content = await readFile(mdPath, "utf-8");
+		const { data } = (0, import_gray_matter.default)(content);
+		if (!data.name || !data.description) return null;
+		if (data.metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
+		return {
+			name: data.name,
+			description: data.description,
+			path: dirname(mdPath),
+			rawContent: content,
+			metadata: data.metadata,
+			cognitiveType
+		};
+	} catch {
+		return null;
+	}
+}
+async function parseSkillMd(skillMdPath, options) {
+	return parseCognitiveMd(skillMdPath, "skill", options);
+}
+function isContainedIn(targetPath, basePath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function isValidRelativePath(path) {
+	return path.startsWith("./");
+}
+async function getPluginSkillPaths(basePath) {
+	const searchDirs = [];
+	const addPluginSkillPaths = (pluginBase, skills) => {
+		if (!isContainedIn(pluginBase, basePath)) return;
+		if (skills && skills.length > 0) for (const skillPath of skills) {
+			if (!isValidRelativePath(skillPath)) continue;
+			const skillDir = dirname(join(pluginBase, skillPath));
+			if (isContainedIn(skillDir, basePath)) searchDirs.push(skillDir);
+		}
+		searchDirs.push(join(pluginBase, "skills"));
+	};
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		const pluginRoot = manifest.metadata?.pluginRoot;
+		if (pluginRoot === void 0 || isValidRelativePath(pluginRoot)) for (const plugin of manifest.plugins ?? []) {
+			if (typeof plugin.source !== "string" && plugin.source !== void 0) continue;
+			if (plugin.source !== void 0 && !isValidRelativePath(plugin.source)) continue;
+			addPluginSkillPaths(join(basePath, pluginRoot ?? "", plugin.source ?? ""), plugin.skills);
+		}
+	} catch {}
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/plugin.json"), "utf-8");
+		addPluginSkillPaths(basePath, JSON.parse(content).skills);
+	} catch {}
+	return searchDirs;
+}
+const SKIP_DIRS = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"__pycache__"
+];
+const ALL_COGNITIVE_TYPES = [
+	"skill",
+	"agent",
+	"prompt"
+];
+const AGENT_DIR_PREFIXES = [
+	".agent",
+	".agents",
+	".claude",
+	".cline",
+	".codebuddy",
+	".codex",
+	".commandcode",
+	".continue",
+	".cursor",
+	".github",
+	".goose",
+	".iflow",
+	".junie",
+	".kilocode",
+	".kiro",
+	".mux",
+	".neovate",
+	".opencode",
+	".openhands",
+	".pi",
+	".qoder",
+	".roo",
+	".trae",
+	".windsurf",
+	".zencoder"
+];
+async function findCognitiveDirs(dir, types = ALL_COGNITIVE_TYPES, depth = 0, maxDepth = 5) {
+	if (depth > maxDepth) return [];
+	try {
+		const checks = types.map(async (ct) => ({
+			type: ct,
+			found: await hasCognitiveMd(dir, ct)
+		}));
+		const [results, entries] = await Promise.all([Promise.all(checks), readdir(dir, { withFileTypes: true }).catch(() => [])]);
+		const currentDir = results.filter((r) => r.found).map((r) => ({
+			dir,
+			cognitiveType: r.type
+		}));
+		const subDirResults = await Promise.all(entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.includes(entry.name)).map((entry) => findCognitiveDirs(join(dir, entry.name), types, depth + 1, maxDepth)));
+		return [...currentDir, ...subDirResults.flat()];
+	} catch {
+		return [];
+	}
+}
+function buildPrioritySearchDirs(searchPath, cognitiveType) {
+	const subdir = COGNITIVE_SUBDIRS[cognitiveType];
+	const dirs = [
+		searchPath,
+		join(searchPath, subdir),
+		join(searchPath, `${subdir}/.curated`),
+		join(searchPath, `${subdir}/.experimental`),
+		join(searchPath, `${subdir}/.system`)
+	];
+	for (const prefix of AGENT_DIR_PREFIXES) dirs.push(join(searchPath, prefix, subdir));
+	return dirs;
+}
+async function discoverCognitives(basePath, subpath, options) {
+	const types = options?.types ?? ["skill"];
+	const results = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	const searchPath = subpath ? join(basePath, subpath) : basePath;
+	const makeKey = (cognitiveType, name) => `${cognitiveType}::${name}`;
+	const addResult = (skill) => {
+		const key = makeKey(skill.cognitiveType ?? "skill", skill.name);
+		if (seenKeys.has(key)) return false;
+		seenKeys.add(key);
+		results.push(skill);
+		return true;
+	};
+	for (const ct of types) if (await hasCognitiveMd(searchPath, ct)) {
+		const fileName = COGNITIVE_FILE_NAMES[ct];
+		const cognitive = await parseCognitiveMd(join(searchPath, fileName), ct, options);
+		if (cognitive) addResult(cognitive);
+	}
+	if (results.length > 0 && !options?.fullDepth) return results;
+	const allPriorityDirs = /* @__PURE__ */ new Set();
+	const dirTypeMap = /* @__PURE__ */ new Map();
+	for (const ct of types) {
+		const dirs = buildPrioritySearchDirs(searchPath, ct);
+		if (ct === "skill") dirs.push(...await getPluginSkillPaths(searchPath));
+		for (const dir of dirs) {
+			allPriorityDirs.add(dir);
+			if (!dirTypeMap.has(dir)) dirTypeMap.set(dir, /* @__PURE__ */ new Set());
+			dirTypeMap.get(dir).add(ct);
+		}
+	}
+	for (const dir of allPriorityDirs) {
+		const typesForDir = dirTypeMap.get(dir);
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) {
+				const subDir = join(dir, entry.name);
+				for (const ct of typesForDir) if (await hasCognitiveMd(subDir, ct)) {
+					const fileName = COGNITIVE_FILE_NAMES[ct];
+					const cognitive = await parseCognitiveMd(join(subDir, fileName), ct, options);
+					if (cognitive) addResult(cognitive);
+				}
+			}
+		} catch {}
+	}
+	if (results.length === 0 || options?.fullDepth) {
+		const allCognitiveDirs = await findCognitiveDirs(searchPath, types);
+		for (const { dir: cogDir, cognitiveType: ct } of allCognitiveDirs) {
+			const fileName = COGNITIVE_FILE_NAMES[ct];
+			const cognitive = await parseCognitiveMd(join(cogDir, fileName), ct, options);
+			if (cognitive) addResult(cognitive);
+		}
+	}
+	return results;
+}
+async function discoverSkills(basePath, subpath, options) {
+	return discoverCognitives(basePath, subpath, {
+		...options,
+		types: options?.types ?? ["skill"]
+	});
+}
+function getSkillDisplayName(skill) {
+	return skill.name || basename(skill.path);
+}
+function filterSkills(skills, inputNames) {
+	const normalizedInputs = inputNames.map((n) => n.toLowerCase());
+	return skills.filter((skill) => {
+		const name = skill.name.toLowerCase();
+		const displayName = getSkillDisplayName(skill).toLowerCase();
+		return normalizedInputs.some((input) => input === name || input === displayName);
+	});
+}
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
+}
+function isPathSafe(basePath, targetPath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function getCanonicalDir(cognitiveType, global, cwd) {
+	return join(global ? homedir() : cwd || process.cwd(), AGENTS_DIR$3, COGNITIVE_SUBDIRS[cognitiveType]);
+}
+function getInstallPath(skillName, agentType, options = {}) {
+	const cognitiveType = options.cognitiveType ?? "skill";
+	const cwd = options.cwd || process.cwd();
+	const sanitized = sanitizeName(skillName);
+	const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+	const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+	const targetBase = options.global && globalDir !== void 0 ? globalDir : join(cwd, localDir);
+	const installPath = join(targetBase, sanitized);
+	if (!isPathSafe(targetBase, installPath)) throw new Error(`Invalid ${cognitiveType} name: potential path traversal detected`);
+	return installPath;
+}
+function getCanonicalPath(skillName, options = {}) {
+	const cognitiveType = options.cognitiveType ?? "skill";
+	const sanitized = sanitizeName(skillName);
+	const canonicalBase = getCanonicalDir(cognitiveType, options.global ?? false, options.cwd);
+	const canonicalPath = join(canonicalBase, sanitized);
+	if (!isPathSafe(canonicalBase, canonicalPath)) throw new Error(`Invalid ${cognitiveType} name: potential path traversal detected`);
+	return canonicalPath;
+}
+const EXCLUDE_FILES = new Set(["README.md", "metadata.json"]);
+const EXCLUDE_DIRS = new Set([".git"]);
+const isExcluded = (name, isDirectory = false) => {
+	if (EXCLUDE_FILES.has(name)) return true;
+	if (name.startsWith("_")) return true;
+	if (isDirectory && EXCLUDE_DIRS.has(name)) return true;
+	return false;
+};
+async function copyDirectory(src, dest) {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	await Promise.all(entries.filter((entry) => !isExcluded(entry.name, entry.isDirectory())).map(async (entry) => {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (entry.isDirectory()) await copyDirectory(srcPath, destPath);
+		else await cp(srcPath, destPath, {
+			dereference: true,
+			recursive: true
+		});
+	}));
+}
+async function cleanAndCreateDirectory(path) {
+	try {
+		await rm(path, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	await mkdir(path, { recursive: true });
+}
+async function resolveParentSymlinks(path) {
+	const resolved = resolve(path);
+	const dir = dirname(resolved);
+	const base = basename(resolved);
+	try {
+		const { realpath } = await import("fs/promises");
+		return join(await realpath(dir), base);
+	} catch {
+		return resolved;
+	}
+}
+function resolveSymlinkTarget(linkPath, linkTarget) {
+	return resolve(dirname(linkPath), linkTarget);
+}
+async function createSymlink(target, linkPath) {
+	try {
+		const resolvedTarget = resolve(target);
+		if (resolvedTarget === resolve(linkPath)) return true;
+		if (await resolveParentSymlinks(target) === await resolveParentSymlinks(linkPath)) return true;
+		try {
+			if ((await lstat(linkPath)).isSymbolicLink()) {
+				if (resolveSymlinkTarget(linkPath, await readlink(linkPath)) === resolvedTarget) return true;
+				await rm(linkPath);
+			} else await rm(linkPath, { recursive: true });
+		} catch (err) {
+			if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") try {
+				await rm(linkPath, { force: true });
+			} catch {}
+		}
+		const linkDir = dirname(linkPath);
+		await mkdir(linkDir, { recursive: true });
+		await symlink(relative(await resolveParentSymlinks(linkDir), target), linkPath, platform() === "win32" ? "junction" : void 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function installCognitiveForAgent(cognitive, agentType, options = {}) {
+	const cognitiveType = options.cognitiveType ?? "skill";
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+	if (isGlobal && globalDir === void 0) return {
+		success: false,
+		path: "",
+		mode: options.mode ?? "symlink",
+		error: `${agent.displayName} does not support global ${cognitiveType} installation`
+	};
+	const safeName = sanitizeName(cognitive.name || basename(cognitive.path));
+	const canonicalBase = getCanonicalDir(cognitiveType, isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, safeName);
+	const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+	const agentBase = isGlobal ? globalDir : join(cwd, localDir);
+	const agentDir = join(agentBase, safeName);
+	const installMode = options.mode ?? "symlink";
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await copyDirectory(cognitive.path, agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await copyDirectory(cognitive.path, canonicalDir);
+		if (isGlobal && isUniversalForType(agentType, cognitiveType)) return {
+			success: true,
+			path: canonicalDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await copyDirectory(cognitive.path, agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function installRemoteSkillForAgent(skill, agentType, options = {}) {
+	const cognitiveType = options.cognitiveType ?? skill.cognitiveType ?? "skill";
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	const fileName = COGNITIVE_FILE_NAMES[cognitiveType];
+	const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+	if (isGlobal && globalDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global ${cognitiveType} installation`
+	};
+	const skillName = sanitizeName(skill.installName);
+	const canonicalBase = getCanonicalDir(cognitiveType, isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+	const agentBase = isGlobal ? globalDir : join(cwd, localDir);
+	const agentDir = join(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await writeFile(join(agentDir, fileName), skill.content, "utf-8");
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await writeFile(join(canonicalDir, fileName), skill.content, "utf-8");
+		if (isGlobal && isUniversalForType(agentType, cognitiveType)) return {
+			success: true,
+			path: canonicalDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await writeFile(join(agentDir, fileName), skill.content, "utf-8");
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
+	const cognitiveType = options.cognitiveType ?? "skill";
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+	if (isGlobal && globalDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global ${cognitiveType} installation`
+	};
+	const skillName = sanitizeName(skill.installName);
+	const canonicalBase = getCanonicalDir(cognitiveType, isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+	const agentBase = isGlobal ? globalDir : join(cwd, localDir);
+	const agentDir = join(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: `Invalid ${cognitiveType} name: potential path traversal detected`
+	};
+	async function writeSkillFiles(targetDir) {
+		for (const [filePath, content] of skill.files) {
+			const fullPath = join(targetDir, filePath);
+			if (!isPathSafe(targetDir, fullPath)) continue;
+			const parentDir = dirname(fullPath);
+			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
+			await writeFile(fullPath, content, "utf-8");
+		}
+	}
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await writeSkillFiles(canonicalDir);
+		if (isGlobal && isUniversalForType(agentType, cognitiveType)) return {
+			success: true,
+			path: canonicalDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function listInstalledCognitives(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const typesToScan = options.typeFilter ?? [
+		"skill",
+		"agent",
+		"prompt"
+	];
+	const cognitivesMap = /* @__PURE__ */ new Map();
+	const detectedAgents = await detectInstalledAgents();
+	const agentFilter = options.agentFilter;
+	const agentsToCheck = agentFilter ? detectedAgents.filter((a) => agentFilter.includes(a)) : detectedAgents;
+	const scopeTypes = [];
+	if (options.global === void 0) scopeTypes.push({ global: false }, { global: true });
+	else scopeTypes.push({ global: options.global });
+	for (const cognitiveType of typesToScan) {
+		const fileName = COGNITIVE_FILE_NAMES[cognitiveType];
+		const scopes = [];
+		for (const { global: isGlobal } of scopeTypes) {
+			scopes.push({
+				global: isGlobal,
+				path: getCanonicalDir(cognitiveType, isGlobal, cwd)
+			});
+			for (const agentType of agentsToCheck) {
+				const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+				if (isGlobal && globalDir === void 0) continue;
+				const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+				const agentDir = isGlobal ? globalDir : join(cwd, localDir);
+				if (!scopes.some((s) => s.path === agentDir && s.global === isGlobal)) scopes.push({
+					global: isGlobal,
+					path: agentDir,
+					agentType
+				});
+			}
+		}
+		for (const scope of scopes) try {
+			const entries = await readdir(scope.path, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const cognitiveDir = join(scope.path, entry.name);
+				const mdPath = join(cognitiveDir, fileName);
+				try {
+					await stat(mdPath);
+				} catch {
+					continue;
+				}
+				const parsed = cognitiveType === "skill" ? await parseSkillMd(mdPath) : await parseCognitiveMd(mdPath, cognitiveType);
+				if (!parsed) continue;
+				const scopeKey = scope.global ? "global" : "project";
+				const cognitiveKey = `${scopeKey}:${cognitiveType}:${parsed.name}`;
+				if (scope.agentType) {
+					if (cognitivesMap.has(cognitiveKey)) {
+						const existing = cognitivesMap.get(cognitiveKey);
+						if (!existing.agents.includes(scope.agentType)) existing.agents.push(scope.agentType);
+					} else cognitivesMap.set(cognitiveKey, {
+						name: parsed.name,
+						description: parsed.description,
+						path: cognitiveDir,
+						canonicalPath: cognitiveDir,
+						scope: scopeKey,
+						agents: [scope.agentType],
+						cognitiveType
+					});
+					continue;
+				}
+				const sanitizedName = sanitizeName(parsed.name);
+				const installedAgents = [];
+				for (const agentType of agentsToCheck) {
+					const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+					if (scope.global && globalDir === void 0) continue;
+					const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+					const agentBase = scope.global ? globalDir : join(cwd, localDir);
+					let found = false;
+					const possibleNames = Array.from(new Set([
+						entry.name,
+						sanitizedName,
+						parsed.name.toLowerCase().replace(/\s+/g, "-").replace(/[\/\\:\0]/g, "")
+					]));
+					for (const possibleName of possibleNames) {
+						const agentCognitiveDir = join(agentBase, possibleName);
+						if (!isPathSafe(agentBase, agentCognitiveDir)) continue;
+						try {
+							await access(agentCognitiveDir);
+							found = true;
+							break;
+						} catch {}
+					}
+					if (!found) try {
+						const agentEntries = await readdir(agentBase, { withFileTypes: true });
+						for (const agentEntry of agentEntries) {
+							if (!agentEntry.isDirectory()) continue;
+							const candidateDir = join(agentBase, agentEntry.name);
+							if (!isPathSafe(agentBase, candidateDir)) continue;
+							try {
+								const candidateMdPath = join(candidateDir, fileName);
+								await stat(candidateMdPath);
+								const candidateParsed = cognitiveType === "skill" ? await parseSkillMd(candidateMdPath) : await parseCognitiveMd(candidateMdPath, cognitiveType);
+								if (candidateParsed && candidateParsed.name === parsed.name) {
+									found = true;
+									break;
+								}
+							} catch {}
+						}
+					} catch {}
+					if (found) installedAgents.push(agentType);
+				}
+				if (cognitivesMap.has(cognitiveKey)) {
+					const existing = cognitivesMap.get(cognitiveKey);
+					for (const agent of installedAgents) if (!existing.agents.includes(agent)) existing.agents.push(agent);
+				} else cognitivesMap.set(cognitiveKey, {
+					name: parsed.name,
+					description: parsed.description,
+					path: cognitiveDir,
+					canonicalPath: cognitiveDir,
+					scope: scopeKey,
+					agents: installedAgents,
+					cognitiveType
+				});
+			}
+		} catch {}
+	}
+	return Array.from(cognitivesMap.values());
+}
+async function listInstalledSkills(options = {}) {
+	return listInstalledCognitives({
+		...options,
+		typeFilter: ["skill"]
+	});
+}
+async function isCognitiveInstalled(name, agentType, cognitiveType, options = {}) {
+	const sanitized = sanitizeName(name);
+	const globalDir = getCognitiveDir(agentType, cognitiveType, "global");
+	if (options.global && globalDir === void 0) return false;
+	const localDir = getCognitiveDir(agentType, cognitiveType, "local");
+	const targetBase = options.global ? globalDir : join(options.cwd || process.cwd(), localDir);
+	const cognitiveDir = join(targetBase, sanitized);
+	if (!isPathSafe(targetBase, cognitiveDir)) return false;
+	try {
+		await access(cognitiveDir);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+	return isCognitiveInstalled(skillName, agentType, options.cognitiveType ?? "skill", options);
+}
+const TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+let cliVersion = null;
+function isCI() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.BUILDKITE || process.env.JENKINS_URL || process.env.TEAMCITY_VERSION);
+}
+function isEnabled() {
+	return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+function setVersion(version) {
+	cliVersion = version;
+}
+function track(data) {
+	if (!isEnabled()) return;
+	try {
+		const params = new URLSearchParams();
+		if (cliVersion) params.set("v", cliVersion);
+		if (isCI()) params.set("ci", "1");
+		for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) params.set(key, String(value));
+		fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {});
+	} catch {}
+}
+var ProviderRegistryImpl = class {
+	providers = [];
+	register(provider) {
+		if (this.providers.some((p) => p.id === provider.id)) throw new Error(`Provider with id "${provider.id}" already registered`);
+		this.providers.push(provider);
+	}
+	findProvider(url) {
+		for (const provider of this.providers) if (provider.match(url).matches) return provider;
+		return null;
+	}
+	getProviders() {
+		return [...this.providers];
+	}
+};
+const registry = new ProviderRegistryImpl();
+function registerProvider(provider) {
+	registry.register(provider);
+}
+function findProvider(url) {
+	return registry.findProvider(url);
+}
+var MintlifyProvider = class {
+	id = "mintlify";
+	displayName = "Mintlify";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		if (!url.toLowerCase().endsWith("/skill.md")) return { matches: false };
+		if (url.includes("github.com") || url.includes("gitlab.com")) return { matches: false };
+		if (url.includes("huggingface.co")) return { matches: false };
+		return { matches: true };
+	}
+	async fetchSkill(url) {
+		try {
+			const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			const mintlifySite = data.metadata?.["mintlify-proj"];
+			if (!mintlifySite) return null;
+			if (!data.name || !data.description) return null;
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName: mintlifySite,
+				sourceUrl: url,
+				metadata: data.metadata
+			};
+		} catch {
+			return null;
+		}
+	}
+	toRawUrl(url) {
+		return url;
+	}
+	getSourceIdentifier(url) {
+		return "mintlify/com";
+	}
+};
+const mintlifyProvider = new MintlifyProvider();
+var HuggingFaceProvider = class {
+	id = "huggingface";
+	displayName = "HuggingFace";
+	HOST = "huggingface.co";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		try {
+			if (new URL(url).hostname !== this.HOST) return { matches: false };
+		} catch {
+			return { matches: false };
+		}
+		if (!url.toLowerCase().endsWith("/skill.md")) return { matches: false };
+		if (!url.includes("/spaces/")) return { matches: false };
+		return { matches: true };
+	}
+	async fetchSkill(url) {
+		try {
+			const rawUrl = this.toRawUrl(url);
+			const response = await fetch(rawUrl, { signal: AbortSignal.timeout(3e4) });
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			if (!data.name || !data.description) return null;
+			const parsed = this.parseUrl(url);
+			if (!parsed) return null;
+			const installName = data.metadata?.["install-name"] || parsed.repo;
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName,
+				sourceUrl: url,
+				metadata: data.metadata
+			};
+		} catch {
+			return null;
+		}
+	}
+	toRawUrl(url) {
+		return url.replace("/blob/", "/raw/");
+	}
+	getSourceIdentifier(url) {
+		const parsed = this.parseUrl(url);
+		if (!parsed) return "huggingface/unknown";
+		return `huggingface/${parsed.owner}/${parsed.repo}`;
+	}
+	parseUrl(url) {
+		const match = url.match(/\/spaces\/([^/]+)\/([^/]+)/);
+		if (!match || !match[1] || !match[2]) return null;
+		return {
+			owner: match[1],
+			repo: match[2]
+		};
+	}
+};
+const huggingFaceProvider = new HuggingFaceProvider();
+var WellKnownProvider = class {
+	id = "well-known";
+	displayName = "Well-Known Skills";
+	WELL_KNOWN_PATH = ".well-known/skills";
+	INDEX_FILE = "index.json";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		try {
+			const parsed = new URL(url);
+			if ([
+				"github.com",
+				"gitlab.com",
+				"huggingface.co"
+			].includes(parsed.hostname)) return { matches: false };
+			return {
+				matches: true,
+				sourceIdentifier: `wellknown/${parsed.hostname}`
+			};
+		} catch {
+			return { matches: false };
+		}
+	}
+	async fetchIndex(baseUrl) {
+		try {
+			const parsed = new URL(baseUrl);
+			const basePath = parsed.pathname.replace(/\/$/, "");
+			const urlsToTry = [{
+				indexUrl: `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+				baseUrl: `${parsed.protocol}//${parsed.host}${basePath}`
+			}];
+			if (basePath && basePath !== "") urlsToTry.push({
+				indexUrl: `${parsed.protocol}//${parsed.host}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+				baseUrl: `${parsed.protocol}//${parsed.host}`
+			});
+			for (const { indexUrl, baseUrl: resolvedBase } of urlsToTry) try {
+				const response = await fetch(indexUrl);
+				if (!response.ok) continue;
+				const index = await response.json();
+				if (!index.skills || !Array.isArray(index.skills)) continue;
+				let allValid = true;
+				for (const entry of index.skills) if (!this.isValidSkillEntry(entry)) {
+					allValid = false;
+					break;
+				}
+				if (allValid) return {
+					index,
+					resolvedBaseUrl: resolvedBase
+				};
+			} catch {
+				continue;
+			}
+			return null;
+		} catch {
+			return null;
+		}
+	}
+	isValidSkillEntry(entry) {
+		if (!entry || typeof entry !== "object") return false;
+		const e = entry;
+		if (typeof e.name !== "string" || !e.name) return false;
+		if (typeof e.description !== "string" || !e.description) return false;
+		if (!Array.isArray(e.files) || e.files.length === 0) return false;
+		if (!/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/.test(e.name) && e.name.length > 1) {
+			if (e.name.length === 1 && !/^[a-z0-9]$/.test(e.name)) return false;
+		}
+		for (const file of e.files) {
+			if (typeof file !== "string") return false;
+			if (file.startsWith("/") || file.startsWith("\\") || file.includes("..")) return false;
+		}
+		if (!e.files.some((f) => typeof f === "string" && f.toLowerCase() === "skill.md")) return false;
+		return true;
+	}
+	async fetchSkill(url) {
+		try {
+			const parsed = new URL(url);
+			const result = await this.fetchIndex(url);
+			if (!result) return null;
+			const { index, resolvedBaseUrl } = result;
+			let skillName = null;
+			const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+			if (pathMatch && pathMatch[1] && pathMatch[1] !== "index.json") skillName = pathMatch[1];
+			else if (index.skills.length === 1) skillName = index.skills[0].name;
+			if (!skillName) return null;
+			const skillEntry = index.skills.find((s) => s.name === skillName);
+			if (!skillEntry) return null;
+			return this.fetchSkillByEntry(resolvedBaseUrl, skillEntry);
+		} catch {
+			return null;
+		}
+	}
+	async fetchSkillByEntry(baseUrl, entry) {
+		try {
+			const skillBaseUrl = `${baseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${entry.name}`;
+			const skillMdUrl = `${skillBaseUrl}/SKILL.md`;
+			const response = await fetch(skillMdUrl);
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			if (!data.name || !data.description) return null;
+			const files = /* @__PURE__ */ new Map();
+			files.set("SKILL.md", content);
+			const filePromises = entry.files.filter((f) => f.toLowerCase() !== "skill.md").map(async (filePath) => {
+				try {
+					const fileUrl = `${skillBaseUrl}/${filePath}`;
+					const fileResponse = await fetch(fileUrl);
+					if (fileResponse.ok) return {
+						path: filePath,
+						content: await fileResponse.text()
+					};
+				} catch {}
+				return null;
+			});
+			const fileResults = await Promise.all(filePromises);
+			for (const result of fileResults) if (result) files.set(result.path, result.content);
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName: entry.name,
+				sourceUrl: skillMdUrl,
+				metadata: data.metadata,
+				files,
+				indexEntry: entry
+			};
+		} catch {
+			return null;
+		}
+	}
+	async fetchAllSkills(url) {
+		try {
+			const result = await this.fetchIndex(url);
+			if (!result) return [];
+			const { index, resolvedBaseUrl } = result;
+			const skillPromises = index.skills.map((entry) => this.fetchSkillByEntry(resolvedBaseUrl, entry));
+			return (await Promise.all(skillPromises)).filter((s) => s !== null);
+		} catch {
+			return [];
+		}
+	}
+	toRawUrl(url) {
+		try {
+			const parsed = new URL(url);
+			if (url.toLowerCase().endsWith("/skill.md")) return url;
+			const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+			if (pathMatch && pathMatch[1]) {
+				const basePath = parsed.pathname.replace(/\/.well-known\/skills\/.*$/, "");
+				return `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${pathMatch[1]}/SKILL.md`;
+			}
+			const basePath = parsed.pathname.replace(/\/$/, "");
+			return `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+		} catch {
+			return url;
+		}
+	}
+	getSourceIdentifier(url) {
+		try {
+			const parsed = new URL(url);
+			const hostParts = parsed.hostname.split(".");
+			if (hostParts.length >= 2) {
+				const tld = hostParts[hostParts.length - 1];
+				return `${hostParts[hostParts.length - 2]}/${tld}`;
+			}
+			return parsed.hostname.replace(".", "/");
+		} catch {
+			return "unknown/unknown";
+		}
+	}
+	async hasSkillsIndex(url) {
+		return await this.fetchIndex(url) !== null;
+	}
+};
+const wellKnownProvider = new WellKnownProvider();
+registerProvider(mintlifyProvider);
+registerProvider(huggingFaceProvider);
+async function fetchMintlifySkill(url) {
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+		if (!response.ok) return null;
+		const content = await response.text();
+		const { data } = (0, import_gray_matter.default)(content);
+		const mintlifySite = data.metadata?.["mintlify-proj"];
+		if (!mintlifySite) return null;
+		if (!data.name || !data.description) return null;
+		return {
+			name: data.name,
+			description: data.description,
+			content,
+			mintlifySite,
+			sourceUrl: url
+		};
+	} catch {
+		return null;
+	}
+}
+var version$1 = "1.0.0";
+function initTelemetry(version) {
+	setVersion(version);
+}
+setVersion(version$1);
+async function selectTargetAgents(options, spinner, cleanup, useUniversalAgents = false) {
+	const validAgents = Object.keys(agents);
+	const universalAgents = getUniversalAgents();
+	if (options.agent?.includes("*")) {
+		const all = validAgents;
+		logger.info(`Installing to all ${all.length} agents`);
+		return all;
+	}
+	if (options.agent && options.agent.length > 0) {
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			logger.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			logger.info(`Valid agents: ${validAgents.join(", ")}`);
+			await cleanup?.();
+			process.exit(1);
+		}
+		if (useUniversalAgents) return ensureUniversalAgents(options.agent);
+		return options.agent;
+	}
+	spinner.start("Loading agents...");
+	const installedAgents = await detectInstalledAgents();
+	const totalAgents = Object.keys(agents).length;
+	spinner.succeed(`${totalAgents} agents`);
+	if (installedAgents.length === 0) {
+		if (options.yes) {
+			if (useUniversalAgents) {
+				logger.info(`Installing to universal agents`);
+				return universalAgents;
+			}
+			const all = validAgents;
+			logger.info("Installing to all agents");
+			return all;
+		}
+		if (useUniversalAgents) {
+			const selected = await selectAgentsInteractive({ global: options.global });
+			if (pD(selected)) {
+				logger.cancel("Installation cancelled");
+				await cleanup?.();
+				process.exit(0);
+			}
+			return selected;
+		}
+		logger.info("Select agents to install skills to");
+		const selected = await promptForAgents("Which agents do you want to install to?", Object.entries(agents).map(([key, config]) => ({
+			value: key,
+			label: config.displayName
+		})));
+		if (pD(selected)) {
+			logger.cancel("Installation cancelled");
+			await cleanup?.();
+			process.exit(0);
+		}
+		return selected;
+	}
+	if (installedAgents.length === 1 || options.yes) {
+		if (useUniversalAgents) {
+			const target = ensureUniversalAgents(installedAgents);
+			const { universal, symlinked } = splitAgentsByType(target);
+			if (symlinked.length > 0) logger.info(`Installing to: ${import_picocolors.default.green("universal")} + ${symlinked.map((a) => import_picocolors.default.cyan(a)).join(", ")}`);
+			else logger.info(`Installing to: ${import_picocolors.default.green("universal agents")}`);
+			return target;
+		}
+		if (installedAgents.length === 1) {
+			const firstAgent = installedAgents[0];
+			logger.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+		} else logger.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+		return installedAgents;
+	}
+	const selected = await selectAgentsInteractive({ global: options.global });
+	if (pD(selected)) {
+		logger.cancel("Installation cancelled");
+		await cleanup?.();
+		process.exit(0);
+	}
+	return selected;
+}
+async function selectInstallScope(options, targetAgents, cleanup) {
+	let installGlobally = options.global ?? false;
+	const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+	if (options.global === void 0 && !options.yes && supportsGlobal) {
+		const scope = await ve({
+			message: "Installation scope",
+			options: [{
+				value: false,
+				label: "Project",
+				hint: "Install in current directory (committed with your project)"
+			}, {
+				value: true,
+				label: "Global",
+				hint: "Install in home directory (available across all projects)"
+			}]
+		});
+		if (pD(scope)) {
+			logger.cancel("Installation cancelled");
+			await cleanup?.();
+			process.exit(0);
+		}
+		installGlobally = scope;
+	}
+	return installGlobally;
+}
+async function selectInstallMode(options, cleanup) {
+	if (options.yes) return "symlink";
+	const modeChoice = await ve({
+		message: "Installation method",
+		options: [{
+			value: "symlink",
+			label: "Symlink (Recommended)",
+			hint: "Single source of truth, easy updates"
+		}, {
+			value: "copy",
+			label: "Copy to all agents",
+			hint: "Independent copies for each agent"
+		}]
+	});
+	if (pD(modeChoice)) {
+		logger.cancel("Installation cancelled");
+		await cleanup?.();
+		process.exit(0);
+	}
+	return modeChoice;
+}
+async function isSourcePrivate(source) {
+	const ownerRepo = parseOwnerRepo(source);
+	if (!ownerRepo) return false;
+	return isRepoPrivate(ownerRepo.owner, ownerRepo.repo);
+}
+async function executeInstallFlow(prepared, options, spinner, cleanup) {
+	const { items, targetAgents, installGlobally, installMode, cognitiveType } = prepared;
+	const cwd = process.cwd();
+	const overwriteChecks = await Promise.all(items.flatMap((item) => targetAgents.map(async (agent) => ({
+		skillName: item.installName,
+		agent,
+		installed: cognitiveType === "skill" ? await isSkillInstalled(item.installName, agent, { global: installGlobally }) : await isCognitiveInstalled(item.installName, agent, cognitiveType, { global: installGlobally })
+	}))));
+	const overwriteStatus = /* @__PURE__ */ new Map();
+	for (const { skillName, agent, installed } of overwriteChecks) {
+		if (!overwriteStatus.has(skillName)) overwriteStatus.set(skillName, /* @__PURE__ */ new Map());
+		overwriteStatus.get(skillName).set(agent, installed);
+	}
+	const summaryLines = [];
+	for (const item of items) {
+		if (summaryLines.length > 0) summaryLines.push("");
+		const shortCanonical = shortenPath$1(getCanonicalPath(item.installName, {
+			global: installGlobally,
+			cognitiveType
+		}), cwd);
+		summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+		summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
+		if (item.fileCount && item.fileCount > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${item.fileCount}`);
+		const skillOverwrites = overwriteStatus.get(item.installName);
+		const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+		if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+	}
+	logger.note(summaryLines.join("\n"), "Installation Summary");
+	if (!options.yes) {
+		const confirmed = await ye({ message: "Proceed with installation?" });
+		if (pD(confirmed) || !confirmed) {
+			logger.cancel("Installation cancelled");
+			await cleanup?.();
+			process.exit(0);
+		}
+	}
+	const label = items.length === 1 ? "Installing skill..." : "Installing skills...";
+	spinner.start(label);
+	const results = [];
+	for (const item of items) for (const agent of targetAgents) {
+		const result = await item.installFn(agent, {
+			global: installGlobally,
+			mode: installMode
+		});
+		results.push({
+			skill: item.installName,
+			agent: agents[agent].displayName,
+			...result
+		});
+	}
+	spinner.succeed("Installation complete");
+	logger.line();
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	const { telemetry } = prepared;
+	if (telemetry.source) {
+		let shouldTrack = true;
+		if (telemetry.checkPrivacy) {
+			if (await isSourcePrivate(telemetry.source) === true) shouldTrack = false;
+		}
+		if (shouldTrack) track({
+			event: "install",
+			source: telemetry.source,
+			skills: items.map((i) => i.installName).join(","),
+			agents: targetAgents.join(","),
+			...installGlobally && { global: "1" },
+			skillFiles: JSON.stringify(telemetry.skillFiles),
+			...telemetry.sourceType && { sourceType: telemetry.sourceType }
+		});
+	}
+	if (successful.length > 0 && installGlobally) {
+		const successfulSkillNames = new Set(successful.map((r) => r.skill));
+		for (const entry of prepared.lockEntries) if (successfulSkillNames.has(entry.name)) try {
+			let skillFolderHash = entry.skillFolderHash;
+			if (!skillFolderHash && entry.sourceType === "github" && entry.skillPath) {
+				const hash = await fetchSkillFolderHash(entry.source, entry.skillPath);
+				if (hash) skillFolderHash = hash;
+			}
+			if (entry.isCognitive) await addCognitiveToLock(entry.name, entry.cognitiveType, {
+				source: entry.source,
+				sourceType: entry.sourceType,
+				sourceUrl: entry.sourceUrl,
+				skillPath: entry.skillPath,
+				skillFolderHash
+			});
+			else await addSkillToLock(entry.name, {
+				source: entry.source,
+				sourceType: entry.sourceType,
+				sourceUrl: entry.sourceUrl,
+				skillFolderHash
+			});
+		} catch {}
+	}
+	if (successful.length > 0) {
+		const bySkill = /* @__PURE__ */ new Map();
+		for (const r of successful) {
+			const skillResults = bySkill.get(r.skill) || [];
+			skillResults.push(r);
+			bySkill.set(r.skill, skillResults);
+		}
+		const skillCount = bySkill.size;
+		const resultLines = [];
+		for (const [skillName, skillResults] of bySkill) {
+			const firstResult = skillResults[0];
+			if (firstResult.mode === "copy") {
+				resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim("(copied)")}`);
+				for (const r of skillResults) {
+					const shortPath = shortenPath$1(r.path, cwd);
+					resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+				}
+			} else {
+				if (firstResult.canonicalPath) {
+					const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+					resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+				} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
+				resultLines.push(...buildResultLines(skillResults, targetAgents));
+			}
+		}
+		const title = import_picocolors.default.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""}`);
+		logger.note(resultLines.join("\n"), title);
+		const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+		if (symlinkFailures.length > 0) {
+			const copiedAgentNames = symlinkFailures.map((r) => r.agent);
+			logger.warning(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgentNames)}`));
+			logger.message(import_picocolors.default.dim("Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+		}
+	}
+	if (failed.length > 0) {
+		logger.line();
+		logger.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+		for (const r of failed) logger.message(`${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+	}
+	logger.outro(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
+	await promptForFindSkills(options, targetAgents);
+}
+async function selectSkillItems(items, options, cleanup) {
+	if (options.skill?.includes("*")) {
+		logger.info(`Installing all ${items.length} skills`);
+		return items;
+	}
+	if (options.skill && options.skill.length > 0) {
+		const selected = items.filter((s) => options.skill.some((name) => "installName" in s && s.installName?.toLowerCase() === name.toLowerCase() || s.name.toLowerCase() === name.toLowerCase()));
+		if (selected.length === 0) {
+			logger.error(`No matching skills found for: ${options.skill.join(", ")}`);
+			logger.info("Available skills:");
+			for (const s of items) logger.message(`- ${"installName" in s ? s.installName : s.name}`);
+			await cleanup?.();
+			process.exit(1);
+		}
+		logger.info(`Selected ${selected.length} skill${selected.length !== 1 ? "s" : ""}: ${selected.map((s) => import_picocolors.default.cyan("installName" in s ? s.installName : s.name)).join(", ")}`);
+		return selected;
+	}
+	if (items.length === 1) {
+		const first = items[0];
+		logger.info(`Skill: ${import_picocolors.default.cyan("installName" in first ? first.installName : first.name)}`);
+		return items;
+	}
+	if (options.yes) {
+		logger.info(`Installing all ${items.length} skills`);
+		return items;
+	}
+	const selected = await multiselect({
+		message: "Select skills to install",
+		options: items.map((s) => ({
+			value: s,
+			label: "installName" in s ? s.installName : s.name,
+			hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+		})),
+		required: true
+	});
+	if (pD(selected)) {
+		logger.cancel("Installation cancelled");
+		await cleanup?.();
+		process.exit(0);
+	}
+	return selected;
+}
+async function resolveRemoteSkill(source, url, options, spinner) {
+	const provider = findProvider(url);
+	if (!provider) return resolveDirectUrlLegacy(source, url, options, spinner);
+	spinner.start(`Fetching skill.md from ${provider.displayName}...`);
+	const providerSkill = await provider.fetchSkill(url);
+	if (!providerSkill) {
+		spinner.fail("Invalid skill");
+		logger.outro(import_picocolors.default.red("Could not fetch skill.md or missing required frontmatter (name, description)."));
+		process.exit(1);
+	}
+	const remoteSkill = {
+		name: providerSkill.name,
+		description: providerSkill.description,
+		content: providerSkill.content,
+		installName: providerSkill.installName,
+		sourceUrl: providerSkill.sourceUrl,
+		providerId: provider.id,
+		sourceIdentifier: provider.getSourceIdentifier(url),
+		metadata: providerSkill.metadata
+	};
+	spinner.succeed(`Found skill: ${import_picocolors.default.cyan(remoteSkill.installName)}`);
+	logger.info(`Skill: ${import_picocolors.default.cyan(remoteSkill.name)}`);
+	logger.message(import_picocolors.default.dim(remoteSkill.description));
+	logger.message(import_picocolors.default.dim(`Source: ${remoteSkill.sourceIdentifier}`));
+	if (options.list) {
+		logger.line();
+		logger.step(import_picocolors.default.bold("Skill Details"));
+		logger.message(`${import_picocolors.default.cyan("Name:")} ${remoteSkill.name}`);
+		logger.message(`${import_picocolors.default.cyan("Install as:")} ${remoteSkill.installName}`);
+		logger.message(`${import_picocolors.default.cyan("Provider:")} ${provider.displayName}`);
+		logger.message(`${import_picocolors.default.cyan("Description:")} ${remoteSkill.description}`);
+		logger.outro("Run without --list to install");
+		process.exit(0);
+	}
+	const targetAgents = await selectTargetAgents(options, spinner, void 0, true);
+	const installGlobally = await selectInstallScope(options, targetAgents);
+	const installMode = await selectInstallMode(options);
+	return {
+		items: [{
+			installName: remoteSkill.installName,
+			displayName: remoteSkill.name,
+			description: remoteSkill.description,
+			sourceIdentifier: remoteSkill.sourceIdentifier,
+			providerId: remoteSkill.providerId,
+			sourceUrl: url,
+			installFn: (agent, opts) => installRemoteSkillForAgent(remoteSkill, agent, opts)
+		}],
+		targetAgents,
+		installGlobally,
+		installMode,
+		cognitiveType: "skill",
+		lockEntries: [{
+			name: remoteSkill.installName,
+			source: remoteSkill.sourceIdentifier,
+			sourceType: remoteSkill.providerId,
+			sourceUrl: url,
+			skillFolderHash: "",
+			cognitiveType: "skill",
+			isCognitive: false
+		}],
+		telemetry: {
+			source: remoteSkill.sourceIdentifier,
+			sourceType: remoteSkill.providerId,
+			skillFiles: { [remoteSkill.installName]: url },
+			checkPrivacy: true
+		}
+	};
+}
+async function resolveDirectUrlLegacy(source, url, options, spinner) {
+	spinner.start("Fetching skill.md...");
+	const mintlifySkill = await fetchMintlifySkill(url);
+	if (!mintlifySkill) {
+		spinner.fail("Invalid skill");
+		logger.outro(import_picocolors.default.red("Could not fetch skill.md or missing required frontmatter (name, description, mintlify-proj)."));
+		process.exit(1);
+	}
+	const remoteSkill = {
+		name: mintlifySkill.name,
+		description: mintlifySkill.description,
+		content: mintlifySkill.content,
+		installName: mintlifySkill.mintlifySite,
+		sourceUrl: mintlifySkill.sourceUrl,
+		providerId: "mintlify",
+		sourceIdentifier: "mintlify/com"
+	};
+	spinner.succeed(`Found skill: ${import_picocolors.default.cyan(remoteSkill.installName)}`);
+	logger.info(`Skill: ${import_picocolors.default.cyan(remoteSkill.name)}`);
+	logger.message(import_picocolors.default.dim(remoteSkill.description));
+	if (options.list) {
+		logger.line();
+		logger.step(import_picocolors.default.bold("Skill Details"));
+		logger.message(`${import_picocolors.default.cyan("Name:")} ${remoteSkill.name}`);
+		logger.message(`${import_picocolors.default.cyan("Site:")} ${remoteSkill.installName}`);
+		logger.message(`${import_picocolors.default.cyan("Description:")} ${remoteSkill.description}`);
+		logger.outro("Run without --list to install");
+		process.exit(0);
+	}
+	const targetAgents = await selectTargetAgents(options, spinner);
+	const installGlobally = await selectInstallScope(options, targetAgents);
+	return {
+		items: [{
+			installName: remoteSkill.installName,
+			displayName: remoteSkill.name,
+			description: remoteSkill.description,
+			sourceIdentifier: "mintlify/com",
+			providerId: "mintlify",
+			sourceUrl: url,
+			installFn: (agent, opts) => installRemoteSkillForAgent(remoteSkill, agent, opts)
+		}],
+		targetAgents,
+		installGlobally,
+		installMode: "symlink",
+		cognitiveType: "skill",
+		lockEntries: [{
+			name: remoteSkill.installName,
+			source: `mintlify/${remoteSkill.installName}`,
+			sourceType: "mintlify",
+			sourceUrl: url,
+			skillFolderHash: "",
+			cognitiveType: "skill",
+			isCognitive: false
+		}],
+		telemetry: {
+			source: "mintlify/com",
+			sourceType: "mintlify",
+			skillFiles: { [remoteSkill.installName]: url },
+			checkPrivacy: false
+		}
+	};
+}
+async function resolveWellKnownSkills(source, url, options, spinner) {
+	spinner.start("Discovering skills from well-known endpoint...");
+	const skills = await wellKnownProvider.fetchAllSkills(url);
+	if (skills.length === 0) {
+		spinner.fail("No skills found");
+		logger.outro(import_picocolors.default.red("No skills found at this URL. Make sure the server has a /.well-known/skills/index.json file."));
+		process.exit(1);
+	}
+	spinner.succeed(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+	for (const skill of skills) {
+		logger.info(`Skill: ${import_picocolors.default.cyan(skill.installName)}`);
+		logger.message(import_picocolors.default.dim(skill.description));
+		if (skill.files.size > 1) logger.message(import_picocolors.default.dim(`  Files: ${Array.from(skill.files.keys()).join(", ")}`));
+	}
+	if (options.list) {
+		logger.line();
+		logger.step(import_picocolors.default.bold("Available Skills"));
+		for (const skill of skills) {
+			logger.message(`${import_picocolors.default.cyan(skill.installName)}`);
+			logger.message(`  ${import_picocolors.default.dim(skill.description)}`);
+			if (skill.files.size > 1) logger.message(`  ${import_picocolors.default.dim(`Files: ${skill.files.size}`)}`);
+		}
+		logger.outro("Run without --list to install");
+		process.exit(0);
+	}
+	const selectedSkills = await selectSkillItems(skills, options);
+	const targetAgents = await selectTargetAgents(options, spinner);
+	const installGlobally = await selectInstallScope(options, targetAgents);
+	const installMode = await selectInstallMode(options);
+	const sourceIdentifier = wellKnownProvider.getSourceIdentifier(url);
+	const items = selectedSkills.map((skill) => ({
+		installName: skill.installName,
+		displayName: skill.name,
+		description: skill.description,
+		sourceIdentifier,
+		providerId: "well-known",
+		sourceUrl: skill.sourceUrl,
+		fileCount: skill.files.size,
+		installFn: (agent, opts) => installWellKnownSkillForAgent(skill, agent, opts)
+	}));
+	const skillFiles = {};
+	const lockEntries = [];
+	for (const skill of selectedSkills) {
+		skillFiles[skill.installName] = skill.sourceUrl;
+		lockEntries.push({
+			name: skill.installName,
+			source: sourceIdentifier,
+			sourceType: "well-known",
+			sourceUrl: skill.sourceUrl,
+			skillFolderHash: "",
+			cognitiveType: "skill",
+			isCognitive: false
+		});
+	}
+	return {
+		items,
+		targetAgents,
+		installGlobally,
+		installMode,
+		cognitiveType: "skill",
+		lockEntries,
+		telemetry: {
+			source: sourceIdentifier,
+			sourceType: "well-known",
+			skillFiles,
+			checkPrivacy: true
+		}
+	};
+}
+async function resolveGitRepoSkills(source, parsed, options, spinner, skillsDir, tempDir) {
+	const cleanupFn = async () => {
+		await cleanupDir(tempDir);
+	};
+	const cognitiveType = options.type ?? "skill";
+	const cognitiveLabel = cognitiveType === "skill" ? "skills" : `${cognitiveType}s`;
+	const cognitiveFile = cognitiveType === "skill" ? "SKILL.md" : cognitiveType === "agent" ? "AGENT.md" : "PROMPT.md";
+	const includeInternal = !!(options.skill && options.skill.length > 0);
+	spinner.start(`Discovering ${cognitiveLabel}...`);
+	const skills = options.type ? await discoverCognitives(skillsDir, parsed.subpath, {
+		includeInternal,
+		fullDepth: options.fullDepth,
+		types: [options.type]
+	}) : await discoverSkills(skillsDir, parsed.subpath, {
+		includeInternal,
+		fullDepth: options.fullDepth
+	});
+	if (skills.length === 0) {
+		spinner.fail(`No ${cognitiveLabel} found`);
+		logger.outro(import_picocolors.default.red(`No valid ${cognitiveLabel} found. They require a ${cognitiveFile} with name and description.`));
+		await cleanupFn();
+		process.exit(1);
+	}
+	spinner.succeed(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+	if (options.list) {
+		logger.line();
+		logger.step(import_picocolors.default.bold("Available Skills"));
+		for (const skill of skills) {
+			logger.message(`${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
+			logger.message(`  ${import_picocolors.default.dim(skill.description)}`);
+		}
+		logger.outro("Use --skill <name> to install specific skills");
+		await cleanupFn();
+		process.exit(0);
+	}
+	let selectedSkills;
+	if (options.skill?.includes("*")) {
+		selectedSkills = skills;
+		logger.info(`Installing all ${skills.length} skills`);
+	} else if (options.skill && options.skill.length > 0) {
+		selectedSkills = filterSkills(skills, options.skill);
+		if (selectedSkills.length === 0) {
+			logger.error(`No matching skills found for: ${options.skill.join(", ")}`);
+			logger.info("Available skills:");
+			for (const s of skills) logger.message(`- ${getSkillDisplayName(s)}`);
+			await cleanupFn();
+			process.exit(1);
+		}
+		logger.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => import_picocolors.default.cyan(getSkillDisplayName(s))).join(", ")}`);
+	} else if (skills.length === 1) {
+		selectedSkills = skills;
+		const firstSkill = skills[0];
+		logger.info(`Skill: ${import_picocolors.default.cyan(getSkillDisplayName(firstSkill))}`);
+		logger.message(import_picocolors.default.dim(firstSkill.description));
+	} else if (options.yes) {
+		selectedSkills = skills;
+		logger.info(`Installing all ${skills.length} skills`);
+	} else {
+		const selected = await multiselect({
+			message: "Select skills to install",
+			options: skills.map((s) => ({
+				value: s,
+				label: getSkillDisplayName(s),
+				hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+			})),
+			required: true
+		});
+		if (pD(selected)) {
+			logger.cancel("Installation cancelled");
+			await cleanupFn();
+			process.exit(0);
+		}
+		selectedSkills = selected;
+	}
+	const targetAgents = await selectTargetAgents(options, spinner, cleanupFn);
+	const installGlobally = await selectInstallScope(options, targetAgents, cleanupFn);
+	const installMode = await selectInstallMode(options, cleanupFn);
+	const normalizedSource = getOwnerRepo(parsed);
+	const skillFiles = {};
+	for (const skill of selectedSkills) {
+		let relativePath;
+		if (tempDir && skill.path === tempDir) relativePath = cognitiveFile;
+		else if (tempDir && skill.path.startsWith(tempDir + sep)) relativePath = skill.path.slice(tempDir.length + 1).split(sep).join("/") + `/${cognitiveFile}`;
+		else continue;
+		skillFiles[skill.name] = relativePath;
+	}
+	const items = selectedSkills.map((skill) => ({
+		installName: skill.name,
+		displayName: getSkillDisplayName(skill),
+		description: skill.description,
+		sourceIdentifier: normalizedSource ?? source,
+		providerId: parsed.type,
+		sourceUrl: parsed.url,
+		installFn: (agent, opts) => installCognitiveForAgent(skill, agent, {
+			...opts,
+			cognitiveType
+		})
+	}));
+	const lockEntries = [];
+	if (normalizedSource) for (const skill of selectedSkills) lockEntries.push({
+		name: getSkillDisplayName(skill),
+		source: normalizedSource,
+		sourceType: parsed.type,
+		sourceUrl: parsed.url,
+		skillPath: skillFiles[skill.name],
+		skillFolderHash: "",
+		cognitiveType,
+		isCognitive: true
+	});
+	let telemetrySource = normalizedSource ?? "";
+	if (normalizedSource) {
+		const ownerRepo = parseOwnerRepo(normalizedSource);
+		if (ownerRepo) if (await isRepoPrivate(ownerRepo.owner, ownerRepo.repo) === false) {} else telemetrySource = "";
+	}
+	return {
+		items,
+		targetAgents,
+		installGlobally,
+		installMode,
+		cognitiveType,
+		lockEntries,
+		telemetry: {
+			source: telemetrySource,
+			skillFiles,
+			checkPrivacy: false
+		}
+	};
+}
+async function runAdd(args, options = {}) {
+	const source = args[0];
+	let installTipShown = false;
+	const showInstallTip = () => {
+		if (installTipShown) return;
+		logger.message(import_picocolors.default.dim("Tip: use the --yes (-y) and --global (-g) flags to install without prompts."));
+		installTipShown = true;
+	};
+	if (!source) {
+		logger.line();
+		logger.log(import_picocolors.default.bgRed(import_picocolors.default.white(import_picocolors.default.bold(" ERROR "))) + " " + import_picocolors.default.red("Missing required argument: source"));
+		logger.line();
+		logger.dim("  Usage:");
+		logger.log(`    ${import_picocolors.default.cyan("npx synk add")} ${import_picocolors.default.yellow("<source>")} ${import_picocolors.default.dim("[options]")}`);
+		logger.line();
+		logger.dim("  Example:");
+		logger.log(`    ${import_picocolors.default.cyan("npx synk add")} ${import_picocolors.default.yellow("vercel-labs/agent-skills")}`);
+		logger.line();
+		process.exit(1);
+	}
+	if (options.all) {
+		options.skill = ["*"];
+		options.agent = ["*"];
+		options.yes = true;
+	}
+	logger.intro(" synk ");
+	if (!process.stdin.isTTY) showInstallTip();
+	let tempDir = null;
+	try {
+		const spinner = logger.spinner();
+		spinner.start("Parsing source...");
+		const parsed = parseSource(source);
+		spinner.succeed(`Source: ${parsed.type === "local" ? parsed.localPath : parsed.url}${parsed.ref ? ` @ ${import_picocolors.default.yellow(parsed.ref)}` : ""}${parsed.subpath ? ` (${parsed.subpath})` : ""}${parsed.skillFilter ? ` ${import_picocolors.default.dim("@")}${import_picocolors.default.cyan(parsed.skillFilter)}` : ""}`);
+		if (parsed.type === "direct-url") {
+			await executeInstallFlow(await resolveRemoteSkill(source, parsed.url, options, spinner), options, spinner);
+			return;
+		}
+		if (parsed.type === "well-known") {
+			await executeInstallFlow(await resolveWellKnownSkills(source, parsed.url, options, spinner), options, spinner);
+			return;
+		}
+		let skillsDir;
+		if (parsed.type === "local") {
+			spinner.start("Validating local path...");
+			if (!existsSync(parsed.localPath)) {
+				spinner.fail("Path not found");
+				logger.outro(import_picocolors.default.red(`Local path does not exist: ${parsed.localPath}`));
+				process.exit(1);
+			}
+			skillsDir = parsed.localPath;
+			spinner.succeed("Local path validated");
+		} else {
+			spinner.start("Cloning repository...");
+			tempDir = await cloneRepo(parsed.url, parsed.ref);
+			skillsDir = tempDir;
+			spinner.succeed("Repository cloned");
+		}
+		if (parsed.skillFilter) {
+			options.skill = options.skill || [];
+			if (!options.skill.includes(parsed.skillFilter)) options.skill.push(parsed.skillFilter);
+		}
+		const prepared = await resolveGitRepoSkills(source, parsed, options, spinner, skillsDir, tempDir);
+		const cleanupFn = async () => {
+			await cleanupDir(tempDir);
+		};
+		await executeInstallFlow(prepared, options, spinner, cleanupFn);
+	} catch (error) {
+		if (error instanceof GitCloneError) {
+			logger.error(import_picocolors.default.red("Failed to clone repository"));
+			for (const line of error.message.split("\n")) logger.message(import_picocolors.default.dim(line));
+		} else logger.error(error instanceof Error ? error.message : "Unknown error occurred");
+		showInstallTip();
+		logger.outro(import_picocolors.default.red("Installation failed"));
+		process.exit(1);
+	} finally {
+		await cleanupDir(tempDir);
+	}
+}
+async function cleanupDir(tempDir) {
+	if (tempDir) try {
+		await cleanupTempDir(tempDir);
+	} catch {}
+}
+async function promptForFindSkills(options, targetAgents) {
+	if (!process.stdin.isTTY) return;
+	if (options?.yes) return;
+	try {
+		if (await isPromptDismissed("findSkillsPrompt")) return;
+		if (await isSkillInstalled("find-skills", "claude-code", { global: true })) {
+			await dismissPrompt("findSkillsPrompt");
+			return;
+		}
+		logger.line();
+		logger.message(import_picocolors.default.dim("One-time prompt - you won't be asked again if you dismiss."));
+		const install = await ye({ message: `Install the ${import_picocolors.default.cyan("find-skills")} skill? It helps your agent discover and suggest skills.` });
+		if (pD(install)) {
+			await dismissPrompt("findSkillsPrompt");
+			return;
+		}
+		if (install) {
+			await dismissPrompt("findSkillsPrompt");
+			const findSkillsAgents = targetAgents?.filter((a) => a !== "replit");
+			if (!findSkillsAgents || findSkillsAgents.length === 0) return;
+			logger.line();
+			logger.step("Installing find-skills skill...");
+			try {
+				await runAdd(["vercel-labs/skills"], {
+					skill: ["find-skills"],
+					global: true,
+					yes: true,
+					agent: findSkillsAgents
+				});
+			} catch {
+				logger.warning("Failed to install find-skills. You can try again with:");
+				logger.message(import_picocolors.default.dim("  npx synk add vercel-labs/skills@find-skills -g -y --all"));
+			}
+		} else {
+			await dismissPrompt("findSkillsPrompt");
+			logger.message(import_picocolors.default.dim("You can install it later with: npx synk add vercel-labs/skills@find-skills"));
+		}
+	} catch {}
+}
+function parseAddOptions(args) {
+	const options = {};
+	const source = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-y" || arg === "--yes") options.yes = true;
+		else if (arg === "-l" || arg === "--list") options.list = true;
+		else if (arg === "--all") options.all = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "-s" || arg === "--skill") {
+			options.skill = options.skill || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.skill.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "-t" || arg === "--type") {
+			i++;
+			const typeVal = args[i];
+			if (typeVal === "skill" || typeVal === "agent" || typeVal === "prompt") options.type = typeVal;
+		} else if (arg === "--full-depth") options.fullDepth = true;
+		else if (arg && !arg.startsWith("-")) source.push(arg);
+	}
+	return {
+		source,
+		options
+	};
+}
+const SEARCH_API_BASE = process.env.SKILLS_API_URL || "https://skills.sh";
+async function searchSkillsAPI(query) {
+	try {
+		const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+		const res = await fetch(url);
+		if (!res.ok) return [];
+		return (await res.json()).skills.map((skill) => ({
+			name: skill.name,
+			slug: skill.id,
+			source: skill.source || "",
+			installs: skill.installs
+		}));
+	} catch {
+		return [];
+	}
+}
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const CLEAR_DOWN = "\x1B[J";
+const MOVE_UP = (n) => `\x1b[${n}A`;
+const MOVE_TO_COL = (n) => `\x1b[${n}G`;
+async function runSearchPrompt(initialQuery = "") {
+	let results = [];
+	let selectedIndex = 0;
+	let query = initialQuery;
+	let loading = false;
+	let debounceTimer = null;
+	let lastRenderedLines = 0;
+	if (process.stdin.isTTY) process.stdin.setRawMode(true);
+	readline.emitKeypressEvents(process.stdin);
+	process.stdin.resume();
+	process.stdout.write(HIDE_CURSOR);
+	function render() {
+		if (lastRenderedLines > 0) process.stdout.write(MOVE_UP(lastRenderedLines) + MOVE_TO_COL(1));
+		process.stdout.write(CLEAR_DOWN);
+		const lines = [];
+		const cursor = `${import_picocolors.default.bold("_")}`;
+		lines.push(`Search skills: ${query}${cursor}`);
+		lines.push("");
+		if (!query || query.length < 2) lines.push(import_picocolors.default.dim("Start typing to search (min 2 chars)"));
+		else if (results.length === 0 && loading) lines.push(import_picocolors.default.dim("Searching..."));
+		else if (results.length === 0) lines.push(import_picocolors.default.dim("No skills found"));
+		else {
+			const visible = results.slice(0, 8);
+			for (let i = 0; i < visible.length; i++) {
+				const skill = visible[i];
+				const isSelected = i === selectedIndex;
+				const arrow = isSelected ? import_picocolors.default.bold(">") : " ";
+				const name = isSelected ? import_picocolors.default.bold(skill.name) : skill.name;
+				const source = skill.source ? ` ${import_picocolors.default.dim(skill.source)}` : "";
+				const loadingIndicator = loading && i === 0 ? ` ${import_picocolors.default.dim("...")}` : "";
+				lines.push(`  ${arrow} ${name}${source}${loadingIndicator}`);
+			}
+		}
+		lines.push("");
+		lines.push(import_picocolors.default.dim("up/down navigate | enter select | esc cancel"));
+		for (const line of lines) process.stdout.write(line + "\n");
+		lastRenderedLines = lines.length;
+	}
+	function triggerSearch(q) {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		loading = false;
+		if (!q || q.length < 2) {
+			results = [];
+			selectedIndex = 0;
+			render();
+			return;
+		}
+		loading = true;
+		render();
+		const debounceMs = Math.max(150, 350 - q.length * 50);
+		debounceTimer = setTimeout(async () => {
+			try {
+				results = await searchSkillsAPI(q);
+				selectedIndex = 0;
+			} catch {
+				results = [];
+			} finally {
+				loading = false;
+				debounceTimer = null;
+				render();
+			}
+		}, debounceMs);
+	}
+	if (initialQuery) triggerSearch(initialQuery);
+	render();
+	return new Promise((resolve) => {
+		function cleanup() {
+			process.stdin.removeListener("keypress", handleKeypress);
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			process.stdout.write(SHOW_CURSOR);
+			process.stdin.pause();
+		}
+		function handleKeypress(_ch, key) {
+			if (!key) return;
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cleanup();
+				resolve(null);
+				return;
+			}
+			if (key.name === "return") {
+				cleanup();
+				resolve(results[selectedIndex] || null);
+				return;
+			}
+			if (key.name === "up") {
+				selectedIndex = Math.max(0, selectedIndex - 1);
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				selectedIndex = Math.min(Math.max(0, results.length - 1), selectedIndex + 1);
+				render();
+				return;
+			}
+			if (key.name === "backspace") {
+				if (query.length > 0) {
+					query = query.slice(0, -1);
+					triggerSearch(query);
+				}
+				return;
+			}
+			if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+				const char = key.sequence;
+				if (char >= " " && char <= "~") {
+					query += char;
+					triggerSearch(query);
+				}
+			}
+		}
+		process.stdin.on("keypress", handleKeypress);
+	});
+}
+function getOwnerRepoFromString(pkg) {
+	const atIndex = pkg.lastIndexOf("@");
+	const match = (atIndex > 0 ? pkg.slice(0, atIndex) : pkg).match(/^([^/]+)\/([^/]+)$/);
+	if (match) return {
+		owner: match[1],
+		repo: match[2]
+	};
+	return null;
+}
+async function isRepoPublic(owner, repo) {
+	return await isRepoPrivate(owner, repo) === false;
+}
+async function runFind(args) {
+	const query = args.join(" ");
+	const isNonInteractive = !process.stdin.isTTY;
+	const agentTip = `${import_picocolors.default.dim("Tip: if running in a coding agent, follow these steps:")}
+${import_picocolors.default.dim("  1) npx synk find [query]")}
+${import_picocolors.default.dim("  2) npx synk add <owner/repo@skill>")}`;
+	if (query) {
+		const results = await searchSkillsAPI(query);
+		track({
+			event: "find",
+			query,
+			resultCount: String(results.length)
+		});
+		if (results.length === 0) {
+			logger.dim(`No skills found for "${query}"`);
+			return;
+		}
+		logger.log(`${import_picocolors.default.dim("Install with")} npx synk add <owner/repo@skill>`);
+		logger.line();
+		for (const skill of results.slice(0, 6)) {
+			const pkg = skill.source || skill.slug;
+			logger.log(`${pkg}@${skill.name}`);
+			logger.dim(`\u2514 https://skills.sh/${skill.slug}`);
+			logger.line();
+		}
+		return;
+	}
+	if (isNonInteractive) {
+		logger.log(agentTip);
+		logger.line();
+	}
+	const selected = await runSearchPrompt();
+	track({
+		event: "find",
+		query: "",
+		resultCount: selected ? "1" : "0",
+		interactive: "1"
+	});
+	if (!selected) {
+		logger.dim("Search cancelled");
+		logger.line();
+		return;
+	}
+	const pkg = selected.source || selected.slug;
+	const skillName = selected.name;
+	logger.line();
+	logger.log(`Installing ${import_picocolors.default.bold(skillName)} from ${import_picocolors.default.dim(pkg)}...`);
+	logger.line();
+	const { source, options } = parseAddOptions([
+		pkg,
+		"--skill",
+		skillName
+	]);
+	await runAdd(source, options);
+	logger.line();
+	const info = getOwnerRepoFromString(pkg);
+	if (info && await isRepoPublic(info.owner, info.repo)) logger.log(`${import_picocolors.default.dim("View the skill at")} https://skills.sh/${selected.slug}`);
+	else logger.log(`${import_picocolors.default.dim("Discover more skills at")} https://skills.sh`);
+	logger.line();
+}
+function shortenPath(fullPath, cwd) {
+	const home = homedir();
+	if (fullPath.startsWith(home)) return fullPath.replace(home, "~");
+	if (fullPath.startsWith(cwd)) return "." + fullPath.slice(cwd.length);
+	return fullPath;
+}
+function formatList(items, maxShow = 5) {
+	if (items.length <= maxShow) return items.join(", ");
+	const shown = items.slice(0, maxShow);
+	const remaining = items.length - maxShow;
+	return `${shown.join(", ")} +${remaining} more`;
+}
+function parseListOptions(args) {
+	const options = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			while (i + 1 < args.length && !args[i + 1].startsWith("-")) options.agent.push(args[++i]);
+		} else if (arg === "-t" || arg === "--type") {
+			i++;
+			const typeVal = args[i];
+			if (typeVal === "skill" || typeVal === "agent" || typeVal === "prompt") options.type = typeVal;
+		}
+	}
+	return options;
+}
+async function runList(args) {
+	const options = parseListOptions(args);
+	const scope = options.global === true ? true : false;
+	let agentFilter;
+	if (options.agent && options.agent.length > 0) {
+		const validAgents = Object.keys(agents);
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			logger.warning(`Invalid agents: ${invalidAgents.join(", ")}`);
+			logger.dim(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+		agentFilter = options.agent;
+	}
+	const installedSkills = await listInstalledSkills({
+		global: scope,
+		agentFilter
+	});
+	const filteredSkills = options.type ? installedSkills.filter((s) => (s.cognitiveType || "skill") === options.type) : installedSkills;
+	const cwd = process.cwd();
+	const scopeLabel = scope ? "Global" : "Project";
+	const typeLabel = options.type ? ` ${options.type}s` : "";
+	if (filteredSkills.length === 0) {
+		logger.dim(`No ${scopeLabel.toLowerCase()}${typeLabel} found.`);
+		if (scope) logger.dim("Try listing project cognitives without -g");
+		else logger.dim("Try listing global cognitives with -g");
+		return;
+	}
+	function getTypeLabel(skill) {
+		const ct = skill.cognitiveType || "skill";
+		if (ct === "agent") return ` ${import_picocolors.default.dim("[AGENT]")}`;
+		if (ct === "prompt") return ` ${import_picocolors.default.dim("[PROMPT]")}`;
+		return "";
+	}
+	function printSkill(skill) {
+		const shortPath = shortenPath(skill.canonicalPath, cwd);
+		const agentNames = skill.agents.map((a) => agents[a].displayName);
+		const agentInfo = skill.agents.length > 0 ? formatList(agentNames) : import_picocolors.default.yellow("not linked");
+		logger.log(`${import_picocolors.default.cyan(skill.name)}${getTypeLabel(skill)} ${import_picocolors.default.dim(shortPath)}`);
+		logger.log(`  ${import_picocolors.default.dim("Agents:")} ${agentInfo}`);
+	}
+	logger.bold(`${scopeLabel}${typeLabel ? typeLabel.charAt(0).toUpperCase() + typeLabel.slice(1) : " Cognitives"}`);
+	logger.line();
+	for (const skill of filteredSkills) printSkill(skill);
+	logger.line();
+}
+async function removeCommand(skillNames, options) {
+	const isGlobal = options.global ?? false;
+	const cwd = process.cwd();
+	const spinner = logger.spinner("Scanning for installed skills...");
+	const skillNamesSet = /* @__PURE__ */ new Set();
+	const scanDir = async (dir) => {
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) skillNamesSet.add(entry.name);
+		} catch (err) {
+			if (err instanceof Error && err.code !== "ENOENT") logger.warning(`Could not scan directory ${dir}: ${err.message}`);
+		}
+	};
+	const typesToScan = options.type ? [options.type] : [
+		"skill",
+		"agent",
+		"prompt"
+	];
+	for (const cogType of typesToScan) if (isGlobal) {
+		await scanDir(getCanonicalDir(cogType, true, cwd));
+		for (const agent of Object.values(agents)) {
+			const dir = cogType === "skill" ? agent.globalSkillsDir : cogType === "agent" ? agent.globalAgentsDir : agent.globalPromptsDir;
+			if (dir !== void 0) await scanDir(dir);
+		}
+	} else {
+		await scanDir(getCanonicalDir(cogType, false, cwd));
+		for (const agent of Object.values(agents)) await scanDir(join(cwd, cogType === "skill" ? agent.skillsDir : cogType === "agent" ? agent.agentsDir : agent.promptsDir));
+	}
+	const installedSkills = Array.from(skillNamesSet).sort();
+	spinner.succeed(`Found ${installedSkills.length} unique installed skill(s)`);
+	if (installedSkills.length === 0) {
+		logger.outro(import_picocolors.default.yellow("No skills found to remove."));
+		return;
+	}
+	if (options.agent && options.agent.length > 0) {
+		const validAgents = Object.keys(agents);
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			logger.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			logger.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+	}
+	let selectedSkills = [];
+	if (options.all) selectedSkills = installedSkills;
+	else if (skillNames.length > 0) {
+		selectedSkills = installedSkills.filter((s) => skillNames.some((name) => name.toLowerCase() === s.toLowerCase()));
+		if (selectedSkills.length === 0) {
+			logger.error(`No matching skills found for: ${skillNames.join(", ")}`);
+			return;
+		}
+	} else {
+		const choices = installedSkills.map((s) => ({
+			value: s,
+			label: s
+		}));
+		const selected = await fe({
+			message: `Select skills to remove ${import_picocolors.default.dim("(space to toggle)")}`,
+			options: choices,
+			required: true
+		});
+		if (pD(selected)) {
+			logger.cancel("Removal cancelled");
+			process.exit(0);
+		}
+		selectedSkills = selected;
+	}
+	let targetAgents;
+	if (options.agent && options.agent.length > 0) targetAgents = options.agent;
+	else {
+		spinner.start("Detecting installed agents...");
+		targetAgents = await detectInstalledAgents();
+		if (targetAgents.length === 0) targetAgents = Object.keys(agents);
+		spinner.succeed(`Targeting ${targetAgents.length} installed agent(s)`);
+	}
+	if (!options.yes) {
+		logger.line();
+		logger.info("Skills to remove:");
+		for (const skill of selectedSkills) logger.message(`${import_picocolors.default.red("•")} ${skill}`);
+		logger.line();
+		const confirmed = await ye({ message: `Are you sure you want to uninstall ${selectedSkills.length} skill(s)?` });
+		if (pD(confirmed) || !confirmed) {
+			logger.cancel("Removal cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Removing skills...");
+	const results = [];
+	for (const skillName of selectedSkills) try {
+		for (const agentKey of targetAgents) {
+			const agent = agents[agentKey];
+			const skillPath = getInstallPath(skillName, agentKey, {
+				global: isGlobal,
+				cwd
+			});
+			try {
+				if (await lstat(skillPath).catch(() => null)) await rm(skillPath, {
+					recursive: true,
+					force: true
+				});
+			} catch (err) {
+				logger.warning(`Could not remove skill from ${agent.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		for (const cogType of typesToScan) await rm(getCanonicalPath(skillName, {
+			global: isGlobal,
+			cwd,
+			cognitiveType: cogType
+		}), {
+			recursive: true,
+			force: true
+		});
+		const lockEntry = isGlobal ? await getSkillFromLock(skillName) : null;
+		const effectiveSource = lockEntry?.source || "local";
+		const effectiveSourceType = lockEntry?.sourceType || "local";
+		if (isGlobal) await removeSkillFromLock(skillName);
+		results.push({
+			skill: skillName,
+			success: true,
+			source: effectiveSource,
+			sourceType: effectiveSourceType
+		});
+	} catch (err) {
+		results.push({
+			skill: skillName,
+			success: false,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+	spinner.succeed("Removal process complete");
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	if (successful.length > 0) {
+		const bySource = /* @__PURE__ */ new Map();
+		for (const r of successful) {
+			const source = r.source || "local";
+			const existing = bySource.get(source) || { skills: [] };
+			existing.skills.push(r.skill);
+			existing.sourceType = r.sourceType;
+			bySource.set(source, existing);
+		}
+		for (const [source, data] of bySource) track({
+			event: "remove",
+			source,
+			skills: data.skills.join(","),
+			agents: targetAgents.join(","),
+			...isGlobal && { global: "1" },
+			sourceType: data.sourceType
+		});
+	}
+	if (successful.length > 0) logger.success(import_picocolors.default.green(`Successfully removed ${successful.length} skill(s)`));
+	if (failed.length > 0) {
+		logger.error(import_picocolors.default.red(`Failed to remove ${failed.length} skill(s)`));
+		for (const r of failed) logger.message(`${import_picocolors.default.red("✗")} ${r.skill}: ${r.error}`);
+	}
+	logger.line();
+	logger.outro(import_picocolors.default.green("Done!"));
+}
+function parseRemoveOptions(args) {
+	const options = {};
+	const skills = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-y" || arg === "--yes") options.yes = true;
+		else if (arg === "--all") options.all = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "-t" || arg === "--type") {
+			i++;
+			const typeVal = args[i];
+			if (typeVal === "skill" || typeVal === "agent" || typeVal === "prompt") options.type = typeVal;
+		} else if (arg && !arg.startsWith("-")) skills.push(arg);
+	}
+	return {
+		skills,
+		options
+	};
+}
+function runInit(args) {
+	const cwd = process.cwd();
+	let cognitiveType = "skill";
+	const filteredArgs = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if ((arg === "-t" || arg === "--type") && i + 1 < args.length) {
+			const typeVal = args[i + 1];
+			if (typeVal === "skill" || typeVal === "agent" || typeVal === "prompt") cognitiveType = typeVal;
+			i++;
+		} else if (arg && !arg.startsWith("-")) filteredArgs.push(arg);
+	}
+	const itemName = filteredArgs[0] || basename(cwd);
+	const hasName = filteredArgs[0] !== void 0;
+	const fileName = {
+		skill: "SKILL.md",
+		agent: "AGENT.md",
+		prompt: "PROMPT.md"
+	}[cognitiveType];
+	const itemDir = hasName ? join(cwd, itemName) : cwd;
+	const itemFile = join(itemDir, fileName);
+	const displayPath = hasName ? `${itemName}/${fileName}` : fileName;
+	if (existsSync(itemFile)) {
+		logger.log(`${cognitiveType} already exists at ${import_picocolors.default.dim(displayPath)}`);
+		return;
+	}
+	if (hasName) mkdirSync(itemDir, { recursive: true });
+	let content;
+	if (cognitiveType === "agent") content = `---
+name: ${itemName}
+description: A brief description of this agent
+---
+
+# ${itemName}
+
+Agent instructions here.
+
+## Role
+
+Describe the agent's role and capabilities.
+
+## Instructions
+
+1. First step
+2. Second step
+3. Additional steps as needed
+`;
+	else if (cognitiveType === "prompt") content = `---
+name: ${itemName}
+description: A brief description of this prompt
+---
+
+# ${itemName}
+
+Prompt template content here.
+
+## Context
+
+Describe when this prompt should be used.
+
+## Template
+
+Your prompt template goes here.
+`;
+	else content = `---
+name: ${itemName}
+description: A brief description of what this skill does
+---
+
+# ${itemName}
+
+Instructions for the agent to follow when this skill is activated.
+
+## When to use
+
+Describe when this skill should be used.
+
+## Instructions
+
+1. First step
+2. Second step
+3. Additional steps as needed
+`;
+	writeFileSync(itemFile, content);
+	logger.log(`Initialized ${cognitiveType}: ${import_picocolors.default.dim(itemName)}`);
+	logger.line();
+	logger.dim("Created:");
+	logger.log(`  ${displayPath}`);
+	logger.line();
+	logger.dim("Next steps:");
+	logger.log(`  1. Edit ${import_picocolors.default.cyan(displayPath)} to define your ${cognitiveType} instructions`);
+	logger.log(`  2. Update the ${import_picocolors.default.cyan("name")} and ${import_picocolors.default.cyan("description")} in the frontmatter`);
+	logger.line();
+	logger.dim("Publishing:");
+	logger.log(`  ${import_picocolors.default.dim("GitHub:")}  Push to a repo, then ${import_picocolors.default.cyan(`npx synk add <owner>/<repo>`)}`);
+	logger.log(`  ${import_picocolors.default.dim("URL:")}     Host the file, then ${import_picocolors.default.cyan(`npx synk add https://example.com/${displayPath}`)}`);
+	logger.line();
+}
+const AGENTS_DIR$1 = ".agents";
+const LOCK_FILE$1 = ".skill-lock.json";
+const CURRENT_LOCK_VERSION$1 = 4;
+function getSkillLockPath$1() {
+	return join(homedir(), AGENTS_DIR$1, LOCK_FILE$1);
+}
+function readSkillLock$1() {
+	const lockPath = getSkillLockPath$1();
+	try {
+		const content = readFileSync(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return {
+			version: CURRENT_LOCK_VERSION$1,
+			skills: {}
+		};
+		if (parsed.version < CURRENT_LOCK_VERSION$1) return {
+			version: CURRENT_LOCK_VERSION$1,
+			skills: {}
+		};
+		return parsed;
+	} catch {
+		return {
+			version: CURRENT_LOCK_VERSION$1,
+			skills: {}
+		};
+	}
+}
+async function runCheck(args = []) {
+	logger.log(`Checking for skill updates...`);
+	logger.line();
+	const lock = readSkillLock$1();
+	const skillNames = Object.keys(lock.skills);
+	if (skillNames.length === 0) {
+		logger.dim("No skills tracked in lock file.");
+		logger.log(`${import_picocolors.default.dim("Install skills with")} npx synk add <package>`);
+		return;
+	}
+	const token = getGitHubToken();
+	const skillsBySource = /* @__PURE__ */ new Map();
+	let skippedCount = 0;
+	for (const skillName of skillNames) {
+		const entry = lock.skills[skillName];
+		if (!entry) continue;
+		if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) {
+			skippedCount++;
+			continue;
+		}
+		const existing = skillsBySource.get(entry.source) || [];
+		existing.push({
+			name: skillName,
+			entry
+		});
+		skillsBySource.set(entry.source, existing);
+	}
+	const totalSkills = skillNames.length - skippedCount;
+	if (totalSkills === 0) {
+		logger.dim("No GitHub skills to check.");
+		return;
+	}
+	logger.dim(`Checking ${totalSkills} skill(s) for updates...`);
+	const updates = [];
+	const errors = [];
+	for (const [source, skills] of skillsBySource) for (const { name, entry } of skills) try {
+		const latestHash = await fetchSkillFolderHash(source, entry.skillPath, token);
+		if (!latestHash) {
+			errors.push({
+				name,
+				source,
+				error: "Could not fetch from GitHub"
+			});
+			continue;
+		}
+		if (latestHash !== entry.skillFolderHash) updates.push({
+			name,
+			source
+		});
+	} catch (err) {
+		errors.push({
+			name,
+			source,
+			error: err instanceof Error ? err.message : "Unknown error"
+		});
+	}
+	logger.line();
+	if (updates.length === 0) logger.success("All skills are up to date");
+	else {
+		logger.log(`${updates.length} update(s) available:`);
+		logger.line();
+		for (const update of updates) {
+			logger.log(`  ${import_picocolors.default.cyan("↑")} ${update.name}`);
+			logger.dim(`    source: ${update.source}`);
+		}
+		logger.line();
+		logger.log(`${import_picocolors.default.dim("Run")} npx synk update ${import_picocolors.default.dim("to update all skills")}`);
+	}
+	if (errors.length > 0) {
+		logger.line();
+		logger.dim(`Could not check ${errors.length} skill(s) (may need reinstall)`);
+	}
+	track({
+		event: "check",
+		skillCount: String(totalSkills),
+		updatesAvailable: String(updates.length)
+	});
+	logger.line();
+}
+const AGENTS_DIR = ".agents";
+const LOCK_FILE = ".skill-lock.json";
+const CURRENT_LOCK_VERSION = 4;
+function getSkillLockPath() {
+	return join(homedir(), AGENTS_DIR, LOCK_FILE);
+}
+function readSkillLock() {
+	const lockPath = getSkillLockPath();
+	try {
+		const content = readFileSync(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+		if (parsed.version < CURRENT_LOCK_VERSION) return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+		return parsed;
+	} catch {
+		return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+	}
+}
+async function runUpdate() {
+	logger.log("Checking for skill updates...");
+	logger.line();
+	const lock = readSkillLock();
+	const skillNames = Object.keys(lock.skills);
+	if (skillNames.length === 0) {
+		logger.dim("No skills tracked in lock file.");
+		logger.log(`${import_picocolors.default.dim("Install skills with")} npx synk add <package>`);
+		return;
+	}
+	const token = getGitHubToken();
+	const updates = [];
+	let checkedCount = 0;
+	for (const skillName of skillNames) {
+		const entry = lock.skills[skillName];
+		if (!entry) continue;
+		if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) continue;
+		checkedCount++;
+		try {
+			const latestHash = await fetchSkillFolderHash(entry.source, entry.skillPath, token);
+			if (latestHash && latestHash !== entry.skillFolderHash) updates.push({
+				name: skillName,
+				source: entry.source,
+				entry
+			});
+		} catch {}
+	}
+	if (checkedCount === 0) {
+		logger.dim("No skills to check.");
+		return;
+	}
+	if (updates.length === 0) {
+		logger.success("All skills are up to date");
+		logger.line();
+		return;
+	}
+	logger.log(`Found ${updates.length} update(s)`);
+	logger.line();
+	let successCount = 0;
+	let failCount = 0;
+	for (const update of updates) {
+		logger.log(`Updating ${update.name}...`);
+		let installUrl = update.entry.sourceUrl;
+		if (update.entry.skillPath) {
+			let skillFolder = update.entry.skillPath;
+			if (skillFolder.endsWith("/SKILL.md")) skillFolder = skillFolder.slice(0, -9);
+			else if (skillFolder.endsWith("SKILL.md")) skillFolder = skillFolder.slice(0, -8);
+			if (skillFolder.endsWith("/")) skillFolder = skillFolder.slice(0, -1);
+			installUrl = update.entry.sourceUrl.replace(/\.git$/, "").replace(/\/$/, "");
+			installUrl = `${installUrl}/tree/main/${skillFolder}`;
+		}
+		if (spawnSync("npx", [
+			"-y",
+			"skills",
+			"add",
+			installUrl,
+			"-g",
+			"-y"
+		], { stdio: [
+			"inherit",
+			"pipe",
+			"pipe"
+		] }).status === 0) {
+			successCount++;
+			logger.success(`Updated ${update.name}`);
+		} else {
+			failCount++;
+			logger.dim(`\u2717 Failed to update ${update.name}`);
+		}
+	}
+	logger.line();
+	if (successCount > 0) logger.success(`Updated ${successCount} skill(s)`);
+	if (failCount > 0) logger.dim(`Failed to update ${failCount} skill(s)`);
+	track({
+		event: "update",
+		skillCount: String(updates.length),
+		successCount: String(successCount),
+		failCount: String(failCount)
+	});
+	logger.line();
+}
+const LOGO_LINES = [
+	"███████╗██╗   ██╗███╗   ██╗██╗  ██╗",
+	"██╔════╝╚██╗ ██╔╝████╗  ██║██║ ██╔╝",
+	"███████╗ ╚████╔╝ ██╔██╗ ██║█████╔╝ ",
+	"╚════██║  ╚██╔╝  ██║╚██╗██║██╔═██╗ ",
+	"███████║   ██║   ██║ ╚████║██║  ██╗",
+	"╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚═╝  ╚═╝"
+];
+const GRAYS = [
+	"\x1B[38;5;250m",
+	"\x1B[38;5;248m",
+	"\x1B[38;5;245m",
+	"\x1B[38;5;243m",
+	"\x1B[38;5;240m",
+	"\x1B[38;5;238m"
+];
+function showLogo() {
+	logger.line();
+	LOGO_LINES.forEach((line, i) => {
+		logger.gradient(line, GRAYS[i]);
+	});
+}
+function showBanner() {
+	showLogo();
+	logger.line();
+	logger.dim("The open cognitive ecosystem for AI agents");
+	logger.line();
+	logger.command("npx synk add <package>", "Install skills, agents, or prompts");
+	logger.command("npx synk list", "List installed cognitives");
+	logger.command("npx synk find [query]", "Search for skills");
+	logger.command("npx synk check", "Check for updates");
+	logger.command("npx synk update", "Update all cognitives");
+	logger.command("npx synk remove", "Remove installed cognitives");
+	logger.command("npx synk init [name]", "Create a new skill, agent, or prompt");
+	logger.line();
+	logger.log(`${import_picocolors.default.dim("try:")} npx synk add vercel-labs/agent-skills`);
+	logger.line();
+}
+function showHelp() {
+	logger.log(`
+${import_picocolors.default.bold("Usage:")} synk <command> [options]
+
+${import_picocolors.default.bold("Commands:")}
+  add <package>     Add skills, agents, or prompts from a package
+                    e.g. vercel-labs/agent-skills
+                         https://github.com/vercel-labs/agent-skills
+  remove [names]    Remove installed cognitives
+  list, ls          List installed cognitives
+  find [query]      Search for skills interactively
+  init [name]       Initialize a cognitive (creates SKILL.md, AGENT.md, or PROMPT.md)
+  check             Check for available updates
+  update            Update all cognitives to latest versions
+
+${import_picocolors.default.bold("Add Options:")}
+  -g, --global           Install globally (user-level) instead of project-level
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -s, --skill <skills>   Specify skill names to install (use '*' for all skills)
+  -t, --type <type>      Filter by cognitive type: skill, agent, or prompt
+  -l, --list             List available cognitives in the repository without installing
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+
+${import_picocolors.default.bold("Remove Options:")}
+  -g, --global           Remove from global scope
+  -a, --agent <agents>   Remove from specific agents (use '*' for all agents)
+  -s, --skill <skills>   Specify skills to remove (use '*' for all skills)
+  -t, --type <type>      Filter by cognitive type: skill, agent, or prompt
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+
+${import_picocolors.default.bold("List Options:")}
+  -g, --global           List global cognitives (default: project)
+  -a, --agent <agents>   Filter by specific agents
+  -t, --type <type>      Filter by cognitive type: skill, agent, or prompt
+
+${import_picocolors.default.bold("Init Options:")}
+  -t, --type <type>      Type to create: skill (default), agent, or prompt
+
+${import_picocolors.default.bold("Options:")}
+  --help, -h        Show this help message
+  --version, -v     Show version number
+
+${import_picocolors.default.bold("Examples:")}
+  ${import_picocolors.default.dim("$")} synk add vercel-labs/agent-skills
+  ${import_picocolors.default.dim("$")} synk add vercel-labs/agent-skills -g
+  ${import_picocolors.default.dim("$")} synk add vercel-labs/agent-skills --type agent
+  ${import_picocolors.default.dim("$")} synk add vercel-labs/agent-skills --agent claude-code cursor
+  ${import_picocolors.default.dim("$")} synk add vercel-labs/agent-skills --skill pr-review commit
+  ${import_picocolors.default.dim("$")} synk remove                     ${import_picocolors.default.dim("# interactive remove")}
+  ${import_picocolors.default.dim("$")} synk remove web-design          ${import_picocolors.default.dim("# remove by name")}
+  ${import_picocolors.default.dim("$")} synk rm --global frontend-design
+  ${import_picocolors.default.dim("$")} synk list                       ${import_picocolors.default.dim("# list all installed cognitives")}
+  ${import_picocolors.default.dim("$")} synk ls -g                      ${import_picocolors.default.dim("# list global cognitives only")}
+  ${import_picocolors.default.dim("$")} synk ls --type agent             ${import_picocolors.default.dim("# list agents only")}
+  ${import_picocolors.default.dim("$")} synk find                       ${import_picocolors.default.dim("# interactive search")}
+  ${import_picocolors.default.dim("$")} synk find typescript            ${import_picocolors.default.dim("# search by keyword")}
+  ${import_picocolors.default.dim("$")} synk init my-skill
+  ${import_picocolors.default.dim("$")} synk init --type agent my-agent
+  ${import_picocolors.default.dim("$")} synk init --type prompt my-prompt
+  ${import_picocolors.default.dim("$")} synk check
+  ${import_picocolors.default.dim("$")} synk update
+`);
+}
+function showRemoveHelp() {
+	logger.log(`
+${import_picocolors.default.bold("Usage:")} synk remove [names...] [options]
+
+${import_picocolors.default.bold("Description:")}
+  Remove installed cognitives from agents. If no names are provided,
+  an interactive selection menu will be shown.
+
+${import_picocolors.default.bold("Arguments:")}
+  names             Optional names to remove (space-separated)
+
+${import_picocolors.default.bold("Options:")}
+  -g, --global       Remove from global scope (~/) instead of project scope
+  -a, --agent        Remove from specific agents (use '*' for all agents)
+  -s, --skill        Specify skills to remove (use '*' for all skills)
+  -t, --type         Filter by cognitive type: skill, agent, or prompt
+  -y, --yes          Skip confirmation prompts
+  --all              Shorthand for --skill '*' --agent '*' -y
+
+${import_picocolors.default.bold("Examples:")}
+  ${import_picocolors.default.dim("$")} synk remove                             ${import_picocolors.default.dim("# interactive selection")}
+  ${import_picocolors.default.dim("$")} synk remove my-skill                     ${import_picocolors.default.dim("# remove specific skill")}
+  ${import_picocolors.default.dim("$")} synk remove skill1 skill2 -y             ${import_picocolors.default.dim("# remove multiple")}
+  ${import_picocolors.default.dim("$")} synk remove --global my-agent            ${import_picocolors.default.dim("# remove from global scope")}
+  ${import_picocolors.default.dim("$")} synk rm --agent claude-code my-skill     ${import_picocolors.default.dim("# remove from specific agent")}
+  ${import_picocolors.default.dim("$")} synk remove --all                        ${import_picocolors.default.dim("# remove all")}
+  ${import_picocolors.default.dim("$")} synk remove --type agent                 ${import_picocolors.default.dim("# remove only agents")}
+`);
+}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+	try {
+		const pkgPath = join(__dirname, "..", "package.json");
+		return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+	} catch {
+		return "0.0.0";
+	}
+}
+const VERSION = getVersion();
+initTelemetry(VERSION);
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.length === 0) {
+		showBanner();
+		return;
+	}
+	const command = args[0];
+	const restArgs = args.slice(1);
+	switch (command) {
+		case "find":
+		case "search":
+		case "f":
+		case "s":
+			showLogo();
+			logger.line();
+			await runFind(restArgs);
+			break;
+		case "init":
+			showLogo();
+			logger.line();
+			runInit(restArgs);
+			break;
+		case "i":
+		case "install":
+		case "a":
+		case "add": {
+			showLogo();
+			const { source, options } = parseAddOptions(restArgs);
+			await runAdd(source, options);
+			break;
+		}
+		case "remove":
+		case "rm":
+		case "r":
+			if (restArgs.includes("--help") || restArgs.includes("-h")) {
+				showRemoveHelp();
+				break;
+			}
+			const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
+			await removeCommand(skills, removeOptions);
+			break;
+		case "list":
+		case "ls":
+			await runList(restArgs);
+			break;
+		case "check":
+			runCheck(restArgs);
+			break;
+		case "update":
+		case "upgrade":
+			runUpdate();
+			break;
+		case "--help":
+		case "-h":
+			showHelp();
+			break;
+		case "--version":
+		case "-v":
+			logger.log(VERSION);
+			break;
+		default:
+			logger.error(`Unknown command: ${command}`);
+			logger.log(`Run ${import_picocolors.default.bold("synk --help")} for usage.`);
+	}
+}
+main();
+export {};