bip-skills 1.4.11 → 1.4.13

package/dist/cli.mjs

@@ -9,7 +9,7 @@ import { t as require_gray_matter } from "./_chunks/libs/gray-matter.mjs";
 import "./_chunks/libs/extend-shallow.mjs";
 import "./_chunks/libs/esprima.mjs";
 import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
-import { execSync, spawnSync } from "child_process";
+import { execFile, execSync, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "path";
 import { homedir, platform, tmpdir } from "os";
@@ -17,6 +17,7 @@ import { fileURLToPath } from "url";
 import * as readline from "readline";
 import { Writable } from "stream";
 import { Buffer } from "node:buffer";
+import { promisify } from "util";
 import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
 import http from "node:http";
 import https from "node:https";
@@ -683,6 +684,118 @@ function filterSkills(skills, inputNames) {
 		return normalizedInputs.some((input) => input === name || input === displayName);
 	});
 }
+const execFileAsync = promisify(execFile);
+const GATEWAY_PROCESS_RE = /(?:yonclaw|openclaw)-gateway/i;
+const YONCLAW_PROCESS_RE = /yonclaw|openclaw-gateway|yonclaw-gateway/i;
+function getYonClawBaseDir(options = {}) {
+	if (options.baseDir) return options.baseDir;
+	const home = options.homeDir ?? homedir();
+	const currentPlatform = options.platform ?? platform();
+	const env = options.env ?? process.env;
+	if (env.YONCLAW_HOME) return env.YONCLAW_HOME;
+	if (currentPlatform === "darwin") return join(home, "Library", "Application Support", "yonclaw");
+	if (currentPlatform === "win32") return join(env.APPDATA || join(home, "AppData", "Roaming"), "yonclaw");
+	return join(options.xdgConfigDir || env.XDG_CONFIG_HOME || xdgConfig || join(home, ".config"), "yonclaw");
+}
+function getYonClawProfileSkillsDir(baseDir, profileKey) {
+	return join(baseDir, "profiles", profileKey, "userData", "runtime", "openclaw", "skills");
+}
+function getYonClawGlobalSkillsDirHint(options = {}) {
+	return getYonClawProfileSkillsDir(getYonClawBaseDir(options), "profile-*");
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+async function listProfileKeys(baseDir) {
+	try {
+		return (await readdir(join(baseDir, "profiles"), { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name.startsWith("profile-")).map((entry) => entry.name).sort();
+	} catch {
+		return [];
+	}
+}
+function unique(items) {
+	return Array.from(new Set(items));
+}
+function parseUserDataProfile(command) {
+	const match = command.match(/--user-data-dir=(?:"([^"]+)"|'([^']+)'|(\S+))/);
+	const userDataDir = match?.[1] ?? match?.[2] ?? match?.[3];
+	if (!userDataDir) return null;
+	return normalize(userDataDir).match(/[\\/]profiles[\\/]([^\\/]+)[\\/]userData$/)?.[1] ?? null;
+}
+function isLivePid(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+}
+function parsePsOutput(stdout) {
+	return stdout.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+		const match = line.match(/^(\d+)\s+(.+)$/);
+		if (!match) return [];
+		return [{
+			pid: Number(match[1]),
+			command: match[2]
+		}];
+	});
+}
+function parsePowershellProcesses(stdout) {
+	try {
+		const parsed = JSON.parse(stdout);
+		return (Array.isArray(parsed) ? parsed : [parsed]).flatMap((item) => {
+			if (typeof item.ProcessId !== "number" || typeof item.CommandLine !== "string") return [];
+			return [{
+				pid: item.ProcessId,
+				command: item.CommandLine
+			}];
+		});
+	} catch {
+		return [];
+	}
+}
+async function listYonClawProcesses(currentPlatform = platform()) {
+	try {
+		if (currentPlatform === "win32") {
+			const { stdout } = await execFileAsync("powershell.exe", [
+				"-NoProfile",
+				"-Command",
+				"Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
+			]);
+			return parsePowershellProcesses(stdout);
+		}
+		const { stdout } = await execFileAsync("ps", ["-axo", "pid=,command="]);
+		return parsePsOutput(stdout);
+	} catch {
+		return [];
+	}
+}
+async function resolveYonClawGlobalSkillsDirs(options = {}) {
+	const baseDir = getYonClawBaseDir(options);
+	const profileKeys = await listProfileKeys(baseDir);
+	if (profileKeys.length === 0) return [];
+	const processes = await (options.processProvider ?? { listProcesses: () => listYonClawProcesses(options.platform) }).listProcesses();
+	const processByPid = new Map(processes.map((processInfo) => [processInfo.pid, processInfo]));
+	const liveGatewayProfiles = [];
+	for (const profileKey of profileKeys) {
+		const runtime = await readJson(join(baseDir, "profiles", profileKey, "userData", "gateway-runtime.json"));
+		if (typeof runtime?.pid !== "number") continue;
+		const processInfo = processByPid.get(runtime.pid);
+		if (processInfo && GATEWAY_PROCESS_RE.test(processInfo.command) && isLivePid(runtime.pid)) liveGatewayProfiles.push(profileKey);
+	}
+	if (liveGatewayProfiles.length > 0) return unique(liveGatewayProfiles).map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+	const userDataProfiles = unique(processes.filter((processInfo) => YONCLAW_PROCESS_RE.test(processInfo.command)).map((processInfo) => parseUserDataProfile(processInfo.command)).filter((profileKey) => Boolean(profileKey)).filter((profileKey) => profileKeys.includes(profileKey)));
+	if (userDataProfiles.length > 0) return userDataProfiles.map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+	if (processes.some((processInfo) => YONCLAW_PROCESS_RE.test(processInfo.command))) {
+		const activeProfile = await readJson(join(baseDir, "device", "active-profile.json"));
+		if (typeof activeProfile?.profileKey === "string" && profileKeys.includes(activeProfile.profileKey)) return [getYonClawProfileSkillsDir(baseDir, activeProfile.profileKey)];
+	}
+	return profileKeys.map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+}
 const home = homedir();
 const configHome = xdgConfig ?? join(home, ".config");
 const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
@@ -703,6 +816,17 @@ const agents = {
 			return existsSync(join(configHome, "amp"));
 		}
 	},
+	yonclaw: {
+		name: "yonclaw",
+		displayName: "YonClaw",
+		skillsDir: "runtime/openclaw/skills",
+		globalSkillsDir: getYonClawGlobalSkillsDirHint(),
+		resolveGlobalSkillsDirs: resolveYonClawGlobalSkillsDirs,
+		supportsProjectInstall: false,
+		detectInstalled: async () => {
+			return existsSync(getYonClawBaseDir());
+		}
+	},
 	antigravity: {
 		name: "antigravity",
 		displayName: "Antigravity",
@@ -1079,6 +1203,10 @@ function getNonUniversalAgents() {
 function isUniversalAgent(type) {
 	return agents[type].skillsDir === ".agents/skills";
 }
+function agentSupportsGlobalInstall$1(agentType) {
+	const agent = agents[agentType];
+	return agent.globalSkillsDir !== void 0 || agent.resolveGlobalSkillsDirs !== void 0;
+}
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
@@ -1100,6 +1228,13 @@ function getAgentBaseDir(agentType, global, cwd) {
 	}
 	return join(baseDir, agent.skillsDir);
 }
+async function getAgentBaseDirs(agentType, global, cwd) {
+	const agent = agents[agentType];
+	if (!global && agent.supportsProjectInstall === false) return [];
+	if (global && agent.resolveGlobalSkillsDirs) return agent.resolveGlobalSkillsDirs();
+	if (global && !agentSupportsGlobalInstall$1(agentType)) return [];
+	return [getAgentBaseDir(agentType, global, cwd)];
+}
 function resolveSymlinkTarget(linkPath, linkTarget) {
 	return resolve(dirname(linkPath), linkTarget);
 }
@@ -1151,7 +1286,13 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const agent = agents[agentType];
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
-	if (isGlobal && agent.globalSkillsDir === void 0) return {
+	if (!isGlobal && agent.supportsProjectInstall === false) return {
+		success: false,
+		path: "",
+		mode: options.mode ?? "symlink",
+		error: `${agent.displayName} only supports global skill installation. Use --global.`
+	};
+	if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) return {
 		success: false,
 		path: "",
 		mode: options.mode ?? "symlink",
@@ -1160,28 +1301,37 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.name || basename(skill.path));
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
-	const agentDir = join(agentBase, skillName);
+	const agentBases = await getAgentBaseDirs(agentType, isGlobal, cwd);
+	const agentDirs = agentBases.map((agentBase) => join(agentBase, skillName));
+	const agentDir = agentDirs[0] ?? "";
 	const installMode = options.mode ?? "symlink";
+	if (agentBases.length === 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `No ${agent.displayName} skills directories found`
+	};
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	for (const [index, agentBase] of agentBases.entries()) if (!isPathSafe(agentBase, agentDirs[index])) return {
 		success: false,
-		path: agentDir,
+		path: agentDirs[index],
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
 	try {
 		if (installMode === "copy") {
-			await cleanAndCreateDirectory(agentDir);
-			await copyDirectory(skill.path, agentDir);
+			await Promise.all(agentDirs.map(async (targetDir) => {
+				await cleanAndCreateDirectory(targetDir);
+				await copyDirectory(skill.path, targetDir);
+			}));
 			return {
 				success: true,
-				path: agentDir,
+				path: agentDirs.join(", "),
 				mode: "copy"
 			};
 		}
@@ -1193,22 +1343,18 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 			canonicalPath: canonicalDir,
 			mode: "symlink"
 		};
-		if (!await createSymlink(canonicalDir, agentDir)) {
-			await cleanAndCreateDirectory(agentDir);
-			await copyDirectory(skill.path, agentDir);
-			return {
-				success: true,
-				path: agentDir,
-				canonicalPath: canonicalDir,
-				mode: "symlink",
-				symlinkFailed: true
-			};
+		let symlinkFailed = false;
+		for (const targetDir of agentDirs) if (!await createSymlink(canonicalDir, targetDir)) {
+			symlinkFailed = true;
+			await cleanAndCreateDirectory(targetDir);
+			await copyDirectory(skill.path, targetDir);
 		}
 		return {
 			success: true,
-			path: agentDir,
+			path: agentDirs.join(", "),
 			canonicalPath: canonicalDir,
-			mode: "symlink"
+			mode: "symlink",
+			...symlinkFailed && { symlinkFailed: true }
 		};
 	} catch (error) {
 		return {
@@ -1243,25 +1389,27 @@ async function copyDirectory(src, dest) {
 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 skillDir = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, skillDir)) return false;
-	try {
-		await access(skillDir);
-		return true;
-	} catch {
-		return false;
+	if (!options.global && agent.supportsProjectInstall === false) return false;
+	if (options.global && !agentSupportsGlobalInstall$1(agentType)) return false;
+	const targetBases = await getAgentBaseDirs(agentType, options.global ?? false, options.cwd);
+	if (targetBases.length === 0) return false;
+	for (const targetBase of targetBases) {
+		const skillDir = join(targetBase, sanitized);
+		if (!isPathSafe(targetBase, skillDir)) continue;
+		try {
+			await access(skillDir);
+			return true;
+		} catch {}
 	}
+	return false;
 }
-function getInstallPath(skillName, agentType, options = {}) {
-	agents[agentType];
-	options.cwd || process.cwd();
+async function getInstallPaths(skillName, agentType, options = {}) {
 	const sanitized = sanitizeName(skillName);
-	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd);
-	const installPath = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
-	return installPath;
+	return (await getAgentBaseDirs(agentType, options.global ?? false, options.cwd)).map((targetBase) => {
+		const installPath = join(targetBase, sanitized);
+		if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+		return installPath;
+	});
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
@@ -1275,7 +1423,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
 	const installMode = options.mode ?? "symlink";
-	if (isGlobal && agent.globalSkillsDir === void 0) return {
+	if (!isGlobal && agent.supportsProjectInstall === false) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} only supports global skill installation. Use --global.`
+	};
+	if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) return {
 		success: false,
 		path: "",
 		mode: installMode,
@@ -1284,17 +1438,24 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.installName);
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
-	const agentDir = join(agentBase, skillName);
+	const agentBases = await getAgentBaseDirs(agentType, isGlobal, cwd);
+	const agentDirs = agentBases.map((agentBase) => join(agentBase, skillName));
+	const agentDir = agentDirs[0] ?? "";
+	if (agentBases.length === 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `No ${agent.displayName} skills directories found`
+	};
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	for (const [index, agentBase] of agentBases.entries()) if (!isPathSafe(agentBase, agentDirs[index])) return {
 		success: false,
-		path: agentDir,
+		path: agentDirs[index],
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
@@ -1309,11 +1470,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	}
 	try {
 		if (installMode === "copy") {
-			await cleanAndCreateDirectory(agentDir);
-			await writeSkillFiles(agentDir);
+			await Promise.all(agentDirs.map(async (targetDir) => {
+				await cleanAndCreateDirectory(targetDir);
+				await writeSkillFiles(targetDir);
+			}));
 			return {
 				success: true,
-				path: agentDir,
+				path: agentDirs.join(", "),
 				mode: "copy"
 			};
 		}
@@ -1325,22 +1488,18 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 			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
-			};
+		let symlinkFailed = false;
+		for (const targetDir of agentDirs) if (!await createSymlink(canonicalDir, targetDir)) {
+			symlinkFailed = true;
+			await cleanAndCreateDirectory(targetDir);
+			await writeSkillFiles(targetDir);
 		}
 		return {
 			success: true,
-			path: agentDir,
+			path: agentDirs.join(", "),
 			canonicalPath: canonicalDir,
-			mode: "symlink"
+			mode: "symlink",
+			...symlinkFailed && { symlinkFailed: true }
 		};
 	} catch (error) {
 		return {
@@ -1367,10 +1526,10 @@ async function listInstalledSkills(options = {}) {
 			path: getCanonicalSkillsDir(isGlobal, cwd)
 		});
 		for (const agentType of agentsToCheck) {
-			const agent = agents[agentType];
-			if (isGlobal && agent.globalSkillsDir === void 0) continue;
-			const agentDir = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
-			if (!scopes.some((s) => s.path === agentDir && s.global === isGlobal)) scopes.push({
+			agents[agentType];
+			if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) continue;
+			const agentDirs = await getAgentBaseDirs(agentType, isGlobal, cwd);
+			for (const agentDir of agentDirs) if (!scopes.some((s) => s.path === agentDir && s.global === isGlobal)) scopes.push({
 				global: isGlobal,
 				path: agentDir,
 				agentType
@@ -1409,41 +1568,47 @@ async function listInstalledSkills(options = {}) {
 			const sanitizedSkillName = sanitizeName(skill.name);
 			const installedAgents = [];
 			for (const agentType of agentsToCheck) {
-				const agent = agents[agentType];
-				if (scope.global && agent.globalSkillsDir === void 0) continue;
-				const agentBase = scope.global ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+				agents[agentType];
+				if (scope.global && !agentSupportsGlobalInstall$1(agentType)) continue;
 				let found = false;
+				const agentBases = await getAgentBaseDirs(agentType, scope.global, cwd);
 				const possibleNames = Array.from(new Set([
 					entry.name,
 					sanitizedSkillName,
 					skill.name.toLowerCase().replace(/\s+/g, "-").replace(/[\/\\:\0]/g, "")
 				]));
-				for (const possibleName of possibleNames) {
-					const agentSkillDir = join(agentBase, possibleName);
-					if (!isPathSafe(agentBase, agentSkillDir)) continue;
-					try {
-						await access(agentSkillDir);
-						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;
+				for (const agentBase of agentBases) {
+					for (const possibleName of possibleNames) {
+						const agentSkillDir = join(agentBase, possibleName);
+						if (!isPathSafe(agentBase, agentSkillDir)) continue;
 						try {
-							const candidateSkillMd = join(candidateDir, "SKILL.md");
-							await stat(candidateSkillMd);
-							const candidateSkill = await parseSkillMd(candidateSkillMd);
-							if (candidateSkill && candidateSkill.name === skill.name) {
-								found = true;
-								break;
-							}
+							await access(agentSkillDir);
+							found = true;
+							break;
 						} catch {}
 					}
-				} catch {}
+					if (found) break;
+				}
+				if (!found) for (const agentBase of agentBases) {
+					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 candidateSkillMd = join(candidateDir, "SKILL.md");
+								await stat(candidateSkillMd);
+								const candidateSkill = await parseSkillMd(candidateSkillMd);
+								if (candidateSkill && candidateSkill.name === skill.name) {
+									found = true;
+									break;
+								}
+							} catch {}
+						}
+					} catch {}
+					if (found) break;
+				}
 				if (found) installedAgents.push(agentType);
 			}
 			if (skillsMap.has(skillKey)) {
@@ -2075,7 +2240,7 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
-var version$1 = "1.4.11";
+var version$1 = "1.4.13";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -2213,6 +2378,47 @@ function ensureUniversalAgents(targetAgents) {
 	for (const ua of universalAgents) if (!result.includes(ua)) result.push(ua);
 	return result;
 }
+function agentSupportsGlobalInstall(agent) {
+	return agents[agent].globalSkillsDir !== void 0 || agents[agent].resolveGlobalSkillsDirs !== void 0;
+}
+function agentSupportsScope(agent, global) {
+	if (global === true) return agentSupportsGlobalInstall(agent);
+	if (global === false) return agents[agent].supportsProjectInstall !== false;
+	return true;
+}
+function resolveAgentScopes(targetAgents, installGlobally, explicitlyRequestedAgents) {
+	if (installGlobally) return {
+		targetAgents,
+		autoGlobalAgents: []
+	};
+	const unsupported = targetAgents.filter((agent) => agents[agent].supportsProjectInstall === false);
+	if (unsupported.length === 0) return {
+		targetAgents,
+		autoGlobalAgents: []
+	};
+	if (explicitlyRequestedAgents?.includes("*")) {
+		const filtered = targetAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
+		if (filtered.length === 0) return {
+			targetAgents: unsupported,
+			autoGlobalAgents: unsupported
+		};
+		return {
+			targetAgents: filtered,
+			autoGlobalAgents: []
+		};
+	}
+	return {
+		targetAgents,
+		autoGlobalAgents: unsupported
+	};
+}
+function shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents) {
+	return installGlobally || autoGlobalAgents.includes(agent);
+}
+function warnAutoGlobalAgents(autoGlobalAgents) {
+	if (autoGlobalAgents.length === 0) return;
+	M.warn(`${formatList$1(autoGlobalAgents.map((agent) => agents[agent].displayName))} only supports global skill installation and was installed globally.`);
+}
 function buildResultLines(results, targetAgents) {
 	const lines = [];
 	const { universal, symlinked: symlinkAgents } = splitAgentsByType(targetAgents);
@@ -2256,9 +2462,9 @@ async function promptForAgents(message, choices) {
 	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 supportsScopeFilter = (a) => agentSupportsScope(a, options.global);
+	const universalAgents = getUniversalAgents().filter(supportsScopeFilter);
+	const otherAgents = getNonUniversalAgents().filter(supportsScopeFilter);
 	const universalSection = {
 		title: "Universal (.agents/skills)",
 		items: universalAgents.map((a) => ({
@@ -2449,7 +2655,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			}
 		}
 		let installGlobally = options.global ?? false;
-		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+		const supportsGlobal = targetAgents.some(agentSupportsGlobalInstall);
 		if (options.global === void 0 && !options.yes && supportsGlobal) {
 			const scope = await ve({
 				message: "Installation scope",
@@ -2469,6 +2675,9 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			}
 			installGlobally = scope;
 		}
+		const scopeResolution = resolveAgentScopes(targetAgents, installGlobally, options.agent);
+		targetAgents = scopeResolution.targetAgents;
+		const autoGlobalAgents = scopeResolution.autoGlobalAgents;
 		let installMode = options.copy ? "copy" : "symlink";
 		if (!options.copy && !options.yes) {
 			const modeChoice = await ve({
@@ -2495,7 +2704,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
 			skillName: skill.installName,
 			agent,
-			installed: await isSkillInstalled(skill.installName, agent, { global: installGlobally })
+			installed: await isSkillInstalled(skill.installName, agent, { global: shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents) })
 		}))));
 		const overwriteStatus = /* @__PURE__ */ new Map();
 		for (const { skillName, agent, installed } of overwriteChecks) {
@@ -2504,7 +2713,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 		}
 		for (const skill of selectedSkills) {
 			if (summaryLines.length > 0) summaryLines.push("");
-			const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
+			const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally || targetAgents.every((agent) => autoGlobalAgents.includes(agent)) }), cwd);
 			summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 			summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
 			const fileCount = getWellKnownFileCount(skill);
@@ -2557,11 +2766,11 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 					error: "Repository-backed skill was not prepared"
 				};
 				else installOutcome = await installSkillForAgent(preparedSkill, agent, {
-					global: installGlobally,
+					global: shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents),
 					mode: installMode
 				});
 			} else installOutcome = await installWellKnownSkillForAgent(skill, agent, {
-				global: installGlobally,
+				global: shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents),
 				mode: installMode
 			});
 			results.push({
@@ -2572,9 +2781,11 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 		}
 		await Promise.all(repositoryTempDirs.map((dir) => cleanupTempDir(dir).catch(() => {})));
 		spinner.stop("Installation complete");
+		warnAutoGlobalAgents(autoGlobalAgents);
 		console.log();
 		const successful = results.filter((r) => r.success);
 		const failed = results.filter((r) => !r.success);
+		const hasAnyGlobalInstall = installGlobally || autoGlobalAgents.length > 0;
 		const sourceIdentifier = wellKnownProvider.getSourceIdentifier(url);
 		const skillFiles = {};
 		for (const skill of selectedSkills) skillFiles[skill.installName] = skill.sourceUrl;
@@ -2583,7 +2794,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			source: sourceIdentifier,
 			skills: selectedSkills.map((s) => s.installName).join(","),
 			agents: targetAgents.join(","),
-			...installGlobally && { global: "1" },
+			...hasAnyGlobalInstall && { global: "1" },
 			skillFiles: JSON.stringify(skillFiles),
 			sourceType: "well-known"
 		});
@@ -2592,14 +2803,14 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			sourceUrl: url,
 			skills: selectedSkills.map((s) => s.installName),
 			agents: targetAgents,
-			installGlobally,
+			installGlobally: hasAnyGlobalInstall,
 			skillFiles,
 			sourceType: "well-known",
 			successfulCount: successful.length,
 			failedCount: failed.length,
 			failedDetails: buildFailedDetails(results)
 		});
-		if (successful.length > 0 && installGlobally) {
+		if (successful.length > 0 && hasAnyGlobalInstall) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
 				await addSkillToLock(skill.installName, {
@@ -2613,18 +2824,21 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 		}
 		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 {}
+			for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) {
+				if (!successful.some((r) => r.skill === skill.installName && targetAgents.some((agent) => agents[agent].displayName === r.agent && !shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents)))) continue;
+				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();
@@ -2908,7 +3122,7 @@ async function runAdd(args, options = {}) {
 			}
 		}
 		let installGlobally = options.global ?? false;
-		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+		const supportsGlobal = targetAgents.some(agentSupportsGlobalInstall);
 		if (options.global === void 0 && !options.yes && supportsGlobal) {
 			const scope = await ve({
 				message: "Installation scope",
@@ -2929,6 +3143,9 @@ async function runAdd(args, options = {}) {
 			}
 			installGlobally = scope;
 		}
+		const scopeResolution = resolveAgentScopes(targetAgents, installGlobally, options.agent);
+		targetAgents = scopeResolution.targetAgents;
+		const autoGlobalAgents = scopeResolution.autoGlobalAgents;
 		let installMode = options.copy ? "copy" : "symlink";
 		if (!options.copy && !options.yes) {
 			const modeChoice = await ve({
@@ -2956,7 +3173,7 @@ async function runAdd(args, options = {}) {
 		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
 			skillName: skill.name,
 			agent,
-			installed: await isSkillInstalled(skill.name, agent, { global: installGlobally })
+			installed: await isSkillInstalled(skill.name, agent, { global: shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents) })
 		}))));
 		const overwriteStatus = /* @__PURE__ */ new Map();
 		for (const { skillName, agent, installed } of overwriteChecks) {
@@ -2973,7 +3190,7 @@ async function runAdd(args, options = {}) {
 		const printSkillSummary = (skills) => {
 			for (const skill of skills) {
 				if (summaryLines.length > 0) summaryLines.push("");
-				const shortCanonical = shortenPath$2(getCanonicalPath(skill.name, { global: installGlobally }), cwd);
+				const shortCanonical = shortenPath$2(getCanonicalPath(skill.name, { global: installGlobally || targetAgents.every((agent) => autoGlobalAgents.includes(agent)) }), cwd);
 				summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 				summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
 				const skillOverwrites = overwriteStatus.get(skill.name);
@@ -3019,7 +3236,7 @@ async function runAdd(args, options = {}) {
 		const results = [];
 		for (const skill of selectedSkills) for (const agent of targetAgents) {
 			const result = await installSkillForAgent(skill, agent, {
-				global: installGlobally,
+				global: shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents),
 				mode: installMode
 			});
 			results.push({
@@ -3030,9 +3247,11 @@ async function runAdd(args, options = {}) {
 			});
 		}
 		spinner.stop("Installation complete");
+		warnAutoGlobalAgents(autoGlobalAgents);
 		console.log();
 		const successful = results.filter((r) => r.success);
 		const failed = results.filter((r) => !r.success);
+		const hasAnyGlobalInstall = installGlobally || autoGlobalAgents.length > 0;
 		const skillFiles = {};
 		for (const skill of selectedSkills) {
 			let relativePath;
@@ -3047,7 +3266,7 @@ async function runAdd(args, options = {}) {
 			sourceUrl: parsed.url,
 			skills: selectedSkills.map((s) => s.name),
 			agents: targetAgents,
-			installGlobally,
+			installGlobally: hasAnyGlobalInstall,
 			sourceType: parsed.type,
 			skillFiles
 		};
@@ -3059,7 +3278,7 @@ async function runAdd(args, options = {}) {
 					source: normalizedSource,
 					skills: selectedSkills.map((s) => s.name).join(","),
 					agents: targetAgents.join(","),
-					...installGlobally && { global: "1" },
+					...hasAnyGlobalInstall && { global: "1" },
 					skillFiles: JSON.stringify(skillFiles)
 				});
 			} else track({
@@ -3067,7 +3286,7 @@ async function runAdd(args, options = {}) {
 				source: normalizedSource,
 				skills: selectedSkills.map((s) => s.name).join(","),
 				agents: targetAgents.join(","),
-				...installGlobally && { global: "1" },
+				...hasAnyGlobalInstall && { global: "1" },
 				skillFiles: JSON.stringify(skillFiles)
 			});
 		}
@@ -3083,7 +3302,7 @@ async function runAdd(args, options = {}) {
 			failedCount: failed.length,
 			failedDetails: buildFailedDetails(results)
 		});
-		if (successful.length > 0 && installGlobally && normalizedSource) {
+		if (successful.length > 0 && (installGlobally || autoGlobalAgents.length > 0) && normalizedSource) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			for (const skill of selectedSkills) {
 				const skillDisplayName = getSkillDisplayName(skill);
@@ -3109,14 +3328,17 @@ async function runAdd(args, options = {}) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			for (const skill of selectedSkills) {
 				const skillDisplayName = getSkillDisplayName(skill);
-				if (successfulSkillNames.has(skillDisplayName)) try {
-					const computedHash = await computeSkillFolderHash(skill.path);
-					await addSkillToLocalLock(skill.name, {
-						source: normalizedSource || parsed.url,
-						sourceType: parsed.type,
-						computedHash
-					}, cwd);
-				} catch {}
+				if (successfulSkillNames.has(skillDisplayName)) {
+					if (!successful.some((r) => r.skill === skillDisplayName && targetAgents.some((agent) => agents[agent].displayName === r.agent && !shouldInstallAgentGlobally(agent, installGlobally, autoGlobalAgents)))) continue;
+					try {
+						const computedHash = await computeSkillFolderHash(skill.path);
+						await addSkillToLocalLock(skill.name, {
+							source: normalizedSource || parsed.url,
+							sourceType: parsed.type,
+							computedHash
+						}, cwd);
+					} catch {}
+				}
 			}
 		}
 		if (successful.length > 0) {
@@ -3284,6 +3506,12 @@ function parseAddOptions(args) {
 			i--;
 		} else if (arg === "--full-depth") options.fullDepth = true;
 		else if (arg === "--copy") options.copy = true;
+		else if (arg && /^-[ygld]+$/.test(arg)) for (const flag of arg.slice(1)) {
+			if (flag === "y") options.yes = true;
+			if (flag === "g") options.global = true;
+			if (flag === "l") options.list = true;
+			if (flag === "d") options.fullDepth = true;
+		}
 		else if (arg && !arg.startsWith("-")) source.push(arg);
 	}
 	return {
@@ -3619,9 +3847,10 @@ async function runSync(args, options = {}) {
 	M.info(`${toInstall.length} skill${toInstall.length !== 1 ? "s" : ""} to install/update`);
 	let targetAgents;
 	const validAgents = Object.keys(agents);
+	const projectAgents = validAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
 	const universalAgents = getUniversalAgents();
 	if (options.agent?.includes("*")) {
-		targetAgents = validAgents;
+		targetAgents = projectAgents;
 		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));
@@ -3630,7 +3859,11 @@ async function runSync(args, options = {}) {
 			M.info(`Valid agents: ${validAgents.join(", ")}`);
 			process.exit(1);
 		}
-		targetAgents = options.agent;
+		targetAgents = options.agent.filter((agent) => {
+			if (agents[agent].supportsProjectInstall !== false) return true;
+			M.error(`${agents[agent].displayName} only supports global skill installation.`);
+			process.exit(1);
+		});
 	} else {
 		spinner.start("Loading agents...");
 		const installedAgents = await detectInstalledAgents();
@@ -3642,7 +3875,7 @@ async function runSync(args, options = {}) {
 		} else {
 			const selected = await searchMultiselect({
 				message: "Which agents do you want to install to?",
-				items: getNonUniversalAgents().map((a) => ({
+				items: getNonUniversalAgents().filter((agent) => agents[agent].supportsProjectInstall !== false).map((a) => ({
 					value: a,
 					label: agents[a].displayName,
 					hint: agents[a].skillsDir
@@ -3663,12 +3896,12 @@ async function runSync(args, options = {}) {
 			targetAgents = selected;
 		}
 		else if (installedAgents.length === 1 || options.yes) {
-			targetAgents = [...installedAgents];
+			targetAgents = installedAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
 			for (const ua of universalAgents) if (!targetAgents.includes(ua)) targetAgents.push(ua);
 		} else {
 			const selected = await searchMultiselect({
 				message: "Which agents do you want to install to?",
-				items: getNonUniversalAgents().filter((a) => installedAgents.includes(a)).map((a) => ({
+				items: getNonUniversalAgents().filter((a) => installedAgents.includes(a) && agents[a].supportsProjectInstall !== false).map((a) => ({
 					value: a,
 					label: agents[a].displayName,
 					hint: agents[a].skillsDir
@@ -3949,10 +4182,13 @@ async function removeCommand(skillNames, options) {
 	};
 	if (isGlobal) {
 		await scanDir(getCanonicalSkillsDir(true, cwd));
-		for (const agent of Object.values(agents)) if (agent.globalSkillsDir !== void 0) await scanDir(agent.globalSkillsDir);
+		for (const agentType of Object.keys(agents)) {
+			const agent = agents[agentType];
+			if (agent.globalSkillsDir !== void 0 || agent.resolveGlobalSkillsDirs !== void 0) for (const agentDir of await getAgentBaseDirs(agentType, true, cwd)) await scanDir(agentDir);
+		}
 	} else {
 		await scanDir(getCanonicalSkillsDir(false, cwd));
-		for (const agent of Object.values(agents)) await scanDir(join(cwd, agent.skillsDir));
+		for (const agent of Object.values(agents).filter((agent) => agent.supportsProjectInstall !== false)) await scanDir(join(cwd, agent.skillsDir));
 	}
 	const installedSkills = Array.from(skillNamesSet).sort();
 	spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
@@ -4019,14 +4255,16 @@ async function removeCommand(skillNames, options) {
 		});
 		for (const agentKey of targetAgents) {
 			const agent = agents[agentKey];
-			const skillPath = getInstallPath(skillName, agentKey, {
+			const skillPaths = await getInstallPaths(skillName, agentKey, {
 				global: isGlobal,
 				cwd
 			});
-			const pathsToCleanup = new Set([skillPath]);
+			const pathsToCleanup = new Set(skillPaths);
 			const sanitizedName = sanitizeName(skillName);
-			if (isGlobal && agent.globalSkillsDir) pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
-			else pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+			if (isGlobal) {
+				const globalDirs = await getAgentBaseDirs(agentKey, true, cwd);
+				for (const globalDir of globalDirs) pathsToCleanup.add(join(globalDir, sanitizedName));
+			} else if (agent.supportsProjectInstall !== false) pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
 			for (const pathToCleanup of pathsToCleanup) {
 				if (pathToCleanup === canonicalPath) continue;
 				try {
@@ -4041,12 +4279,16 @@ async function removeCommand(skillNames, options) {
 		}
 		const remainingAgents = (await detectInstalledAgents()).filter((a) => !targetAgents.includes(a));
 		let isStillUsed = false;
-		for (const agentKey of remainingAgents) if (await lstat(getInstallPath(skillName, agentKey, {
-			global: isGlobal,
-			cwd
-		})).catch(() => null)) {
-			isStillUsed = true;
-			break;
+		for (const agentKey of remainingAgents) {
+			const paths = await getInstallPaths(skillName, agentKey, {
+				global: isGlobal,
+				cwd
+			});
+			for (const path of paths) if (await lstat(path).catch(() => null)) {
+				isStillUsed = true;
+				break;
+			}
+			if (isStillUsed) break;
 		}
 		if (!isStillUsed) await rm(canonicalPath, {
 			recursive: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bip-skills",
-  "version": "1.4.11",
+  "version": "1.4.13",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
@@ -14,6 +14,21 @@
     "README.md",
     "ThirdPartyNoticeText.txt"
   ],
+  "scripts": {
+    "build": "obuild && node scripts/generate-licenses.ts",
+    "generate-licenses": "node scripts/generate-licenses.ts",
+    "dev": "node src/cli.ts",
+    "exec:test": "node scripts/execute-tests.ts",
+    "pack:check": "npm pack --dry-run --ignore-scripts --cache .npm-cache",
+    "prepublishOnly": "npm run build",
+    "publish:npm": "node scripts/publish-npm.ts",
+    "format": "prettier --write 'src/**/*.ts' 'scripts/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts' 'scripts/**/*.ts'",
+    "prepare": "husky",
+    "test": "vitest",
+    "type-check": "tsc --noEmit",
+    "publish:snapshot": "npm version prerelease --preid=snapshot --no-git-tag-version && npm publish --tag snapshot"
+  },
   "lint-staged": {
     "src/**/*.ts": "prettier --write",
     "scripts/**/*.ts": "prettier --write",
@@ -29,6 +44,7 @@
     "augment",
     "claude-code",
     "openclaw",
+    "yonclaw",
     "cline",
     "codebuddy",
     "codex",
@@ -95,16 +111,5 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "build": "obuild && node scripts/generate-licenses.ts",
-    "generate-licenses": "node scripts/generate-licenses.ts",
-    "dev": "node src/cli.ts",
-    "exec:test": "node scripts/execute-tests.ts",
-    "pack:check": "npm pack --dry-run --ignore-scripts --cache .npm-cache",
-    "format": "prettier --write 'src/**/*.ts' 'scripts/**/*.ts'",
-    "format:check": "prettier --check 'src/**/*.ts' 'scripts/**/*.ts'",
-    "test": "vitest",
-    "type-check": "tsc --noEmit",
-    "publish:snapshot": "npm version prerelease --preid=snapshot --no-git-tag-version && npm publish --tag snapshot"
-  }
-}
+  "packageManager": "pnpm@10.17.1"
+}