@leemat/atlas 2026.2.6-3

package/dist/skills-DQK2ES0C.js

@@ -0,0 +1,1163 @@
+import { a as parseBooleanValue, o as createSubsystemLogger } from "./entry.js";
+import { m as resolveUserPath, t as CONFIG_DIR } from "./utils-C1qSQAOk.js";
+import { n as resolveAtlasPackageRootSync } from "./atlas-root-F1I7aUzD.js";
+import { a as MANIFEST_KEY, c as resolveEnableState, i as LEGACY_MANIFEST_KEYS, l as resolveMemorySlotDecision, s as normalizePluginsConfig, t as loadPluginManifestRegistry } from "./manifest-registry-CxTVtFfj.js";
+import path from "node:path";
+import fs from "node:fs";
+import JSON5 from "json5";
+import { fileURLToPath } from "node:url";
+import { formatSkillsForPrompt, loadSkillsFromDir } from "@earendil-works/pi-coding-agent";
+import YAML from "yaml";
+
+//#region src/markdown/frontmatter.ts
+function stripQuotes(value) {
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return value;
+}
+function coerceFrontmatterValue(value) {
+	if (value === null || value === void 0) return;
+	if (typeof value === "string") return value.trim();
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function parseYamlFrontmatter(block) {
+	try {
+		const parsed = YAML.parse(block);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		const result = {};
+		for (const [rawKey, value] of Object.entries(parsed)) {
+			const key = rawKey.trim();
+			if (!key) continue;
+			const coerced = coerceFrontmatterValue(value);
+			if (coerced === void 0) continue;
+			result[key] = coerced;
+		}
+		return result;
+	} catch {
+		return null;
+	}
+}
+function extractMultiLineValue(lines, startIndex) {
+	const match = lines[startIndex].match(/^([\w-]+):\s*(.*)$/);
+	if (!match) return {
+		value: "",
+		linesConsumed: 1
+	};
+	const inlineValue = match[2].trim();
+	if (inlineValue) return {
+		value: inlineValue,
+		linesConsumed: 1
+	};
+	const valueLines = [];
+	let i = startIndex + 1;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) break;
+		valueLines.push(line);
+		i++;
+	}
+	return {
+		value: valueLines.join("\n").trim(),
+		linesConsumed: i - startIndex
+	};
+}
+function parseLineFrontmatter(block) {
+	const frontmatter = {};
+	const lines = block.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const match = lines[i].match(/^([\w-]+):\s*(.*)$/);
+		if (!match) {
+			i++;
+			continue;
+		}
+		const key = match[1];
+		const inlineValue = match[2].trim();
+		if (!key) {
+			i++;
+			continue;
+		}
+		if (!inlineValue && i + 1 < lines.length) {
+			const nextLine = lines[i + 1];
+			if (nextLine.startsWith(" ") || nextLine.startsWith("	")) {
+				const { value, linesConsumed } = extractMultiLineValue(lines, i);
+				if (value) frontmatter[key] = value;
+				i += linesConsumed;
+				continue;
+			}
+		}
+		const value = stripQuotes(inlineValue);
+		if (value) frontmatter[key] = value;
+		i++;
+	}
+	return frontmatter;
+}
+function parseFrontmatterBlock(content) {
+	const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (!normalized.startsWith("---")) return {};
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return {};
+	const block = normalized.slice(4, endIndex);
+	const lineParsed = parseLineFrontmatter(block);
+	const yamlParsed = parseYamlFrontmatter(block);
+	if (yamlParsed === null) return lineParsed;
+	const merged = { ...yamlParsed };
+	for (const [key, value] of Object.entries(lineParsed)) if (value.startsWith("{") || value.startsWith("[")) merged[key] = value;
+	return merged;
+}
+
+//#endregion
+//#region src/agents/skills/frontmatter.ts
+function parseFrontmatter(content) {
+	return parseFrontmatterBlock(content);
+}
+function normalizeStringList(input) {
+	if (!input) return [];
+	if (Array.isArray(input)) return input.map((value) => String(value).trim()).filter(Boolean);
+	if (typeof input === "string") return input.split(",").map((value) => value.trim()).filter(Boolean);
+	return [];
+}
+function parseInstallSpec(input) {
+	if (!input || typeof input !== "object") return;
+	const raw = input;
+	const kind = (typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "").trim().toLowerCase();
+	if (kind !== "brew" && kind !== "node" && kind !== "go" && kind !== "uv" && kind !== "download") return;
+	const spec = { kind };
+	if (typeof raw.id === "string") spec.id = raw.id;
+	if (typeof raw.label === "string") spec.label = raw.label;
+	const bins = normalizeStringList(raw.bins);
+	if (bins.length > 0) spec.bins = bins;
+	const osList = normalizeStringList(raw.os);
+	if (osList.length > 0) spec.os = osList;
+	if (typeof raw.formula === "string") spec.formula = raw.formula;
+	if (typeof raw.package === "string") spec.package = raw.package;
+	if (typeof raw.module === "string") spec.module = raw.module;
+	if (typeof raw.url === "string") spec.url = raw.url;
+	if (typeof raw.archive === "string") spec.archive = raw.archive;
+	if (typeof raw.extract === "boolean") spec.extract = raw.extract;
+	if (typeof raw.stripComponents === "number") spec.stripComponents = raw.stripComponents;
+	if (typeof raw.targetDir === "string") spec.targetDir = raw.targetDir;
+	return spec;
+}
+function getFrontmatterValue(frontmatter, key) {
+	const raw = frontmatter[key];
+	return typeof raw === "string" ? raw : void 0;
+}
+function parseFrontmatterBool(value, fallback) {
+	const parsed = parseBooleanValue(value);
+	return parsed === void 0 ? fallback : parsed;
+}
+function resolveAtlasMetadata(frontmatter) {
+	const raw = getFrontmatterValue(frontmatter, "metadata");
+	if (!raw) return;
+	try {
+		const parsed = JSON5.parse(raw);
+		if (!parsed || typeof parsed !== "object") return;
+		const metadataRawCandidates = [MANIFEST_KEY, ...LEGACY_MANIFEST_KEYS];
+		let metadataRaw;
+		for (const key of metadataRawCandidates) {
+			const candidate = parsed[key];
+			if (candidate && typeof candidate === "object") {
+				metadataRaw = candidate;
+				break;
+			}
+		}
+		if (!metadataRaw || typeof metadataRaw !== "object") return;
+		const metadataObj = metadataRaw;
+		const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null ? metadataObj.requires : void 0;
+		const install = (Array.isArray(metadataObj.install) ? metadataObj.install : []).map((entry) => parseInstallSpec(entry)).filter((entry) => Boolean(entry));
+		const osRaw = normalizeStringList(metadataObj.os);
+		const dependsOnRaw = normalizeStringList(metadataObj.dependsOn);
+		const providesRaw = normalizeStringList(metadataObj.provides);
+		let exclusive;
+		if (typeof metadataObj.exclusive === "boolean") exclusive = metadataObj.exclusive;
+		else if (Array.isArray(metadataObj.exclusive)) {
+			const exclusiveList = normalizeStringList(metadataObj.exclusive);
+			if (exclusiveList.length > 0) exclusive = exclusiveList;
+		}
+		return {
+			always: typeof metadataObj.always === "boolean" ? metadataObj.always : void 0,
+			emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : void 0,
+			homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : void 0,
+			skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : void 0,
+			primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : void 0,
+			os: osRaw.length > 0 ? osRaw : void 0,
+			requires: requiresRaw ? {
+				bins: normalizeStringList(requiresRaw.bins),
+				anyBins: normalizeStringList(requiresRaw.anyBins),
+				env: normalizeStringList(requiresRaw.env),
+				config: normalizeStringList(requiresRaw.config)
+			} : void 0,
+			install: install.length > 0 ? install : void 0,
+			dependsOn: dependsOnRaw.length > 0 ? dependsOnRaw : void 0,
+			provides: providesRaw.length > 0 ? providesRaw : void 0,
+			exclusive
+		};
+	} catch {
+		return;
+	}
+}
+function resolveSkillInvocationPolicy(frontmatter) {
+	return {
+		userInvocable: parseFrontmatterBool(getFrontmatterValue(frontmatter, "user-invocable"), true),
+		disableModelInvocation: parseFrontmatterBool(getFrontmatterValue(frontmatter, "disable-model-invocation"), false)
+	};
+}
+function resolveSkillKey(skill, entry) {
+	return entry?.metadata?.skillKey ?? skill.name;
+}
+
+//#endregion
+//#region src/agents/skills/config.ts
+const DEFAULT_CONFIG_VALUES = {
+	"browser.enabled": true,
+	"browser.evaluateEnabled": true
+};
+function isTruthy(value) {
+	if (value === void 0 || value === null) return false;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value !== 0;
+	if (typeof value === "string") return value.trim().length > 0;
+	return true;
+}
+function resolveConfigPath(config, pathStr) {
+	const parts = pathStr.split(".").filter(Boolean);
+	let current = config;
+	for (const part of parts) {
+		if (typeof current !== "object" || current === null) return;
+		current = current[part];
+	}
+	return current;
+}
+function isConfigPathTruthy(config, pathStr) {
+	const value = resolveConfigPath(config, pathStr);
+	if (value === void 0 && pathStr in DEFAULT_CONFIG_VALUES) return DEFAULT_CONFIG_VALUES[pathStr];
+	return isTruthy(value);
+}
+function resolveSkillConfig(config, skillKey) {
+	const skills = config?.skills?.entries;
+	if (!skills || typeof skills !== "object") return;
+	const entry = skills[skillKey];
+	if (!entry || typeof entry !== "object") return;
+	return entry;
+}
+function resolveRuntimePlatform() {
+	return process.platform;
+}
+function normalizeAllowlist(input) {
+	if (!input) return;
+	if (!Array.isArray(input)) return;
+	const normalized = input.map((entry) => String(entry).trim()).filter(Boolean);
+	return normalized.length > 0 ? normalized : void 0;
+}
+const BUNDLED_SOURCES = new Set(["atlas-bundled"]);
+function isBundledSkill(entry) {
+	return BUNDLED_SOURCES.has(entry.skill.sourceInfo.source);
+}
+function resolveBundledAllowlist(config) {
+	return normalizeAllowlist(config?.skills?.allowBundled);
+}
+function isBundledSkillAllowed(entry, allowlist) {
+	if (!allowlist || allowlist.length === 0) return true;
+	if (!isBundledSkill(entry)) return true;
+	const key = resolveSkillKey(entry.skill, entry);
+	return allowlist.includes(key) || allowlist.includes(entry.skill.name);
+}
+function hasBinary(bin) {
+	const parts = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+	for (const part of parts) {
+		const candidate = path.join(part, bin);
+		try {
+			fs.accessSync(candidate, fs.constants.X_OK);
+			return true;
+		} catch {}
+	}
+	return false;
+}
+function shouldIncludeSkill(params) {
+	const { entry, config, eligibility } = params;
+	const skillConfig = resolveSkillConfig(config, resolveSkillKey(entry.skill, entry));
+	const allowBundled = normalizeAllowlist(config?.skills?.allowBundled);
+	const osList = entry.metadata?.os ?? [];
+	const remotePlatforms = eligibility?.remote?.platforms ?? [];
+	if (skillConfig?.enabled === false) return false;
+	if (!isBundledSkillAllowed(entry, allowBundled)) return false;
+	if (osList.length > 0 && !osList.includes(resolveRuntimePlatform()) && !remotePlatforms.some((platform) => osList.includes(platform))) return false;
+	if (entry.metadata?.always === true) return true;
+	const requiredBins = entry.metadata?.requires?.bins ?? [];
+	if (requiredBins.length > 0) for (const bin of requiredBins) {
+		if (hasBinary(bin)) continue;
+		if (eligibility?.remote?.hasBin?.(bin)) continue;
+		return false;
+	}
+	const requiredAnyBins = entry.metadata?.requires?.anyBins ?? [];
+	if (requiredAnyBins.length > 0) {
+		if (!(requiredAnyBins.some((bin) => hasBinary(bin)) || eligibility?.remote?.hasAnyBin?.(requiredAnyBins))) return false;
+	}
+	const requiredEnv = entry.metadata?.requires?.env ?? [];
+	if (requiredEnv.length > 0) for (const envName of requiredEnv) {
+		if (process.env[envName]) continue;
+		if (skillConfig?.env?.[envName]) continue;
+		if (skillConfig?.apiKey && entry.metadata?.primaryEnv === envName) continue;
+		return false;
+	}
+	const requiredConfig = entry.metadata?.requires?.config ?? [];
+	if (requiredConfig.length > 0) {
+		for (const configPath of requiredConfig) if (!isConfigPathTruthy(config, configPath)) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/agents/skills/env-overrides.ts
+function applySkillEnvOverrides(params) {
+	const { skills, config } = params;
+	const updates = [];
+	for (const entry of skills) {
+		const skillConfig = resolveSkillConfig(config, resolveSkillKey(entry.skill, entry));
+		if (!skillConfig) continue;
+		if (skillConfig.env) for (const [envKey, envValue] of Object.entries(skillConfig.env)) {
+			if (!envValue || process.env[envKey]) continue;
+			updates.push({
+				key: envKey,
+				prev: process.env[envKey]
+			});
+			process.env[envKey] = envValue;
+		}
+		const primaryEnv = entry.metadata?.primaryEnv;
+		if (primaryEnv && skillConfig.apiKey && !process.env[primaryEnv]) {
+			updates.push({
+				key: primaryEnv,
+				prev: process.env[primaryEnv]
+			});
+			process.env[primaryEnv] = skillConfig.apiKey;
+		}
+	}
+	return () => {
+		for (const update of updates) if (update.prev === void 0) delete process.env[update.key];
+		else process.env[update.key] = update.prev;
+	};
+}
+function applySkillEnvOverridesFromSnapshot(params) {
+	const { snapshot, config } = params;
+	if (!snapshot) return () => {};
+	const updates = [];
+	for (const skill of snapshot.skills) {
+		const skillConfig = resolveSkillConfig(config, skill.name);
+		if (!skillConfig) continue;
+		if (skillConfig.env) for (const [envKey, envValue] of Object.entries(skillConfig.env)) {
+			if (!envValue || process.env[envKey]) continue;
+			updates.push({
+				key: envKey,
+				prev: process.env[envKey]
+			});
+			process.env[envKey] = envValue;
+		}
+		if (skill.primaryEnv && skillConfig.apiKey && !process.env[skill.primaryEnv]) {
+			updates.push({
+				key: skill.primaryEnv,
+				prev: process.env[skill.primaryEnv]
+			});
+			process.env[skill.primaryEnv] = skillConfig.apiKey;
+		}
+	}
+	return () => {
+		for (const update of updates) if (update.prev === void 0) delete process.env[update.key];
+		else process.env[update.key] = update.prev;
+	};
+}
+
+//#endregion
+//#region src/agents/skills/bundled-dir.ts
+function looksLikeSkillsDir(dir) {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isFile() && entry.name.endsWith(".md")) return true;
+			if (entry.isDirectory()) {
+				if (fs.existsSync(path.join(fullPath, "SKILL.md"))) return true;
+			}
+		}
+	} catch {
+		return false;
+	}
+	return false;
+}
+function resolveBundledSkillsDir(opts = {}) {
+	const override = process.env.ATLAS_BUNDLED_SKILLS_DIR?.trim();
+	if (override) return override;
+	try {
+		const execPath = opts.execPath ?? process.execPath;
+		const execDir = path.dirname(execPath);
+		const sibling = path.join(execDir, "skills");
+		if (fs.existsSync(sibling)) return sibling;
+	} catch {}
+	try {
+		const moduleUrl = opts.moduleUrl ?? import.meta.url;
+		const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+		const packageRoot = resolveAtlasPackageRootSync({
+			argv1: opts.argv1 ?? process.argv[1],
+			moduleUrl,
+			cwd: opts.cwd ?? process.cwd()
+		});
+		if (packageRoot) {
+			const candidate = path.join(packageRoot, "skills");
+			if (looksLikeSkillsDir(candidate)) return candidate;
+		}
+		let current = moduleDir;
+		for (let depth = 0; depth < 6; depth += 1) {
+			const candidate = path.join(current, "skills");
+			if (looksLikeSkillsDir(candidate)) return candidate;
+			const next = path.dirname(current);
+			if (next === current) break;
+			current = next;
+		}
+	} catch {}
+}
+
+//#endregion
+//#region src/agents/skills/plugin-skills.ts
+const log$2 = createSubsystemLogger("skills");
+function resolvePluginSkillDirs(params) {
+	const workspaceDir = params.workspaceDir.trim();
+	if (!workspaceDir) return [];
+	const registry = loadPluginManifestRegistry({
+		workspaceDir,
+		config: params.config
+	});
+	if (registry.plugins.length === 0) return [];
+	const normalizedPlugins = normalizePluginsConfig(params.config?.plugins);
+	const memorySlot = normalizedPlugins.slots.memory;
+	let selectedMemoryPluginId = null;
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const record of registry.plugins) {
+		if (!record.skills || record.skills.length === 0) continue;
+		if (!resolveEnableState(record.id, record.origin, normalizedPlugins).enabled) continue;
+		const memoryDecision = resolveMemorySlotDecision({
+			id: record.id,
+			kind: record.kind,
+			slot: memorySlot,
+			selectedId: selectedMemoryPluginId
+		});
+		if (!memoryDecision.enabled) continue;
+		if (memoryDecision.selected && record.kind === "memory") selectedMemoryPluginId = record.id;
+		for (const raw of record.skills) {
+			const trimmed = raw.trim();
+			if (!trimmed) continue;
+			const candidate = path.resolve(record.rootDir, trimmed);
+			if (!fs.existsSync(candidate)) {
+				log$2.warn(`plugin skill path not found (${record.id}): ${candidate}`);
+				continue;
+			}
+			if (seen.has(candidate)) continue;
+			seen.add(candidate);
+			resolved.push(candidate);
+		}
+	}
+	return resolved;
+}
+
+//#endregion
+//#region src/agents/skills/serialize.ts
+const SKILLS_SYNC_QUEUE = /* @__PURE__ */ new Map();
+async function serializeByKey(key, task) {
+	const next = (SKILLS_SYNC_QUEUE.get(key) ?? Promise.resolve()).then(task, task);
+	SKILLS_SYNC_QUEUE.set(key, next);
+	try {
+		return await next;
+	} finally {
+		if (SKILLS_SYNC_QUEUE.get(key) === next) SKILLS_SYNC_QUEUE.delete(key);
+	}
+}
+
+//#endregion
+//#region src/agents/skills/workspace.ts
+const fsp = fs.promises;
+const skillsLogger = createSubsystemLogger("skills");
+const skillCommandDebugOnce = /* @__PURE__ */ new Set();
+function debugSkillCommandOnce(messageKey, message, meta) {
+	if (skillCommandDebugOnce.has(messageKey)) return;
+	skillCommandDebugOnce.add(messageKey);
+	skillsLogger.debug(message, meta);
+}
+function filterSkillEntries(entries, config, skillFilter, eligibility) {
+	let filtered = entries.filter((entry) => shouldIncludeSkill({
+		entry,
+		config,
+		eligibility
+	}));
+	if (skillFilter !== void 0) {
+		const normalized = skillFilter.map((entry) => String(entry).trim()).filter(Boolean);
+		const label = normalized.length > 0 ? normalized.join(", ") : "(none)";
+		console.log(`[skills] Applying skill filter: ${label}`);
+		filtered = normalized.length > 0 ? filtered.filter((entry) => normalized.includes(entry.skill.name)) : [];
+		console.log(`[skills] After filter: ${filtered.map((entry) => entry.skill.name).join(", ")}`);
+	}
+	return filtered;
+}
+const SKILL_COMMAND_MAX_LENGTH$1 = 32;
+const SKILL_COMMAND_FALLBACK$1 = "skill";
+const SKILL_COMMAND_DESCRIPTION_MAX_LENGTH = 100;
+function sanitizeSkillCommandName(raw) {
+	return raw.toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, SKILL_COMMAND_MAX_LENGTH$1) || SKILL_COMMAND_FALLBACK$1;
+}
+function resolveUniqueSkillCommandName(base, used) {
+	const normalizedBase = base.toLowerCase();
+	if (!used.has(normalizedBase)) return base;
+	for (let index = 2; index < 1e3; index += 1) {
+		const suffix = `_${index}`;
+		const maxBaseLength = Math.max(1, SKILL_COMMAND_MAX_LENGTH$1 - suffix.length);
+		const candidate = `${base.slice(0, maxBaseLength)}${suffix}`;
+		const candidateKey = candidate.toLowerCase();
+		if (!used.has(candidateKey)) return candidate;
+	}
+	return `${base.slice(0, Math.max(1, SKILL_COMMAND_MAX_LENGTH$1 - 2))}_x`;
+}
+function loadSkillEntries(workspaceDir, opts) {
+	const loadSkills = (params) => {
+		const loaded = loadSkillsFromDir(params);
+		if (Array.isArray(loaded)) return loaded;
+		if (loaded && typeof loaded === "object" && "skills" in loaded && Array.isArray(loaded.skills)) return loaded.skills;
+		return [];
+	};
+	const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+	const workspaceSkillsDir = path.join(workspaceDir, "skills");
+	const bundledSkillsDir = opts?.bundledSkillsDir ?? resolveBundledSkillsDir();
+	const extraDirs = (opts?.config?.skills?.load?.extraDirs ?? []).map((d) => typeof d === "string" ? d.trim() : "").filter(Boolean);
+	const pluginSkillDirs = resolvePluginSkillDirs({
+		workspaceDir,
+		config: opts?.config
+	});
+	const mergedExtraDirs = [...extraDirs, ...pluginSkillDirs];
+	const bundledSkills = bundledSkillsDir ? loadSkills({
+		dir: bundledSkillsDir,
+		source: "atlas-bundled"
+	}) : [];
+	const extraSkills = mergedExtraDirs.flatMap((dir) => {
+		return loadSkills({
+			dir: resolveUserPath(dir),
+			source: "atlas-extra"
+		});
+	});
+	const managedSkills = loadSkills({
+		dir: managedSkillsDir,
+		source: "atlas-managed"
+	});
+	const workspaceSkills = loadSkills({
+		dir: workspaceSkillsDir,
+		source: "atlas-workspace"
+	});
+	const merged = /* @__PURE__ */ new Map();
+	for (const skill of extraSkills) merged.set(skill.name, skill);
+	for (const skill of bundledSkills) merged.set(skill.name, skill);
+	for (const skill of managedSkills) merged.set(skill.name, skill);
+	for (const skill of workspaceSkills) merged.set(skill.name, skill);
+	return Array.from(merged.values()).map((skill) => {
+		let frontmatter = {};
+		try {
+			frontmatter = parseFrontmatter(fs.readFileSync(skill.filePath, "utf-8"));
+		} catch {}
+		return {
+			skill,
+			frontmatter,
+			metadata: resolveAtlasMetadata(frontmatter),
+			invocation: resolveSkillInvocationPolicy(frontmatter)
+		};
+	});
+}
+function buildWorkspaceSkillSnapshot(workspaceDir, opts) {
+	const eligible = filterSkillEntries(opts?.entries ?? loadSkillEntries(workspaceDir, opts), opts?.config, opts?.skillFilter, opts?.eligibility);
+	const resolvedSkills = eligible.filter((entry) => entry.invocation?.disableModelInvocation !== true).map((entry) => entry.skill);
+	return {
+		prompt: [opts?.eligibility?.remote?.note?.trim(), formatSkillsForPrompt(resolvedSkills)].filter(Boolean).join("\n"),
+		skills: eligible.map((entry) => ({
+			name: entry.skill.name,
+			primaryEnv: entry.metadata?.primaryEnv
+		})),
+		resolvedSkills,
+		version: opts?.snapshotVersion
+	};
+}
+function buildWorkspaceSkillsPrompt(workspaceDir, opts) {
+	const promptEntries = filterSkillEntries(opts?.entries ?? loadSkillEntries(workspaceDir, opts), opts?.config, opts?.skillFilter, opts?.eligibility).filter((entry) => entry.invocation?.disableModelInvocation !== true);
+	return [opts?.eligibility?.remote?.note?.trim(), formatSkillsForPrompt(promptEntries.map((entry) => entry.skill))].filter(Boolean).join("\n");
+}
+function resolveSkillsPromptForRun(params) {
+	const snapshotPrompt = params.skillsSnapshot?.prompt?.trim();
+	if (snapshotPrompt) return snapshotPrompt;
+	if (params.entries && params.entries.length > 0) {
+		const prompt = buildWorkspaceSkillsPrompt(params.workspaceDir, {
+			entries: params.entries,
+			config: params.config
+		});
+		return prompt.trim() ? prompt : "";
+	}
+	return "";
+}
+function loadWorkspaceSkillEntries(workspaceDir, opts) {
+	return loadSkillEntries(workspaceDir, opts);
+}
+async function syncSkillsToWorkspace(params) {
+	const sourceDir = resolveUserPath(params.sourceWorkspaceDir);
+	const targetDir = resolveUserPath(params.targetWorkspaceDir);
+	if (sourceDir === targetDir) return;
+	await serializeByKey(`syncSkills:${targetDir}`, async () => {
+		const targetSkillsDir = path.join(targetDir, "skills");
+		const entries = loadSkillEntries(sourceDir, {
+			config: params.config,
+			managedSkillsDir: params.managedSkillsDir,
+			bundledSkillsDir: params.bundledSkillsDir
+		});
+		await fsp.rm(targetSkillsDir, {
+			recursive: true,
+			force: true
+		});
+		await fsp.mkdir(targetSkillsDir, { recursive: true });
+		for (const entry of entries) {
+			const dest = path.join(targetSkillsDir, entry.skill.name);
+			try {
+				await fsp.cp(entry.skill.baseDir, dest, {
+					recursive: true,
+					force: true
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : JSON.stringify(error);
+				console.warn(`[skills] Failed to copy ${entry.skill.name} to sandbox: ${message}`);
+			}
+		}
+	});
+}
+function buildWorkspaceSkillCommandSpecs(workspaceDir, opts) {
+	const userInvocable = filterSkillEntries(opts?.entries ?? loadSkillEntries(workspaceDir, opts), opts?.config, opts?.skillFilter, opts?.eligibility).filter((entry) => entry.invocation?.userInvocable !== false);
+	const used = /* @__PURE__ */ new Set();
+	for (const reserved of opts?.reservedNames ?? []) used.add(reserved.toLowerCase());
+	const specs = [];
+	for (const entry of userInvocable) {
+		const rawName = entry.skill.name;
+		const base = sanitizeSkillCommandName(rawName);
+		if (base !== rawName) debugSkillCommandOnce(`sanitize:${rawName}:${base}`, `Sanitized skill command name "${rawName}" to "/${base}".`, {
+			rawName,
+			sanitized: `/${base}`
+		});
+		const unique = resolveUniqueSkillCommandName(base, used);
+		if (unique !== base) debugSkillCommandOnce(`dedupe:${rawName}:${unique}`, `De-duplicated skill command name for "${rawName}" to "/${unique}".`, {
+			rawName,
+			deduped: `/${unique}`
+		});
+		used.add(unique.toLowerCase());
+		const rawDescription = entry.skill.description?.trim() || rawName;
+		const description = rawDescription.length > SKILL_COMMAND_DESCRIPTION_MAX_LENGTH ? rawDescription.slice(0, SKILL_COMMAND_DESCRIPTION_MAX_LENGTH - 1) + "…" : rawDescription;
+		const dispatch = (() => {
+			const kindRaw = (entry.frontmatter?.["command-dispatch"] ?? entry.frontmatter?.["command_dispatch"] ?? "").trim().toLowerCase();
+			if (!kindRaw) return;
+			if (kindRaw !== "tool") return;
+			const toolName = (entry.frontmatter?.["command-tool"] ?? entry.frontmatter?.["command_tool"] ?? "").trim();
+			if (!toolName) {
+				debugSkillCommandOnce(`dispatch:missingTool:${rawName}`, `Skill command "/${unique}" requested tool dispatch but did not provide command-tool. Ignoring dispatch.`, {
+					skillName: rawName,
+					command: unique
+				});
+				return;
+			}
+			const argModeRaw = (entry.frontmatter?.["command-arg-mode"] ?? entry.frontmatter?.["command_arg_mode"] ?? "").trim().toLowerCase();
+			if (!(!argModeRaw || argModeRaw === "raw" ? "raw" : null)) debugSkillCommandOnce(`dispatch:badArgMode:${rawName}:${argModeRaw}`, `Skill command "/${unique}" requested tool dispatch but has unknown command-arg-mode. Falling back to raw.`, {
+				skillName: rawName,
+				command: unique,
+				argMode: argModeRaw
+			});
+			return {
+				kind: "tool",
+				toolName,
+				argMode: "raw"
+			};
+		})();
+		specs.push({
+			name: unique,
+			skillName: rawName,
+			description,
+			...dispatch ? { dispatch } : {}
+		});
+	}
+	return specs;
+}
+
+//#endregion
+//#region src/agents/skills/dependency-manager.ts
+const log$1 = createSubsystemLogger("skills/deps");
+function resolveInstallId(spec, index) {
+	return (spec.id ?? `${spec.kind}-${index}`).trim();
+}
+function buildSkillMap(entries) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		map.set(entry.skill.name, entry);
+		const key = resolveSkillKey(entry.skill, entry);
+		if (key !== entry.skill.name) map.set(key, entry);
+	}
+	return map;
+}
+function detectCircularDependencies(entries) {
+	const skillMap = buildSkillMap(entries);
+	const cycles = [];
+	const visited = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	function dfs(name, stack) {
+		if (inStack.has(name)) {
+			const cycleStart = stack.indexOf(name);
+			if (cycleStart !== -1) cycles.push({ cycle: [...stack.slice(cycleStart), name] });
+			return;
+		}
+		if (visited.has(name)) return;
+		visited.add(name);
+		inStack.add(name);
+		stack.push(name);
+		const deps = skillMap.get(name)?.metadata?.dependsOn ?? [];
+		for (const dep of deps) dfs(dep, stack);
+		stack.pop();
+		inStack.delete(name);
+	}
+	for (const entry of entries) dfs(entry.skill.name, []);
+	return cycles;
+}
+function resolveSkillDependencyOrder(entries) {
+	const skillMap = buildSkillMap(entries);
+	const inDegree = /* @__PURE__ */ new Map();
+	const adjacency = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const name = entry.skill.name;
+		if (!inDegree.has(name)) inDegree.set(name, 0);
+		if (!adjacency.has(name)) adjacency.set(name, []);
+	}
+	for (const entry of entries) {
+		const name = entry.skill.name;
+		const deps = entry.metadata?.dependsOn ?? [];
+		for (const dep of deps) {
+			if (!skillMap.has(dep)) continue;
+			const neighbors = adjacency.get(dep) ?? [];
+			neighbors.push(name);
+			adjacency.set(dep, neighbors);
+			inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
+		}
+	}
+	const queue = [];
+	for (const [name, degree] of inDegree.entries()) if (degree === 0) queue.push(name);
+	const order = [];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		order.push(current);
+		for (const neighbor of adjacency.get(current) ?? []) {
+			const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+			inDegree.set(neighbor, newDegree);
+			if (newDegree === 0) queue.push(neighbor);
+		}
+	}
+	const remaining = entries.map((e) => e.skill.name).filter((name) => !order.includes(name));
+	return [...order, ...remaining];
+}
+function checkSkillDependencies(entry, opts = {}) {
+	const { config, availableSkills, remote } = opts;
+	const skillName = entry.skill.name;
+	const skillConfig = resolveSkillConfig(config, resolveSkillKey(entry.skill, entry));
+	const missing = [];
+	const requiredBins = entry.metadata?.requires?.bins ?? [];
+	for (const bin of requiredBins) if (!(hasBinary(bin) || remote?.hasBin(bin) === true)) missing.push({
+		kind: "bin",
+		name: bin
+	});
+	const anyBins = entry.metadata?.requires?.anyBins ?? [];
+	if (anyBins.length > 0) {
+		if (!(anyBins.some((bin) => hasBinary(bin)) || remote?.hasAnyBin(anyBins) === true)) missing.push({
+			kind: "anyBin",
+			names: anyBins
+		});
+	}
+	const requiredEnv = entry.metadata?.requires?.env ?? [];
+	for (const envName of requiredEnv) if (!(Boolean(process.env[envName]) || Boolean(skillConfig?.env?.[envName]) || Boolean(skillConfig?.apiKey) && entry.metadata?.primaryEnv === envName)) missing.push({
+		kind: "env",
+		name: envName
+	});
+	const requiredConfig = entry.metadata?.requires?.config ?? [];
+	for (const configPath of requiredConfig) if (!isConfigPathTruthy(config, configPath)) missing.push({
+		kind: "config",
+		path: configPath
+	});
+	const dependsOn = entry.metadata?.dependsOn ?? [];
+	for (const depSkillName of dependsOn) if (!(availableSkills?.has(depSkillName) ?? false)) missing.push({
+		kind: "skill",
+		name: depSkillName
+	});
+	return {
+		skillName,
+		missing,
+		installable: (entry.metadata?.install ?? []).filter((spec) => {
+			if (spec.os && spec.os.length > 0 && !spec.os.includes(process.platform)) return false;
+			return true;
+		}),
+		satisfied: missing.length === 0
+	};
+}
+function resolveSkillInstallPlan(entries, prefs, opts = {}) {
+	const order = resolveSkillDependencyOrder(entries);
+	const skillByName = buildSkillMap(entries);
+	const plan = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const skillName of order) {
+		const entry = skillByName.get(skillName);
+		if (!entry) continue;
+		const status = checkSkillDependencies(entry, opts);
+		if (status.satisfied) continue;
+		if (!status.missing.some((m) => m.kind === "bin" || m.kind === "anyBin")) continue;
+		const specs = entry.metadata?.install ?? [];
+		for (const [index, spec] of specs.entries()) {
+			if (spec.os && spec.os.length > 0 && !spec.os.includes(process.platform)) continue;
+			if (spec.kind === "brew" && !prefs.preferBrew && hasBinary("brew")) continue;
+			const installId = resolveInstallId(spec, index);
+			const dedupeKey = `${skillName}:${installId}`;
+			if (seen.has(dedupeKey)) continue;
+			seen.add(dedupeKey);
+			const missingBins = spec.bins?.filter((bin) => !hasBinary(bin) && opts.remote?.hasBin(bin) !== true) ?? [];
+			const reason = missingBins.length > 0 ? `missing: ${missingBins.join(", ")}` : `install spec for ${skillName}`;
+			plan.push({
+				skillName,
+				spec,
+				installId,
+				reason
+			});
+		}
+	}
+	return plan;
+}
+async function runSkillDependencyManager(entries, opts) {
+	const { config, prefs, autoInstall = false, remote, onProgress, installSkillDep } = opts;
+	const cycles = detectCircularDependencies(entries);
+	if (cycles.length > 0) for (const cycle of cycles) log$1.warn(`Circular skill dependency detected: ${cycle.cycle.join(" → ")}`);
+	const order = resolveSkillDependencyOrder(entries);
+	const availableSkills = new Set(entries.map((e) => e.skill.name));
+	const skillByName = buildSkillMap(entries);
+	const statuses = order.map((name) => skillByName.get(name)).filter((entry) => Boolean(entry)).map((entry) => checkSkillDependencies(entry, {
+		config,
+		availableSkills,
+		remote
+	}));
+	const plan = resolveSkillInstallPlan(entries, prefs, {
+		config,
+		availableSkills,
+		remote
+	});
+	const report = {
+		order,
+		cycles,
+		statuses,
+		plan,
+		hasIssues: cycles.length > 0 || statuses.some((s) => !s.satisfied && s.installable.length === 0)
+	};
+	const installed = [];
+	if (!autoInstall || !installSkillDep || plan.length === 0) return {
+		report,
+		installed
+	};
+	for (const item of plan) {
+		onProgress?.(`Installing ${item.reason} for skill "${item.skillName}"…`);
+		log$1.info(`Auto-installing dependency for skill "${item.skillName}" (${item.installId}): ${item.reason}`);
+		try {
+			const result = await installSkillDep({
+				skillName: item.skillName,
+				installId: item.installId
+			});
+			installed.push({
+				skillName: item.skillName,
+				installId: item.installId,
+				ok: result.ok,
+				message: result.message
+			});
+			if (result.ok) {
+				log$1.info(`Installed "${item.installId}" for skill "${item.skillName}": ${result.message}`);
+				onProgress?.(`✓ Installed ${item.installId} for "${item.skillName}"`);
+			} else {
+				log$1.warn(`Failed to install "${item.installId}" for skill "${item.skillName}": ${result.message}`);
+				onProgress?.(`✗ Failed to install ${item.installId} for "${item.skillName}": ${result.message}`);
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			log$1.error(`Unexpected error installing "${item.installId}" for skill "${item.skillName}": ${message}`);
+			installed.push({
+				skillName: item.skillName,
+				installId: item.installId,
+				ok: false,
+				message
+			});
+		}
+	}
+	return {
+		report,
+		installed
+	};
+}
+function formatDependencyReport(report) {
+	const lines = [];
+	if (report.cycles.length > 0) {
+		lines.push("Circular dependencies detected:");
+		for (const { cycle } of report.cycles) lines.push(`  ⚠ ${cycle.join(" → ")}`);
+		lines.push("");
+	}
+	const unsatisfied = report.statuses.filter((s) => !s.satisfied);
+	if (unsatisfied.length === 0) {
+		lines.push("All skill dependencies are satisfied.");
+		return lines.join("\n");
+	}
+	lines.push(`${unsatisfied.length} skill(s) have unmet dependencies:`);
+	for (const status of unsatisfied) {
+		lines.push(`  ${status.skillName}:`);
+		for (const dep of status.missing) switch (dep.kind) {
+			case "bin":
+				lines.push(`    • missing binary: ${dep.name}`);
+				break;
+			case "anyBin":
+				lines.push(`    • missing one of: ${dep.names.join(", ")}`);
+				break;
+			case "env":
+				lines.push(`    • missing env var: ${dep.name}`);
+				break;
+			case "config":
+				lines.push(`    • missing config: ${dep.path}`);
+				break;
+			case "skill":
+				lines.push(`    • depends on missing skill: ${dep.name}`);
+				break;
+		}
+		if (status.installable.length > 0) lines.push(`    → installable via: ${status.installable.map((s) => s.kind).join(", ")}`);
+		else lines.push(`    → no install spec available`);
+	}
+	if (report.plan.length > 0) {
+		lines.push("");
+		lines.push(`Install plan (${report.plan.length} item(s)):`);
+		for (const item of report.plan) lines.push(`  [${item.skillName}] ${item.installId} (${item.spec.kind}): ${item.reason}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/agents/skills/conflict-detector.ts
+const log = createSubsystemLogger("skills/conflicts");
+const SKILL_COMMAND_MAX_LENGTH = 32;
+const SKILL_COMMAND_FALLBACK = "skill";
+function sanitizeCommandName(raw) {
+	return raw.toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, SKILL_COMMAND_MAX_LENGTH) || SKILL_COMMAND_FALLBACK;
+}
+function getExclusiveCapabilities(entry) {
+	const provides = entry.metadata?.provides ?? [];
+	const exclusive = entry.metadata?.exclusive;
+	if (!exclusive || provides.length === 0) return /* @__PURE__ */ new Set();
+	if (exclusive === true) return new Set(provides);
+	if (Array.isArray(exclusive)) return new Set(exclusive.filter((cap) => provides.includes(cap)));
+	return /* @__PURE__ */ new Set();
+}
+function getCommandDispatchTool(frontmatter) {
+	if ((frontmatter["command-dispatch"] ?? frontmatter["command_dispatch"] ?? "").trim().toLowerCase() !== "tool") return;
+	return (frontmatter["command-tool"] ?? frontmatter["command_tool"] ?? "").trim() || void 0;
+}
+function detectCapabilityOverlap(entries) {
+	const conflicts = [];
+	const capabilityMap = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const name = entry.skill.name;
+		for (const cap of entry.metadata?.provides ?? []) {
+			const existing = capabilityMap.get(cap) ?? [];
+			existing.push(name);
+			capabilityMap.set(cap, existing);
+		}
+	}
+	for (const [capability, skillNames] of capabilityMap.entries()) {
+		if (skillNames.length < 2) continue;
+		const exclusiveSkills = skillNames.filter((skillName) => {
+			const entry = entries.find((e) => e.skill.name === skillName);
+			return entry ? getExclusiveCapabilities(entry).has(capability) : false;
+		});
+		if (exclusiveSkills.length > 0) conflicts.push({
+			kind: "EXCLUSIVE_CAPABILITY_CONFLICT",
+			severity: "error",
+			skillNames,
+			resource: capability,
+			message: `Skill "${exclusiveSkills[0]}" claims exclusive ownership of capability "${capability}" but ${skillNames.filter((n) => n !== exclusiveSkills[0]).map((n) => `"${n}"`).join(", ")} also provide it. Only one skill may exclusively own a capability.`
+		});
+		else conflicts.push({
+			kind: "CAPABILITY_OVERLAP",
+			severity: "warn",
+			skillNames,
+			resource: capability,
+			message: `Multiple skills provide the "${capability}" capability: ${skillNames.map((n) => `"${n}"`).join(", ")}. The model may use any of them ambiguously. Consider disabling all but one.`
+		});
+	}
+	return conflicts;
+}
+function detectCommandNameCollisions(entries) {
+	const conflicts = [];
+	const commandMap = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (entry.invocation?.userInvocable === false) continue;
+		const sanitized = sanitizeCommandName(entry.skill.name);
+		const existing = commandMap.get(sanitized) ?? [];
+		existing.push(entry.skill.name);
+		commandMap.set(sanitized, existing);
+	}
+	for (const [command, skillNames] of commandMap.entries()) {
+		if (skillNames.length < 2) continue;
+		conflicts.push({
+			kind: "COMMAND_NAME_COLLISION",
+			severity: "warn",
+			skillNames,
+			resource: `/${command}`,
+			message: `Skills ${skillNames.map((n) => `"${n}"`).join(", ")} all map to the same command "/${command}". Atlas will auto-rename duplicates (e.g. "/${command}_2"), which may confuse users. Consider renaming one of these skills.`
+		});
+	}
+	return conflicts;
+}
+function detectToolDispatchCollisions(entries) {
+	const conflicts = [];
+	const toolMap = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const toolName = getCommandDispatchTool(entry.frontmatter);
+		if (!toolName) continue;
+		const existing = toolMap.get(toolName) ?? [];
+		existing.push(entry.skill.name);
+		toolMap.set(toolName, existing);
+	}
+	for (const [toolName, skillNames] of toolMap.entries()) {
+		if (skillNames.length < 2) continue;
+		conflicts.push({
+			kind: "TOOL_DISPATCH_COLLISION",
+			severity: "error",
+			skillNames,
+			resource: toolName,
+			message: `Skills ${skillNames.map((n) => `"${n}"`).join(", ")} all dispatch commands to the same tool "${toolName}". Only one skill may own a tool dispatch target. The last one registered will silently shadow the others.`
+		});
+	}
+	return conflicts;
+}
+function detectEnvCollisions(entries) {
+	const conflicts = [];
+	const byPrimaryEnv = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const env = entry.metadata?.primaryEnv;
+		if (!env) continue;
+		const existing = byPrimaryEnv.get(env) ?? [];
+		existing.push(entry);
+		byPrimaryEnv.set(env, existing);
+	}
+	for (const [envVar, envEntries] of byPrimaryEnv.entries()) {
+		if (envEntries.length < 2) continue;
+		const capSets = envEntries.map((e) => new Set(e.metadata?.provides ?? []));
+		const overlapPairs = [];
+		for (let i = 0; i < envEntries.length; i++) for (let j = i + 1; j < envEntries.length; j++) {
+			const shared = [...capSets[i]].filter((cap) => capSets[j].has(cap));
+			if (shared.length > 0) overlapPairs.push([
+				envEntries[i].skill.name,
+				envEntries[j].skill.name,
+				shared
+			]);
+		}
+		if (overlapPairs.length > 0) for (const [nameA, nameB, sharedCaps] of overlapPairs) conflicts.push({
+			kind: "ENV_COLLISION",
+			severity: "warn",
+			skillNames: [nameA, nameB],
+			resource: envVar,
+			message: `Skills "${nameA}" and "${nameB}" both use "${envVar}" and provide the same capabilities: ${sharedCaps.map((c) => `"${c}"`).join(", ")}. They are competing providers of the same functionality via the same API key.`
+		});
+		else conflicts.push({
+			kind: "ENV_COLLISION",
+			severity: "warn",
+			skillNames: envEntries.map((e) => e.skill.name),
+			resource: envVar,
+			message: `Multiple skills share the primary env var "${envVar}": ${envEntries.map((e) => `"${e.skill.name}"`).join(", ")}. Rotating or revoking this key will affect all of them simultaneously.`
+		});
+	}
+	return conflicts;
+}
+function detectOsChainMismatches(entries) {
+	const conflicts = [];
+	const entryMap = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		entryMap.set(entry.skill.name, entry);
+		const key = resolveSkillKey(entry.skill, entry);
+		if (key !== entry.skill.name) entryMap.set(key, entry);
+	}
+	for (const entry of entries) {
+		const parentOs = entry.metadata?.os ?? [];
+		if (parentOs.length === 0) continue;
+		const deps = entry.metadata?.dependsOn ?? [];
+		for (const depName of deps) {
+			const dep = entryMap.get(depName);
+			if (!dep) continue;
+			const depOs = dep.metadata?.os ?? [];
+			if (depOs.length === 0) continue;
+			if (!parentOs.some((os) => depOs.includes(os))) conflicts.push({
+				kind: "OS_CHAIN_MISMATCH",
+				severity: "error",
+				skillNames: [entry.skill.name, depName],
+				resource: `os:${parentOs.join(",")}↔${depOs.join(",")}`,
+				message: `Skill "${entry.skill.name}" runs on [${parentOs.join(", ")}] but depends on "${depName}" which only runs on [${depOs.join(", ")}]. This dependency can never be satisfied and "${entry.skill.name}" will always fail to load.`
+			});
+		}
+	}
+	return conflicts;
+}
+function detectSkillConflicts(entries) {
+	const allConflicts = [
+		...detectCapabilityOverlap(entries),
+		...detectCommandNameCollisions(entries),
+		...detectToolDispatchCollisions(entries),
+		...detectEnvCollisions(entries),
+		...detectOsChainMismatches(entries)
+	];
+	for (const conflict of allConflicts) if (conflict.severity === "error") log.error(`[${conflict.kind}] ${conflict.message}`, {
+		skills: conflict.skillNames,
+		resource: conflict.resource
+	});
+	else log.warn(`[${conflict.kind}] ${conflict.message}`, {
+		skills: conflict.skillNames,
+		resource: conflict.resource
+	});
+	return {
+		conflicts: allConflicts,
+		hasErrors: allConflicts.some((c) => c.severity === "error"),
+		hasWarnings: allConflicts.some((c) => c.severity === "warn")
+	};
+}
+function formatConflictReport(report) {
+	if (report.conflicts.length === 0) return "No skill conflicts detected.";
+	const lines = [];
+	const errors = report.conflicts.filter((c) => c.severity === "error");
+	const warnings = report.conflicts.filter((c) => c.severity === "warn");
+	if (errors.length > 0) {
+		lines.push(`${errors.length} conflict error(s) found:`);
+		for (const conflict of errors) lines.push(`  ✗ [${conflict.kind}] ${conflict.message}`);
+	}
+	if (warnings.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push(`${warnings.length} conflict warning(s):`);
+		for (const conflict of warnings) lines.push(`  ⚠ [${conflict.kind}] ${conflict.message}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/agents/skills.ts
+function resolveSkillsInstallPreferences(config) {
+	const raw = config?.skills?.install;
+	const preferBrew = raw?.preferBrew ?? true;
+	const manager = (typeof raw?.nodeManager === "string" ? raw.nodeManager.trim() : "").toLowerCase();
+	return {
+		preferBrew,
+		nodeManager: manager === "pnpm" || manager === "yarn" || manager === "bun" || manager === "npm" ? manager : "npm"
+	};
+}
+
+//#endregion
+export { parseFrontmatterBlock as S, isConfigPathTruthy as _, runSkillDependencyManager as a, resolveSkillConfig as b, loadWorkspaceSkillEntries as c, resolvePluginSkillDirs as d, resolveBundledSkillsDir as f, isBundledSkillAllowed as g, hasBinary as h, formatDependencyReport as i, resolveSkillsPromptForRun as l, applySkillEnvOverridesFromSnapshot as m, detectSkillConflicts as n, buildWorkspaceSkillCommandSpecs as o, applySkillEnvOverrides as p, formatConflictReport as r, buildWorkspaceSkillSnapshot as s, resolveSkillsInstallPreferences as t, syncSkillsToWorkspace as u, resolveBundledAllowlist as v, resolveSkillKey as x, resolveConfigPath as y };