skills 1.5.12 → 1.5.13

package/README.md

@@ -139,6 +139,9 @@ npx skills find
 
 # Search by keyword
 npx skills find typescript
+
+# Search across every repository owned by an organization or user
+npx skills find react --owner vercel
 ```
 
 ### `skills update`

package/dist/cli.mjs

@@ -10,6 +10,7 @@ import { t as require_dist } from "./_chunks/libs/@vercel/detect-agent.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
+import { createHash } from "node:crypto";
 import { stripVTControlCharacters } from "node:util";
 import { homedir, platform, tmpdir } from "os";
 import * as readline from "readline";
@@ -18,8 +19,7 @@ import { promisify } from "util";
 import { execFile, execSync, spawn, spawnSync } from "child_process";
 import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
 import { parse } from "yaml";
-import { createHash } from "crypto";
-import { createHash as createHash$1 } from "node:crypto";
+import { createHash as createHash$1 } from "crypto";
 import { gunzipSync, inflateRawSync } from "node:zlib";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 function getOwnerRepo(parsed) {
@@ -720,7 +720,7 @@ async function computeSkillFolderHash(skillDir) {
 	const files = [];
 	await collectFiles(skillDir, skillDir, files);
 	files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-	const hash = createHash("sha256");
+	const hash = createHash$1("sha256");
 	for (const file of files) {
 		hash.update(file.relativePath);
 		hash.update(file.content);
@@ -1617,6 +1617,16 @@ async function detectInstalledAgents() {
 		installed: await config.detectInstalled()
 	})))).filter((r) => r.installed).map((r) => r.type);
 }
+const EVE_SUBAGENTS_DIR = join("agent", "subagents");
+function getEveSubagents(cwd = process.cwd()) {
+	const dir = join(cwd, EVE_SUBAGENTS_DIR);
+	if (!existsSync(dir)) return [];
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+	} catch {
+		return [];
+	}
+}
 function getUniversalAgents() {
 	return Object.entries(agents).filter(([_, config]) => config.skillsDir === ".agents/skills" && config.showInUniversalList !== false).map(([type]) => type);
 }
@@ -1654,8 +1664,12 @@ async function isDirEntryOrSymlinkToDir(entry, entryPath) {
 function getCanonicalSkillsDir(global, cwd) {
 	return join(global ? homedir() : cwd || process.cwd(), AGENTS_DIR$1, SKILLS_SUBDIR);
 }
-function getAgentBaseDir(agentType, global, cwd) {
+function getEveSubagentSkillsDir(subagent, cwd) {
+	return join(cwd || process.cwd(), EVE_SUBAGENTS_DIR, sanitizeName(subagent), "skills");
+}
+function getAgentBaseDir(agentType, global, cwd, eveSubagent) {
 	if (isUniversalAgent(agentType)) return getCanonicalSkillsDir(global, cwd);
+	if (agentType === "eve" && eveSubagent) return getEveSubagentSkillsDir(eveSubagent, cwd);
 	const agent = agents[agentType];
 	const baseDir = global ? homedir() : cwd || process.cwd();
 	if (global) {
@@ -1717,6 +1731,7 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const agent = agents[agentType];
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
+	const eveSubagent = options.eveSubagent;
 	if (isGlobal && agent.globalSkillsDir === void 0) return {
 		success: false,
 		path: "",
@@ -1725,9 +1740,9 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	};
 	const skillName = sanitizeName(skill.name || basename(skill.path));
 	const installMode = options.mode ?? "symlink";
-	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd) : getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent) : getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
 	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
 		success: false,
@@ -1869,7 +1884,7 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
 	const agent = agents[agentType];
 	const sanitized = sanitizeName(skillName);
 	if (options.global && agent.globalSkillsDir === void 0) return false;
-	const targetBase = options.global ? agent.globalSkillsDir : join(options.cwd || process.cwd(), agent.skillsDir);
+	const targetBase = options.global ? agent.globalSkillsDir : agentType === "eve" && options.eveSubagent ? getEveSubagentSkillsDir(options.eveSubagent, options.cwd) : join(options.cwd || process.cwd(), agent.skillsDir);
 	const skillDir = join(targetBase, sanitized);
 	if (!isPathSafe$1(targetBase, skillDir)) return false;
 	try {
@@ -1883,14 +1898,14 @@ function getInstallPath(skillName, agentType, options = {}) {
 	agents[agentType];
 	options.cwd || process.cwd();
 	const sanitized = sanitizeName(skillName);
-	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd);
+	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd, options.eveSubagent);
 	const installPath = join(targetBase, sanitized);
 	if (!isPathSafe$1(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return installPath;
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
-	const canonicalBase = options.agent === "eve" ? getAgentBaseDir("eve", options.global ?? false, options.cwd) : getCanonicalSkillsDir(options.global ?? false, options.cwd);
+	const canonicalBase = options.agent === "eve" ? getAgentBaseDir("eve", options.global ?? false, options.cwd, options.eveSubagent) : getCanonicalSkillsDir(options.global ?? false, options.cwd);
 	const canonicalPath = join(canonicalBase, sanitized);
 	if (!isPathSafe$1(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return canonicalPath;
@@ -1900,6 +1915,7 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
 	const installMode = options.mode ?? "symlink";
+	const eveSubagent = options.eveSubagent;
 	if (isGlobal && agent.globalSkillsDir === void 0) return {
 		success: false,
 		path: "",
@@ -1907,9 +1923,9 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 		error: `${agent.displayName} does not support global skill installation`
 	};
 	const skillName = sanitizeName(skill.installName);
-	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd) : getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent) : getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
 	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
 		success: false,
@@ -1981,6 +1997,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
 	const installMode = options.mode ?? "symlink";
+	const eveSubagent = options.eveSubagent;
 	if (isGlobal && agent.globalSkillsDir === void 0) return {
 		success: false,
 		path: "",
@@ -1988,7 +2005,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 		error: `${agent.displayName} does not support global skill installation`
 	};
 	const skillName = sanitizeName(skill.installName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	if (agentType === "eve" && !isEvePackagedSkill(skill.files)) {
 		const flatSkillPath = join(agentBase, toEveFlatSkillFileName(skill.installName));
 		if (!isPathSafe$1(agentBase, flatSkillPath)) return {
@@ -2018,7 +2035,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 			};
 		}
 	}
-	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd) : getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent) : getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentDir = join(agentBase, skillName);
 	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
@@ -2119,6 +2136,14 @@ async function listInstalledSkills(options = {}) {
 				path: agentDir,
 				agentType
 			});
+			if (agentType === "eve" && !isGlobal) for (const subagent of getEveSubagents(cwd)) {
+				const subagentDir = getEveSubagentSkillsDir(subagent, cwd);
+				if (!scopes.some((s) => s.path === subagentDir && s.global === isGlobal)) scopes.push({
+					global: isGlobal,
+					path: subagentDir,
+					agentType
+				});
+			}
 		}
 		const allAgentTypes = Object.keys(agents);
 		for (const agentType of allAgentTypes) {
@@ -2623,7 +2648,7 @@ var WellKnownProvider = class {
 		}
 	}
 	computeDigest(bytes) {
-		return `sha256:${createHash$1("sha256").update(bytes).digest("hex")}`;
+		return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
 	}
 	extractArchive(bytes, artifactUrl, contentType) {
 		if (this.isZipArchive(bytes, artifactUrl, contentType)) return this.extractZip(bytes);
@@ -3041,6 +3066,14 @@ async function fetchSkillDownload(source, slug) {
 		return null;
 	}
 }
+function computeSnapshotHash(files) {
+	const hash = createHash("sha256");
+	for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+		hash.update(file.path);
+		hash.update(file.contents);
+	}
+	return hash.digest("hex");
+}
 async function tryBlobInstall(ownerRepo, options = {}) {
 	const tree = await fetchRepoTree(ownerRepo, options.ref, options.getToken);
 	if (!tree) return null;
@@ -3099,22 +3132,22 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 	return {
 		skills: downloads.map(({ skill, download }) => {
 			const mdPathLower = skill.mdPath.toLowerCase();
-			mdPathLower.endsWith("/skill.md") ? skill.mdPath.slice(0, -9) : mdPathLower === "skill.md" || skill.mdPath.slice(0, -9);
+			const files = (mdPathLower.endsWith("/skill.md") ? skill.mdPath.slice(0, -9) : mdPathLower === "skill.md" ? "" : skill.mdPath.slice(0, -9)) ? download.files : download.files.filter((file) => file.path.toLowerCase() === "skill.md");
 			return {
 				name: skill.name,
 				description: skill.description,
 				path: "",
 				rawContent: skill.content,
 				metadata: skill.metadata,
-				files: download.files,
-				snapshotHash: download.hash,
+				files,
+				snapshotHash: files.length === download.files.length ? download.hash : computeSnapshotHash(files),
 				repoPath: skill.mdPath
 			};
 		}),
 		tree
 	};
 }
-var version$1 = "1.5.12";
+var version$1 = "1.5.13";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -3175,6 +3208,12 @@ function shortenPath$2(fullPath, cwd) {
 	if (fullPath === cwd || fullPath.startsWith(cwd + sep)) return "." + fullPath.slice(cwd.length);
 	return fullPath;
 }
+function computeSingleFileSkillHash(contents) {
+	const hash = createHash("sha256");
+	hash.update("SKILL.md");
+	hash.update(contents);
+	return hash.digest("hex");
+}
 function formatList$1(items, maxShow = 5) {
 	if (items.length <= maxShow) return items.join(", ");
 	const shown = items.slice(0, maxShow);
@@ -3203,6 +3242,37 @@ function buildAgentSummaryLines(targetAgents, installMode) {
 	}
 	return lines;
 }
+function targetDisplayName(target) {
+	const base = agents[target.agent].displayName;
+	return target.subagent ? `${base} (${target.subagent})` : base;
+}
+function targetKey(target) {
+	return target.subagent ? `${target.agent}:${target.subagent}` : target.agent;
+}
+function buildInstallTargets(targetAgents, eveSubagentTargets) {
+	const targets = [];
+	for (const agent of targetAgents) if (agent === "eve") for (const subagent of eveSubagentTargets) targets.push({
+		agent,
+		subagent
+	});
+	else targets.push({ agent });
+	return targets;
+}
+function buildTargetSummaryLines(targets, installMode) {
+	const lines = [];
+	const rootAgents = targets.filter((t) => !t.subagent).map((t) => t.agent);
+	const subagentNames = targets.filter((t) => t.subagent).map(targetDisplayName);
+	const { universal, symlinked } = splitAgentsByType(rootAgents);
+	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)}`);
+		if (subagentNames.length > 0) lines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(subagentNames)}`);
+	} else {
+		const allNames = targets.map(targetDisplayName);
+		lines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(allNames)}`);
+	}
+	return lines;
+}
 function ensureUniversalAgents(targetAgents) {
 	const universalAgents = getUniversalAgents();
 	const result = [...targetAgents];
@@ -3872,6 +3942,35 @@ async function runAdd(args, options = {}) {
 				targetAgents = selected;
 			}
 		}
+		if (options.subagent && options.subagent.length > 0 && !targetAgents.includes("eve")) targetAgents = [...targetAgents, "eve"];
+		let eveSubagentTargets = [void 0];
+		if (targetAgents.includes("eve")) {
+			const availableSubagents = getEveSubagents(process.cwd());
+			if (options.subagent && options.subagent.length > 0) eveSubagentTargets = options.subagent.map((s) => s === "root" || s === "." ? void 0 : s);
+			else if (availableSubagents.length > 0 && !options.yes) {
+				const selectedSubagents = await fe({
+					message: "Where should Eve skills be installed?",
+					options: [{
+						value: "",
+						label: "Root agent",
+						hint: "agent/skills"
+					}, ...availableSubagents.map((name) => ({
+						value: name,
+						label: name,
+						hint: `agent/subagents/${name}/skills`
+					}))],
+					initialValues: [""],
+					required: true
+				});
+				if (pD(selectedSubagents)) {
+					xe("Installation cancelled");
+					await cleanup(tempDir);
+					process.exit(0);
+				}
+				eveSubagentTargets = selectedSubagents.map((s) => s === "" ? void 0 : s);
+			}
+		}
+		const installTargets = buildInstallTargets(targetAgents, eveSubagentTargets);
 		let installGlobally = options.global ?? false;
 		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
 		if (options.global === void 0 && !options.yes && supportsGlobal) {
@@ -3895,8 +3994,9 @@ async function runAdd(args, options = {}) {
 			installGlobally = scope;
 		}
 		let installMode = options.copy ? "copy" : "symlink";
-		const uniqueDirs = new Set(targetAgents.map((a) => agents[a].skillsDir));
-		if (!options.copy && !options.yes && uniqueDirs.size > 1) {
+		const allEve = installTargets.every((t) => t.agent === "eve");
+		const uniqueDirs = new Set(installTargets.map((t) => t.subagent ? `eve:subagent:${t.subagent}` : agents[t.agent].skillsDir));
+		if (!options.copy && !options.yes && uniqueDirs.size > 1 && !allEve) {
 			const modeChoice = await ve({
 				message: "Installation method",
 				options: [{
@@ -3915,19 +4015,21 @@ async function runAdd(args, options = {}) {
 				process.exit(0);
 			}
 			installMode = modeChoice;
-		} else if (uniqueDirs.size <= 1) installMode = "copy";
+		} else if (uniqueDirs.size <= 1 || allEve) installMode = "copy";
 		const cwd = process.cwd();
 		const summaryLines = [];
-		targetAgents.map((a) => agents[a].displayName);
-		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
+		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => installTargets.map(async (target) => ({
 			skillName: skill.name,
-			agent,
-			installed: await isSkillInstalled(skill.name, agent, { global: installGlobally })
+			target,
+			installed: await isSkillInstalled(skill.name, target.agent, {
+				global: installGlobally,
+				eveSubagent: target.subagent
+			})
 		}))));
 		const overwriteStatus = /* @__PURE__ */ new Map();
-		for (const { skillName, agent, installed } of overwriteChecks) {
+		for (const { skillName, target, installed } of overwriteChecks) {
 			if (!overwriteStatus.has(skillName)) overwriteStatus.set(skillName, /* @__PURE__ */ new Map());
-			overwriteStatus.get(skillName).set(agent, installed);
+			overwriteStatus.get(skillName).set(targetKey(target), installed);
 		}
 		const groupedSummary = {};
 		const ungroupedSummary = [];
@@ -3939,14 +4041,15 @@ async function runAdd(args, options = {}) {
 		const printSkillSummary = (skills) => {
 			for (const skill of skills) {
 				if (summaryLines.length > 0) summaryLines.push("");
-				const shortCanonical = shortenPath$2(targetAgents.length === 1 ? getCanonicalPath(skill.name, {
+				const shortCanonical = shortenPath$2(installTargets.length === 1 ? getCanonicalPath(skill.name, {
 					global: installGlobally,
-					agent: targetAgents[0]
+					agent: installTargets[0].agent,
+					eveSubagent: installTargets[0].subagent
 				}) : getCanonicalPath(skill.name, { global: installGlobally }), cwd);
 				summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
-				summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
+				summaryLines.push(...buildTargetSummaryLines(installTargets, installMode));
 				const skillOverwrites = overwriteStatus.get(skill.name);
-				const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+				const overwriteAgents = installTargets.filter((t) => skillOverwrites?.get(targetKey(t))).map(targetDisplayName);
 				if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
 			}
 		};
@@ -3986,7 +4089,8 @@ async function runAdd(args, options = {}) {
 		}
 		spinner.start("Installing skills...");
 		const results = [];
-		for (const skill of selectedSkills) for (const agent of targetAgents) {
+		for (const skill of selectedSkills) for (const target of installTargets) {
+			const { agent, subagent } = target;
 			let result;
 			if (blobResult && "files" in skill) {
 				const blobSkill = skill;
@@ -3995,15 +4099,27 @@ async function runAdd(args, options = {}) {
 					files: blobSkill.files
 				}, agent, {
 					global: installGlobally,
-					mode: installMode
+					mode: installMode,
+					eveSubagent: subagent
 				});
-			} else result = await installSkillForAgent(skill, agent, {
+			} else if (tempDir && skill.path === tempDir && skill.rawContent) result = await installBlobSkillForAgent({
+				installName: skill.name,
+				files: [{
+					path: "SKILL.md",
+					contents: skill.rawContent
+				}]
+			}, agent, {
 				global: installGlobally,
 				mode: installMode
 			});
+			else result = await installSkillForAgent(skill, agent, {
+				global: installGlobally,
+				mode: installMode,
+				eveSubagent: subagent
+			});
 			results.push({
 				skill: getSkillDisplayName(skill),
-				agent: agents[agent].displayName,
+				agent: targetDisplayName(target),
 				pluginName: skill.pluginName,
 				...result
 			});
@@ -4069,17 +4185,20 @@ async function runAdd(args, options = {}) {
 		}
 		if (successful.length > 0 && !installGlobally) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
+			const eveSubagents = targetAgents.includes("eve") ? eveSubagentTargets.map((s) => s ?? "") : void 0;
+			const recordSubagents = eveSubagents && (eveSubagents.length > 1 || eveSubagents.some((s) => s !== ""));
 			for (const skill of selectedSkills) {
 				const skillDisplayName = getSkillDisplayName(skill);
 				if (successfulSkillNames.has(skillDisplayName)) try {
-					const computedHash = blobResult && "snapshotHash" in skill ? skill.snapshotHash : await computeSkillFolderHash(skill.path);
+					const computedHash = blobResult && "snapshotHash" in skill ? skill.snapshotHash : tempDir && skill.path === tempDir && skill.rawContent ? computeSingleFileSkillHash(skill.rawContent) : await computeSkillFolderHash(skill.path);
 					const skillPathValue = skillFiles[skill.name];
 					await addSkillToLocalLock(skill.name, {
 						source: lockSource || parsed.url,
 						ref: parsed.ref,
 						sourceType: parsed.type,
 						...skillPathValue && { skillPath: skillPathValue },
-						computedHash
+						computedHash,
+						...recordSubagents && { subagents: eveSubagents }
 					}, cwd);
 				} catch {}
 			}
@@ -4237,7 +4356,17 @@ function parseAddOptions(args) {
 			i--;
 		} else if (arg === "--full-depth") options.fullDepth = true;
 		else if (arg === "--copy") options.copy = true;
-		else if (arg === "--dangerously-accept-openclaw-risks") options.dangerouslyAcceptOpenclawRisks = true;
+		else if (arg === "--subagent") {
+			options.subagent = options.subagent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.subagent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "--dangerously-accept-openclaw-risks") options.dangerouslyAcceptOpenclawRisks = true;
 		else if (arg && !arg.startsWith("-")) source.push(arg);
 	}
 	return {
@@ -4257,9 +4386,54 @@ function formatInstalls(count) {
 	if (count >= 1e3) return `${(count / 1e3).toFixed(1).replace(/\.0$/, "")}K installs`;
 	return `${count} install${count === 1 ? "" : "s"}`;
 }
-async function searchSkillsAPI(query) {
+const GITHUB_OWNER_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,38})$/i;
+function parseFindOptions(args) {
+	const queryParts = [];
+	const options = {};
+	const errors = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg) continue;
+		let ownerValue;
+		if (arg === "--owner") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) {
+				errors.push("--owner requires a GitHub owner");
+				continue;
+			}
+			ownerValue = value;
+			i++;
+		} else if (arg.startsWith("--owner=")) {
+			ownerValue = arg.slice(8);
+			if (!ownerValue) {
+				errors.push("--owner requires a GitHub owner");
+				continue;
+			}
+		} else {
+			queryParts.push(arg);
+			continue;
+		}
+		const owner = ownerValue.trim().toLowerCase();
+		if (!GITHUB_OWNER_PATTERN.test(owner)) {
+			errors.push("--owner must be a valid GitHub owner");
+			continue;
+		}
+		options.owner = owner;
+	}
+	return {
+		query: queryParts.join(" "),
+		options,
+		errors
+	};
+}
+async function searchSkillsAPI(query, owner) {
 	try {
-		const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+		const params = new URLSearchParams({
+			q: query,
+			limit: "10"
+		});
+		if (owner) params.set("owner", owner);
+		const url = `${SEARCH_API_BASE}/api/search?${params.toString()}`;
 		const res = await fetch(url);
 		if (!res.ok) return [];
 		return (await res.json()).skills.map((skill) => ({
@@ -4277,7 +4451,7 @@ 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 = "") {
+async function runSearchPrompt(initialQuery = "", owner) {
 	let results = [];
 	let selectedIndex = 0;
 	let query = initialQuery;
@@ -4334,7 +4508,7 @@ async function runSearchPrompt(initialQuery = "") {
 		const debounceMs = Math.max(150, 350 - q.length * 50);
 		debounceTimer = setTimeout(async () => {
 			try {
-				results = await searchSkillsAPI(q);
+				results = await searchSkillsAPI(q, owner);
 				selectedIndex = 0;
 			} catch {
 				results = [];
@@ -4407,20 +4581,27 @@ async function isRepoPublic(owner, repo) {
 	return await isRepoPrivate(owner, repo) === false;
 }
 async function runFind(args) {
-	const query = args.join(" ");
+	const { query, options: findOptions, errors } = parseFindOptions(args);
+	const owner = findOptions.owner;
 	const isNonInteractive = !process.stdin.isTTY;
 	const agentTip = `${DIM$3}Tip: if running in a coding agent, follow these steps:${RESET$3}
-${DIM$3}  1) npx skills find [query]${RESET$3}
+${DIM$3}  1) npx skills find [query] [--owner <owner>]${RESET$3}
 ${DIM$3}  2) npx skills add <owner/repo@skill>${RESET$3}`;
+	if (errors.length > 0) {
+		for (const error of errors) console.error(error);
+		console.error("Usage: npx skills find <query> [--owner <owner>]");
+		return;
+	}
 	if (query) {
-		const results = await searchSkillsAPI(query);
+		const results = await searchSkillsAPI(query, owner);
 		track({
 			event: "find",
 			query,
 			resultCount: String(results.length)
 		});
 		if (results.length === 0) {
-			console.log(`${DIM$3}No skills found for "${query}"${RESET$3}`);
+			const ownerSuffix = owner ? ` from owner "${owner}"` : "";
+			console.log(`${DIM$3}No skills found for "${query}"${ownerSuffix}${RESET$3}`);
 			return;
 		}
 		console.log(`${DIM$3}Install with${RESET$3} npx skills add <owner/repo@skill>`);
@@ -4437,10 +4618,10 @@ ${DIM$3}  2) npx skills add <owner/repo@skill>${RESET$3}`;
 	if (isNonInteractive || await isRunningInAgent()) {
 		console.log(agentTip);
 		console.log();
-		console.log(`${DIM$3}Usage: npx skills find <query>${RESET$3}`);
+		console.log(`${DIM$3}Usage: npx skills find <query> [--owner <owner>]${RESET$3}`);
 		return;
 	}
-	const selected = await runSearchPrompt();
+	const selected = await runSearchPrompt("", owner);
 	track({
 		event: "find",
 		query: "",
@@ -4457,12 +4638,12 @@ ${DIM$3}  2) npx skills add <owner/repo@skill>${RESET$3}`;
 	console.log();
 	console.log(`${TEXT$2}Installing ${BOLD$3}${skillName}${RESET$3} from ${DIM$3}${pkg}${RESET$3}...`);
 	console.log();
-	const { source, options } = parseAddOptions([
+	const { source, options: addOptions } = parseAddOptions([
 		pkg,
 		"--skill",
 		skillName
 	]);
-	await runAdd(source, options);
+	await runAdd(source, addOptions);
 	console.log();
 	const info = getOwnerRepoFromString(pkg);
 	if (info && await isRepoPublic(info.owner, info.repo)) console.log(`${DIM$3}View the skill at${RESET$3} ${TEXT$2}https://skills.sh/${selected.slug}${RESET$3}`);
@@ -4982,6 +5163,7 @@ async function removeCommand(skillNames, options) {
 	} else {
 		await scanDir(getCanonicalSkillsDir(false, cwd));
 		for (const agent of Object.values(agents)) await scanDir(join(cwd, agent.skillsDir));
+		for (const subagent of getEveSubagents(cwd)) await scanDir(getEveSubagentSkillsDir(subagent, cwd));
 	}
 	const installedSkills = Array.from(skillNamesSet).sort();
 	spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
@@ -5055,7 +5237,10 @@ async function removeCommand(skillNames, options) {
 			const pathsToCleanup = new Set([skillPath]);
 			const sanitizedName = sanitizeName(skillName);
 			if (isGlobal && agent.globalSkillsDir) pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
-			else pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+			else {
+				pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+				if (agentKey === "eve") for (const subagent of getEveSubagents(cwd)) pathsToCleanup.add(join(getEveSubagentSkillsDir(subagent, cwd), sanitizedName));
+			}
 			for (const pathToCleanup of pathsToCleanup) {
 				if (pathToCleanup === canonicalPath) continue;
 				try {
@@ -5571,12 +5756,14 @@ async function updateProjectSkills(options = {}) {
 			const safeName = sanitizeMetadata(skill.name);
 			console.log(`${TEXT$1}Updating ${safeName}...${RESET$1}`);
 			const installUrl = formatSourceInput(skill.entry.source, skill.entry.ref);
+			const subagentArgs = skill.entry.subagents?.length ? ["--subagent", ...skill.entry.subagents.map((s) => s === "" ? "root" : s)] : [];
 			if (spawnSync(process.execPath, [
 				cliEntry,
 				"add",
 				installUrl,
 				"--skill",
 				skill.name,
+				...subagentArgs,
 				"-y"
 			], {
 				stdio: [
@@ -6084,6 +6271,9 @@ ${BOLD}Manage Skills:${RESET}
   list, ls             List installed skills
   find [query]         Search for skills interactively
 
+${BOLD}Find Options:${RESET}
+  --owner <owner>        Search only repositories from a GitHub owner
+
 ${BOLD}Updates:${RESET}
   update [skills...]   Update skills to latest versions (alias: upgrade)
 
@@ -6104,6 +6294,7 @@ ${BOLD}Add Options:${RESET}
   -l, --list             List available skills in the repository without installing
   -y, --yes              Skip confirmation prompts
   --copy                 Copy files instead of symlinking to agent directories
+  --subagent <names>     Install to Eve subagents (use 'root' for the root agent)
   --all                  Shorthand for --skill '*' --agent '*' -y
   --full-depth           Search all subdirectories even when a root SKILL.md exists
 
@@ -6150,6 +6341,7 @@ ${BOLD}Examples:${RESET}
   ${DIM}$${RESET} skills ls --json                      ${DIM}# JSON output${RESET}
   ${DIM}$${RESET} skills find                          ${DIM}# interactive search${RESET}
   ${DIM}$${RESET} skills find typescript               ${DIM}# search by keyword${RESET}
+  ${DIM}$${RESET} skills find react --owner vercel     ${DIM}# search within an owner${RESET}
   ${DIM}$${RESET} skills update
   ${DIM}$${RESET} skills update my-skill             ${DIM}# update a single skill${RESET}
   ${DIM}$${RESET} skills update -g                    ${DIM}# update global skills only${RESET}

package/package.json

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