bip-skills 1.4.4 → 1.4.6

package/dist/cli.mjs

@@ -11,7 +11,7 @@ import "./_chunks/libs/esprima.mjs";
 import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
 import { execSync, spawn, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
+import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "path";
 import { homedir, platform, tmpdir } from "os";
 import { createHash } from "crypto";
 import { fileURLToPath } from "url";
@@ -30,9 +30,16 @@ const DEFAULT_SEARCH_API_BASE = DEFAULT_WELL_KNOWN_BASE_URL;
 const DEFAULT_GIT_HOST = "git.yonyou.com";
 const DEFAULT_GIT_BASE_URL = `https://${DEFAULT_GIT_HOST}`;
 const DEFAULT_GIT_FALLBACK_SSH_HOST = "git.yyrd.com";
+const DEFAULT_INSTALL_REPORT_URL = "https://sun.yyuap.com/api/install-report";
 function isYyuapHost(hostname) {
 	return hostname === "yyuap.com" || hostname.endsWith(".yyuap.com");
 }
+function isYyrdHost(hostname) {
+	return hostname === "yyrd.com" || hostname.endsWith(".yyrd.com");
+}
+function isInternalSkillSourceHost(hostname) {
+	return isYyuapHost(hostname) || isYyrdHost(hostname);
+}
 function isAllowedReportingUrl(url) {
 	try {
 		return isYyuapHost(new URL(url).hostname);
@@ -74,6 +81,20 @@ async function isRepoPrivate(owner, repo) {
 		return null;
 	}
 }
+function extractSourceHostname(sourceUrl) {
+	if (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://") || sourceUrl.startsWith("ssh://") || sourceUrl.startsWith("git://")) try {
+		return new URL(sourceUrl).hostname;
+	} catch {
+		return null;
+	}
+	const scpLikeMatch = sourceUrl.match(/^(?:[^@]+@)?([^:/]+):.+$/);
+	if (scpLikeMatch) return scpLikeMatch[1] ?? null;
+	return null;
+}
+function isInternalSkillSourceUrl(sourceUrl) {
+	const hostname = extractSourceHostname(sourceUrl);
+	return hostname ? isInternalSkillSourceHost(hostname) : false;
+}
 function isLocalPath(input) {
 	return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
 }
@@ -375,12 +396,9 @@ var GitCloneError = class extends Error {
 };
 async function cloneRepo(url, ref) {
 	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
-	const git = esm_default({
-		timeout: { block: CLONE_TIMEOUT_MS },
-		env: {
-			...process.env,
-			GIT_TERMINAL_PROMPT: "0"
-		}
+	const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } }).env({
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
 	});
 	const cloneOptions = ref ? [
 		"--depth",
@@ -1400,6 +1418,7 @@ function getAllowedReportingUrl(envVarName) {
 }
 const TELEMETRY_URL = getAllowedReportingUrl("SKILLS_TELEMETRY_URL");
 const AUDIT_URL = getAllowedReportingUrl("SKILLS_AUDIT_URL");
+const INSTALL_REPORT_URL = isAllowedReportingUrl(DEFAULT_INSTALL_REPORT_URL) ? DEFAULT_INSTALL_REPORT_URL : null;
 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);
@@ -1428,17 +1447,24 @@ async function fetchAuditData(source, skillSlugs, timeoutMs = 3e3) {
 		return null;
 	}
 }
-function track(data) {
-	if (!TELEMETRY_URL) return;
+function sendTelemetry(url, 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(() => {});
+		fetch(`${url}?${params.toString()}`).catch(() => {});
 	} catch {}
 }
+function track(data) {
+	if (!TELEMETRY_URL) return;
+	sendTelemetry(TELEMETRY_URL, data);
+}
+function trackInstallReport(data) {
+	if (!INSTALL_REPORT_URL) return;
+	sendTelemetry(INSTALL_REPORT_URL, data);
+}
 var ProviderRegistryImpl = class {
 	providers = [];
 	register(provider) {
@@ -1459,6 +1485,54 @@ var WellKnownProvider = class {
 	displayName = "Well-Known Skills";
 	WELL_KNOWN_PATH = ".well-known/skills";
 	INDEX_FILE = "index.json";
+	buildUrl(baseUrl, relativePath) {
+		const normalizedRelative = relativePath.replace(/^\/+/, "");
+		return new URL(normalizedRelative, `${baseUrl.replace(/\/?$/, "/")}`).toString();
+	}
+	getSkillRoot(entry) {
+		if (entry.entry) {
+			const normalizedEntry = posix.normalize(entry.entry).replace(/^\/+/, "");
+			const entryDir = posix.dirname(normalizedEntry);
+			return entryDir === "." ? "" : entryDir;
+		}
+		return entry.name;
+	}
+	resolveRepositoryUrl(index, resolvedBaseUrl, entry) {
+		if (!entry.repositoryId) return `${resolvedBaseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+		return (index.repositories?.find((repo) => repo.id === entry.repositoryId))?.repository || `${resolvedBaseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+	}
+	resolveInlineBaseUrl(repositoryUrl) {
+		if (!repositoryUrl.startsWith("http://") && !repositoryUrl.startsWith("https://")) return null;
+		try {
+			const parsed = new URL(repositoryUrl);
+			if (parsed.pathname.endsWith(`/${this.INDEX_FILE}`)) parsed.pathname = parsed.pathname.replace(new RegExp(`/${this.INDEX_FILE}$`), "");
+			else parsed.pathname = parsed.pathname.replace(/\/$/, "");
+			parsed.search = "";
+			parsed.hash = "";
+			return parsed.toString().replace(/\/$/, "");
+		} catch {
+			return null;
+		}
+	}
+	resolveInstallTarget(index, resolvedBaseUrl, entry) {
+		const repositoryUrl = this.resolveRepositoryUrl(index, resolvedBaseUrl, entry);
+		const skillRoot = this.getSkillRoot(entry);
+		const inlineBaseUrl = this.resolveInlineBaseUrl(repositoryUrl);
+		if (inlineBaseUrl) {
+			const skillMdRelativePath = entry.entry || posix.join(skillRoot, "SKILL.md");
+			return {
+				type: "inline",
+				repositoryUrl,
+				skillRoot,
+				skillMdUrl: this.buildUrl(inlineBaseUrl, skillMdRelativePath)
+			};
+		}
+		return {
+			type: "repository",
+			repositoryUrl,
+			subpath: skillRoot
+		};
+	}
 	match(url) {
 		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
 		try {
@@ -1501,14 +1575,17 @@ var WellKnownProvider = class {
 				debugLog(`[well-known] index response body: ${responseText}`);
 				const index = JSON.parse(responseText);
 				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
+				const totalSkillCount = index.skills.length;
+				const validSkills = index.skills.filter((entry) => this.isValidSkillEntry(entry));
+				const invalidSkillCount = totalSkillCount - validSkills.length;
+				return {
+					index: {
+						...index,
+						skills: validSkills
+					},
+					resolvedBaseUrl: resolvedBase,
+					totalSkillCount,
+					invalidSkillCount
 				};
 			} catch {
 				continue;
@@ -1532,6 +1609,12 @@ var WellKnownProvider = class {
 			if (file.startsWith("/") || file.startsWith("\\") || file.includes("..")) return false;
 		}
 		if (!e.files.some((f) => typeof f === "string" && f.toLowerCase() === "skill.md")) return false;
+		if (e.entry !== void 0) {
+			if (typeof e.entry !== "string") return false;
+			if (e.entry.startsWith("/") || e.entry.startsWith("\\") || e.entry.includes("..")) return false;
+			if (!e.entry.toLowerCase().endsWith("/skill.md") && e.entry.toLowerCase() !== "skill.md") return false;
+		}
+		if (e.repositoryId !== void 0 && typeof e.repositoryId !== "string") return false;
 		return true;
 	}
 	async fetchSkill(url, options = {}) {
@@ -1547,28 +1630,40 @@ var WellKnownProvider = class {
 			if (!skillName) return null;
 			const skillEntry = index.skills.find((s) => s.name === skillName);
 			if (!skillEntry) return null;
-			return this.fetchSkillByEntry(resolvedBaseUrl, skillEntry);
+			return this.fetchSkillByEntry(index, resolvedBaseUrl, skillEntry);
 		} catch {
 			return null;
 		}
 	}
-	async fetchSkillByEntry(baseUrl, entry) {
+	async fetchSkillByEntry(index, baseUrl, entry) {
 		try {
-			const skillBaseUrl = `${baseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${entry.name}`;
-			const skillMdUrl = `${skillBaseUrl}/SKILL.md`;
-			const response = await fetch(skillMdUrl);
+			const installTarget = this.resolveInstallTarget(index, baseUrl, entry);
+			const files = /* @__PURE__ */ new Map();
+			if (installTarget.type === "repository") return {
+				name: entry.name,
+				description: entry.description,
+				content: "",
+				installName: entry.name,
+				sourceUrl: installTarget.repositoryUrl,
+				files,
+				declaredFiles: [...entry.files],
+				indexEntry: entry,
+				installTarget
+			};
+			const response = await fetch(installTarget.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 normalizedFilePath = filePath.replace(/^\/+/, "");
+					const fileRelativePath = installTarget.skillRoot ? posix.join(installTarget.skillRoot, normalizedFilePath) : normalizedFilePath;
+					const fileUrl = this.buildUrl(this.resolveInlineBaseUrl(installTarget.repositoryUrl) || baseUrl, fileRelativePath);
 					const fileResponse = await fetch(fileUrl);
 					if (fileResponse.ok) return {
-						path: filePath,
+						path: normalizedFilePath,
 						content: await fileResponse.text()
 					};
 				} catch {}
@@ -1581,24 +1676,51 @@ var WellKnownProvider = class {
 				description: data.description,
 				content,
 				installName: entry.name,
-				sourceUrl: skillMdUrl,
+				sourceUrl: installTarget.skillMdUrl,
 				metadata: data.metadata,
 				files,
-				indexEntry: entry
+				declaredFiles: [...entry.files],
+				indexEntry: entry,
+				installTarget
 			};
 		} catch {
 			return null;
 		}
 	}
 	async fetchAllSkills(url, options = {}) {
+		return (await this.fetchAllSkillsWithStatus(url, options)).skills;
+	}
+	async fetchAllSkillsWithStatus(url, options = {}) {
 		try {
 			const result = await this.fetchIndex(url, options);
-			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);
+			if (!result) return {
+				skills: [],
+				status: "index-not-found",
+				totalSkillCount: 0,
+				invalidSkillCount: 0
+			};
+			const { index, resolvedBaseUrl, totalSkillCount, invalidSkillCount } = result;
+			if (index.skills.length === 0) return {
+				skills: [],
+				status: "no-valid-entries",
+				totalSkillCount,
+				invalidSkillCount
+			};
+			const skillPromises = index.skills.map((entry) => this.fetchSkillByEntry(index, resolvedBaseUrl, entry));
+			const skills = (await Promise.all(skillPromises)).filter((s) => s !== null);
+			return {
+				skills,
+				status: skills.length > 0 ? "ok" : "no-installable-skills",
+				totalSkillCount,
+				invalidSkillCount
+			};
 		} catch {
-			return [];
+			return {
+				skills: [],
+				status: "index-not-found",
+				totalSkillCount: 0,
+				invalidSkillCount: 0
+			};
 		}
 	}
 	toRawUrl(url) {
@@ -1804,7 +1926,7 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
-var version$1 = "1.4.4";
+var version$1 = "1.4.6";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -1814,6 +1936,40 @@ async function isSourcePrivate(source) {
 function initTelemetry(version) {
 	setVersion(version);
 }
+function getWellKnownFileCount(skill) {
+	return skill.declaredFiles.length > 0 ? skill.declaredFiles.length : skill.files.size;
+}
+function getWellKnownEmptyStateMessage(status, totalSkillCount, invalidSkillCount) {
+	switch (status) {
+		case "no-valid-entries": return totalSkillCount > 0 ? `Found a skills index, but all ${totalSkillCount} entr${totalSkillCount === 1 ? "y is" : "ies are"} invalid. Check that each entry has a top-level SKILL.md in files[].` : "Found a skills index, but it does not contain any valid skill entries.";
+		case "no-installable-skills":
+			if (invalidSkillCount > 0) return `Found a skills index, but no installable skills could be loaded. ${invalidSkillCount} invalid entr${invalidSkillCount === 1 ? "y was" : "ies were"} skipped.`;
+			return "Found a skills index, but no installable skills could be loaded from it.";
+		default: return "No skills found at this URL. Make sure the server has a /.well-known/skills/index.json file.";
+	}
+}
+async function prepareRepositoryBackedWellKnownSkill(skill) {
+	if (skill.installTarget.type !== "repository") throw new Error("Skill is not repository-backed");
+	const tempDir = await cloneRepo(skill.installTarget.repositoryUrl);
+	try {
+		const discovered = await discoverSkills(tempDir, skill.installTarget.subpath, {
+			includeInternal: true,
+			fullDepth: true
+		});
+		const matched = discovered.find((candidate) => candidate.name.toLowerCase() === skill.installName.toLowerCase()) || discovered[0];
+		if (!matched) throw new Error(`No skill found at ${skill.installTarget.repositoryUrl}${skill.installTarget.subpath ? ` (${skill.installTarget.subpath})` : ""}`);
+		return {
+			preparedSkill: {
+				...matched,
+				name: skill.installName
+			},
+			tempDir
+		};
+	} catch (error) {
+		await cleanupTempDir(tempDir).catch(() => {});
+		throw error;
+	}
+}
 function riskLabel(risk) {
 	switch (risk) {
 		case "critical": return import_picocolors.default.red(import_picocolors.default.bold("Critical Risk"));
@@ -1970,6 +2126,33 @@ async function selectAgentsInteractive(options) {
 	return selected;
 }
 setVersion(version$1);
+function resolveInstallOutcome(successCount, failCount) {
+	if (failCount === 0) return "success";
+	if (successCount === 0) return "failure";
+	return "partial_failure";
+}
+function buildFailedDetails(results) {
+	const failed = results.filter((result) => !result.success).map((result) => `${result.skill}@${result.agent}${result.error ? `:${result.error}` : ""}`);
+	return failed.length > 0 ? JSON.stringify(failed) : void 0;
+}
+function reportInstallToSunIfNeeded(params) {
+	if (!isInternalSkillSourceUrl(params.sourceUrl)) return;
+	trackInstallReport({
+		event: "install",
+		source: params.source,
+		sourceUrl: params.sourceUrl,
+		skills: params.skills.join(","),
+		agents: params.agents.join(","),
+		...params.installGlobally && { global: "1" },
+		...params.skillFiles && { skillFiles: JSON.stringify(params.skillFiles) },
+		...params.sourceType && { sourceType: params.sourceType },
+		result: resolveInstallOutcome(params.successfulCount, params.failedCount),
+		successCount: String(params.successfulCount),
+		failCount: String(params.failedCount),
+		...params.failedDetails && { failedDetails: params.failedDetails },
+		...params.errorMessage && { errorMessage: params.errorMessage }
+	});
+}
 function isBareSkillNameSource(source) {
 	return /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/.test(source);
 }
@@ -1980,297 +2163,367 @@ function buildFallbackGitSshUrl(source) {
 	return `git@${DEFAULT_GIT_FALLBACK_SSH_HOST}:${source.replace(/\.git$/, "")}.git`;
 }
 async function handleWellKnownSkills(source, url, options, spinner, allowFallback = false, fallbackToRoot = true) {
-	spinner.start("Discovering skills from well-known endpoint...");
-	const skills = await wellKnownProvider.fetchAllSkills(url, { fallbackToRoot });
-	if (skills.length === 0) {
-		if (allowFallback) {
-			spinner.stop(import_picocolors.default.yellow("Default well-known endpoint unavailable"));
-			return false;
-		}
-		spinner.stop(import_picocolors.default.red("No skills found"));
-		Se(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.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
-	for (const skill of skills) {
-		M.info(`Skill: ${import_picocolors.default.cyan(skill.installName)}`);
-		M.message(import_picocolors.default.dim(skill.description));
-		if (skill.files.size > 1) M.message(import_picocolors.default.dim(`  Files: ${Array.from(skill.files.keys()).join(", ")}`));
-	}
-	if (options.list) {
-		console.log();
-		M.step(import_picocolors.default.bold("Available Skills"));
-		for (const skill of skills) {
-			M.message(`  ${import_picocolors.default.cyan(skill.installName)}`);
-			M.message(`    ${import_picocolors.default.dim(skill.description)}`);
-			if (skill.files.size > 1) M.message(`    ${import_picocolors.default.dim(`Files: ${skill.files.size}`)}`);
-		}
-		console.log();
-		Se("Run without --list to install");
-		process.exit(0);
-	}
-	let selectedSkills;
-	if (options.skill?.includes("*")) {
-		selectedSkills = skills;
-		M.info(`Installing all ${skills.length} skills`);
-	} else if (options.skill && options.skill.length > 0) {
-		selectedSkills = skills.filter((s) => options.skill.some((name) => s.installName.toLowerCase() === name.toLowerCase() || s.name.toLowerCase() === name.toLowerCase()));
-		if (selectedSkills.length === 0) {
+	const shouldReportToSun = isInternalSkillSourceUrl(url);
+	try {
+		spinner.start("Discovering skills from well-known endpoint...");
+		const discovery = await wellKnownProvider.fetchAllSkillsWithStatus(url, { fallbackToRoot });
+		const skills = discovery.skills;
+		if (skills.length === 0) {
 			if (allowFallback) {
-				M.info(`Skill not found on default well-known endpoint: ${options.skill.join(", ")}`);
+				spinner.stop(import_picocolors.default.yellow("Default well-known endpoint unavailable"));
 				return false;
 			}
-			M.error(`No matching skills found for: ${options.skill.join(", ")}`);
-			M.info("Available skills:");
-			for (const s of skills) M.message(`  - ${s.installName}`);
+			spinner.stop(import_picocolors.default.red("No usable skills found"));
+			Se(import_picocolors.default.red(getWellKnownEmptyStateMessage(discovery.status, discovery.totalSkillCount, discovery.invalidSkillCount)));
 			process.exit(1);
 		}
-	} else if (skills.length === 1) {
-		selectedSkills = skills;
-		const firstSkill = skills[0];
-		M.info(`Skill: ${import_picocolors.default.cyan(firstSkill.installName)}`);
-	} else if (options.yes) {
-		selectedSkills = skills;
-		M.info(`Installing all ${skills.length} skills`);
-	} else {
-		const selected = await multiselect({
-			message: "Select skills to install",
-			options: skills.map((s) => ({
-				value: s,
-				label: s.installName,
-				hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
-			})),
-			required: true
-		});
-		if (pD(selected)) {
-			xe("Installation cancelled");
-			process.exit(0);
+		spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+		for (const skill of skills) {
+			M.info(`Skill: ${import_picocolors.default.cyan(skill.installName)}`);
+			M.message(import_picocolors.default.dim(skill.description));
+			if (skill.files.size > 1) M.message(import_picocolors.default.dim(`  Files: ${Array.from(skill.files.keys()).join(", ")}`));
+			else if (skill.declaredFiles.length > 1) M.message(import_picocolors.default.dim(`  Files: ${skill.declaredFiles.join(", ")}`));
 		}
-		selectedSkills = selected;
-	}
-	let targetAgents;
-	const validAgents = Object.keys(agents);
-	if (options.agent?.includes("*")) {
-		targetAgents = validAgents;
-		M.info(`Installing to all ${targetAgents.length} agents`);
-	} else if (options.agent && options.agent.length > 0) {
-		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
-		if (invalidAgents.length > 0) {
-			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
-			M.info(`Valid agents: ${validAgents.join(", ")}`);
-			process.exit(1);
+		if (options.list) {
+			console.log();
+			M.step(import_picocolors.default.bold("Available Skills"));
+			for (const skill of skills) {
+				M.message(`  ${import_picocolors.default.cyan(skill.installName)}`);
+				M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+				const fileCount = getWellKnownFileCount(skill);
+				if (fileCount > 1) M.message(`    ${import_picocolors.default.dim(`Files: ${fileCount}`)}`);
+			}
+			console.log();
+			Se("Run without --list to install");
+			process.exit(0);
 		}
-		targetAgents = options.agent;
-	} else {
-		spinner.start("Loading agents...");
-		const installedAgents = await detectInstalledAgents();
-		const totalAgents = Object.keys(agents).length;
-		spinner.stop(`${totalAgents} agents`);
-		if (installedAgents.length === 0) if (options.yes) {
-			targetAgents = validAgents;
-			M.info("Installing to all agents");
+		let selectedSkills;
+		if (options.skill?.includes("*")) {
+			selectedSkills = skills;
+			M.info(`Installing all ${skills.length} skills`);
+		} else if (options.skill && options.skill.length > 0) {
+			selectedSkills = skills.filter((s) => options.skill.some((name) => s.installName.toLowerCase() === name.toLowerCase() || s.name.toLowerCase() === name.toLowerCase()));
+			if (selectedSkills.length === 0) {
+				if (allowFallback) {
+					M.info(`Skill not found on default well-known endpoint: ${options.skill.join(", ")}`);
+					return false;
+				}
+				M.error(`No matching skills found for: ${options.skill.join(", ")}`);
+				M.info("Available skills:");
+				for (const s of skills) M.message(`  - ${s.installName}`);
+				process.exit(1);
+			}
+		} else if (skills.length === 1) {
+			selectedSkills = skills;
+			const firstSkill = skills[0];
+			M.info(`Skill: ${import_picocolors.default.cyan(firstSkill.installName)}`);
+		} else if (options.yes) {
+			selectedSkills = skills;
+			M.info(`Installing all ${skills.length} skills`);
 		} else {
-			M.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
-			})));
+			const selected = await multiselect({
+				message: "Select skills to install",
+				options: skills.map((s) => ({
+					value: s,
+					label: s.installName,
+					hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+				})),
+				required: true
+			});
 			if (pD(selected)) {
 				xe("Installation cancelled");
 				process.exit(0);
 			}
-			targetAgents = selected;
+			selectedSkills = selected;
 		}
-		else if (installedAgents.length === 1 || options.yes) {
-			targetAgents = ensureUniversalAgents(installedAgents);
-			if (installedAgents.length === 1) {
-				const firstAgent = installedAgents[0];
-				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
-			} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+		let targetAgents;
+		const validAgents = Object.keys(agents);
+		if (options.agent?.includes("*")) {
+			targetAgents = validAgents;
+			M.info(`Installing to all ${targetAgents.length} agents`);
+		} else if (options.agent && options.agent.length > 0) {
+			const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+			if (invalidAgents.length > 0) {
+				M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+				M.info(`Valid agents: ${validAgents.join(", ")}`);
+				process.exit(1);
+			}
+			targetAgents = options.agent;
 		} else {
-			const selected = await selectAgentsInteractive({ global: options.global });
-			if (pD(selected)) {
+			spinner.start("Loading agents...");
+			const installedAgents = await detectInstalledAgents();
+			const totalAgents = Object.keys(agents).length;
+			spinner.stop(`${totalAgents} agents`);
+			if (installedAgents.length === 0) if (options.yes) {
+				targetAgents = validAgents;
+				M.info("Installing to all agents");
+			} else {
+				M.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)) {
+					xe("Installation cancelled");
+					process.exit(0);
+				}
+				targetAgents = selected;
+			}
+			else if (installedAgents.length === 1 || options.yes) {
+				targetAgents = ensureUniversalAgents(installedAgents);
+				if (installedAgents.length === 1) {
+					const firstAgent = installedAgents[0];
+					M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+				} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+			} else {
+				const selected = await selectAgentsInteractive({ global: options.global });
+				if (pD(selected)) {
+					xe("Installation cancelled");
+					process.exit(0);
+				}
+				targetAgents = selected;
+			}
+		}
+		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)) {
 				xe("Installation cancelled");
 				process.exit(0);
 			}
-			targetAgents = selected;
+			installGlobally = scope;
 		}
-	}
-	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)) {
-			xe("Installation cancelled");
-			process.exit(0);
+		let installMode = options.copy ? "copy" : "symlink";
+		if (!options.copy && !options.yes) {
+			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)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			installMode = modeChoice;
 		}
-		installGlobally = scope;
-	}
-	let installMode = options.copy ? "copy" : "symlink";
-	if (!options.copy && !options.yes) {
-		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)) {
-			xe("Installation cancelled");
-			process.exit(0);
+		const cwd = process.cwd();
+		const summaryLines = [];
+		targetAgents.map((a) => agents[a].displayName);
+		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
+			skillName: skill.installName,
+			agent,
+			installed: await isSkillInstalled(skill.installName, agent, { 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);
 		}
-		installMode = modeChoice;
-	}
-	const cwd = process.cwd();
-	const summaryLines = [];
-	targetAgents.map((a) => agents[a].displayName);
-	const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
-		skillName: skill.installName,
-		agent,
-		installed: await isSkillInstalled(skill.installName, agent, { 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);
-	}
-	for (const skill of selectedSkills) {
-		if (summaryLines.length > 0) summaryLines.push("");
-		const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
-		summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
-		summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
-		if (skill.files.size > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${skill.files.size}`);
-		const skillOverwrites = overwriteStatus.get(skill.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)}`);
-	}
-	console.log();
-	Me(summaryLines.join("\n"), "Installation Summary");
-	if (!options.yes) {
-		const confirmed = await ye({ message: "Proceed with installation?" });
-		if (pD(confirmed) || !confirmed) {
-			xe("Installation cancelled");
-			process.exit(0);
+		for (const skill of selectedSkills) {
+			if (summaryLines.length > 0) summaryLines.push("");
+			const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
+			summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+			summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
+			const fileCount = getWellKnownFileCount(skill);
+			if (fileCount > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${fileCount}`);
+			const skillOverwrites = overwriteStatus.get(skill.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)}`);
 		}
-	}
-	spinner.start("Installing skills...");
-	const results = [];
-	for (const skill of selectedSkills) for (const agent of targetAgents) {
-		const result = await installWellKnownSkillForAgent(skill, agent, {
-			global: installGlobally,
-			mode: installMode
+		console.log();
+		Me(summaryLines.join("\n"), "Installation Summary");
+		if (!options.yes) {
+			const confirmed = await ye({ message: "Proceed with installation?" });
+			if (pD(confirmed) || !confirmed) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+		}
+		const preparedRepositorySkills = /* @__PURE__ */ new Map();
+		const repositoryPrepFailures = /* @__PURE__ */ new Map();
+		const repositoryTempDirs = [];
+		const repositoryBackedSkills = selectedSkills.filter((skill) => skill.installTarget.type === "repository");
+		if (repositoryBackedSkills.length > 0) {
+			spinner.start("Preparing repository-backed skills...");
+			for (const skill of repositoryBackedSkills) try {
+				const prepared = await prepareRepositoryBackedWellKnownSkill(skill);
+				preparedRepositorySkills.set(skill.installName, prepared.preparedSkill);
+				repositoryTempDirs.push(prepared.tempDir);
+			} catch (error) {
+				repositoryPrepFailures.set(skill.installName, error instanceof Error ? error.message : "Unknown error");
+			}
+			spinner.stop("Repository-backed skills prepared");
+		}
+		spinner.start("Installing skills...");
+		const results = [];
+		for (const skill of selectedSkills) for (const agent of targetAgents) {
+			let installOutcome;
+			const prepError = repositoryPrepFailures.get(skill.installName);
+			if (prepError) installOutcome = {
+				success: false,
+				path: "",
+				mode: installMode,
+				error: prepError
+			};
+			else if (skill.installTarget.type === "repository") {
+				const preparedSkill = preparedRepositorySkills.get(skill.installName);
+				if (!preparedSkill) installOutcome = {
+					success: false,
+					path: "",
+					mode: installMode,
+					error: "Repository-backed skill was not prepared"
+				};
+				else installOutcome = await installSkillForAgent(preparedSkill, agent, {
+					global: installGlobally,
+					mode: installMode
+				});
+			} else installOutcome = await installWellKnownSkillForAgent(skill, agent, {
+				global: installGlobally,
+				mode: installMode
+			});
+			results.push({
+				skill: skill.installName,
+				agent: agents[agent].displayName,
+				...installOutcome
+			});
+		}
+		await Promise.all(repositoryTempDirs.map((dir) => cleanupTempDir(dir).catch(() => {})));
+		spinner.stop("Installation complete");
+		console.log();
+		const successful = results.filter((r) => r.success);
+		const failed = results.filter((r) => !r.success);
+		const sourceIdentifier = wellKnownProvider.getSourceIdentifier(url);
+		const skillFiles = {};
+		for (const skill of selectedSkills) skillFiles[skill.installName] = skill.sourceUrl;
+		if (await isSourcePrivate(sourceIdentifier) !== true) track({
+			event: "install",
+			source: sourceIdentifier,
+			skills: selectedSkills.map((s) => s.installName).join(","),
+			agents: targetAgents.join(","),
+			...installGlobally && { global: "1" },
+			skillFiles: JSON.stringify(skillFiles),
+			sourceType: "well-known"
 		});
-		results.push({
-			skill: skill.installName,
-			agent: agents[agent].displayName,
-			...result
+		reportInstallToSunIfNeeded({
+			source: sourceIdentifier,
+			sourceUrl: url,
+			skills: selectedSkills.map((s) => s.installName),
+			agents: targetAgents,
+			installGlobally,
+			skillFiles,
+			sourceType: "well-known",
+			successfulCount: successful.length,
+			failedCount: failed.length,
+			failedDetails: buildFailedDetails(results)
 		});
-	}
-	spinner.stop("Installation complete");
-	console.log();
-	const successful = results.filter((r) => r.success);
-	const failed = results.filter((r) => !r.success);
-	const sourceIdentifier = wellKnownProvider.getSourceIdentifier(url);
-	const skillFiles = {};
-	for (const skill of selectedSkills) skillFiles[skill.installName] = skill.sourceUrl;
-	if (await isSourcePrivate(sourceIdentifier) !== true) track({
-		event: "install",
-		source: sourceIdentifier,
-		skills: selectedSkills.map((s) => s.installName).join(","),
-		agents: targetAgents.join(","),
-		...installGlobally && { global: "1" },
-		skillFiles: JSON.stringify(skillFiles),
-		sourceType: "well-known"
-	});
-	if (successful.length > 0 && installGlobally) {
-		const successfulSkillNames = new Set(successful.map((r) => r.skill));
-		for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
-			await addSkillToLock(skill.installName, {
-				source: sourceIdentifier,
-				sourceType: "well-known",
-				sourceUrl: skill.sourceUrl,
-				skillFolderHash: ""
-			});
-		} catch {}
-	}
-	if (successful.length > 0 && !installGlobally) {
-		const successfulSkillNames = new Set(successful.map((r) => r.skill));
-		for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
-			const matchingResult = successful.find((r) => r.skill === skill.installName);
-			const installDir = matchingResult?.canonicalPath || matchingResult?.path;
-			if (installDir) {
-				const computedHash = await computeSkillFolderHash(installDir);
-				await addSkillToLocalLock(skill.installName, {
+		if (successful.length > 0 && installGlobally) {
+			const successfulSkillNames = new Set(successful.map((r) => r.skill));
+			for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
+				await addSkillToLock(skill.installName, {
 					source: sourceIdentifier,
 					sourceType: "well-known",
-					computedHash
-				}, cwd);
-			}
-		} 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);
+					sourceUrl: skill.sourceUrl,
+					skillFolderHash: ""
+				});
+			} catch {}
 		}
-		const skillCount = bySkill.size;
-		const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
-		const copiedAgents = symlinkFailures.map((r) => r.agent);
-		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$2(r.path, cwd);
-					resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+		if (successful.length > 0 && !installGlobally) {
+			const successfulSkillNames = new Set(successful.map((r) => r.skill));
+			for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
+				const matchingResult = successful.find((r) => r.skill === skill.installName);
+				const installDir = matchingResult?.canonicalPath || matchingResult?.path;
+				if (installDir) {
+					const computedHash = await computeSkillFolderHash(installDir);
+					await addSkillToLocalLock(skill.installName, {
+						source: sourceIdentifier,
+						sourceType: "well-known",
+						computedHash
+					}, cwd);
+				}
+			} 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 symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+			const copiedAgents = symlinkFailures.map((r) => r.agent);
+			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$2(r.path, cwd);
+						resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+					}
+				} else {
+					if (firstResult.canonicalPath) {
+						const shortPath = shortenPath$2(firstResult.canonicalPath, cwd);
+						resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+					} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
+					resultLines.push(...buildResultLines(skillResults, targetAgents));
 				}
-			} else {
-				if (firstResult.canonicalPath) {
-					const shortPath = shortenPath$2(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" : ""}`);
+			Me(resultLines.join("\n"), title);
+			if (symlinkFailures.length > 0) {
+				M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgents)}`));
+				M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
 			}
 		}
-		const title = import_picocolors.default.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""}`);
-		Me(resultLines.join("\n"), title);
-		if (symlinkFailures.length > 0) {
-			M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgents)}`));
-			M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+		if (failed.length > 0) {
+			console.log();
+			M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+			for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
 		}
-	}
-	if (failed.length > 0) {
 		console.log();
-		M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
-		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+		Se(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
+		await promptForFindSkills(options, targetAgents);
+		return true;
+	} catch (error) {
+		if (shouldReportToSun) reportInstallToSunIfNeeded({
+			source: wellKnownProvider.getSourceIdentifier(url),
+			sourceUrl: url,
+			skills: options.skill || [],
+			agents: options.agent || [],
+			installGlobally: options.global ?? false,
+			sourceType: "well-known",
+			successfulCount: 0,
+			failedCount: 1,
+			errorMessage: error instanceof Error ? error.message : "Unknown error occurred"
+		});
+		throw error;
 	}
-	console.log();
-	Se(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
-	await promptForFindSkills(options, targetAgents);
-	return true;
 }
 async function runAdd(args, options = {}) {
 	let source = args[0] || DEFAULT_WELL_KNOWN_BASE_URL;
 	let installTipShown = false;
+	let parsed = null;
+	let installReportContext = null;
 	const showInstallTip = () => {
 		if (installTipShown) return;
 		M.message(import_picocolors.default.dim("Tip: use the --yes (-y) and --global (-g) flags to install without prompts."));
@@ -2300,7 +2553,7 @@ async function runAdd(args, options = {}) {
 			M.info(`Falling back to git source: ${import_picocolors.default.cyan(source)}`);
 		}
 		spinner.start("Parsing source...");
-		const parsed = parseSource(source);
+		parsed = parseSource(source);
 		spinner.stop(`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.skillFilter) {
 			options.skill = options.skill || [];
@@ -2623,6 +2876,15 @@ async function runAdd(args, options = {}) {
 			skillFiles[skill.name] = relativePath;
 		}
 		const normalizedSource = getOwnerRepo(parsed);
+		installReportContext = {
+			source: normalizedSource || parsed.url,
+			sourceUrl: parsed.url,
+			skills: selectedSkills.map((s) => s.name),
+			agents: targetAgents,
+			installGlobally,
+			sourceType: parsed.type,
+			skillFiles
+		};
 		if (normalizedSource) {
 			const ownerRepo = parseOwnerRepo(normalizedSource);
 			if (ownerRepo) {
@@ -2643,6 +2905,18 @@ async function runAdd(args, options = {}) {
 				skillFiles: JSON.stringify(skillFiles)
 			});
 		}
+		reportInstallToSunIfNeeded({
+			source: installReportContext.source,
+			sourceUrl: installReportContext.sourceUrl,
+			skills: installReportContext.skills,
+			agents: installReportContext.agents,
+			installGlobally: installReportContext.installGlobally,
+			sourceType: installReportContext.sourceType,
+			skillFiles: installReportContext.skillFiles,
+			successfulCount: successful.length,
+			failedCount: failed.length,
+			failedDetails: buildFailedDetails(results)
+		});
 		if (successful.length > 0 && installGlobally && normalizedSource) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			for (const skill of selectedSkills) {
@@ -2746,6 +3020,18 @@ async function runAdd(args, options = {}) {
 		Se(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
 		await promptForFindSkills(options, targetAgents);
 	} catch (error) {
+		if (parsed) reportInstallToSunIfNeeded({
+			source: getOwnerRepo(parsed) || parsed.url,
+			sourceUrl: parsed.url,
+			skills: installReportContext?.skills || [],
+			agents: installReportContext?.agents || [],
+			installGlobally: installReportContext?.installGlobally || false,
+			sourceType: installReportContext?.sourceType || parsed.type,
+			skillFiles: installReportContext?.skillFiles,
+			successfulCount: 0,
+			failedCount: 1,
+			errorMessage: error instanceof Error ? error.message : "Unknown error occurred"
+		});
 		if (error instanceof GitCloneError) {
 			M.error(import_picocolors.default.red("Failed to clone repository"));
 			for (const line of error.message.split("\n")) M.message(import_picocolors.default.dim(line));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bip-skills",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {