@agimon-ai/po-domain 0.0.0-alpha.0

package/dist/resourceCollector-Cu-lp5hJ.cjs

@@ -0,0 +1,837 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_mcpFilter = require("./mcpFilter-CZNmU_VF.cjs");
+const require_toolNames = require("./toolNames-Cuu-u8r1.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let yaml = require("yaml");
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+let _agimon_ai_po_config_agentPluginMcp = require("@agimon-ai/po-config/agentPluginMcp");
+let _agimon_ai_po_config_config = require("@agimon-ai/po-config/config");
+let _agimon_ai_po_core_mcpProjection = require("@agimon-ai/po-core/mcpProjection");
+//#region src/services/skillCacheLocation/index.ts
+const SYNC_DIRECTORY = "sync";
+const WORKTREES_DIRECTORY = "worktrees";
+const SKILL_CACHE_SEGMENTS = ["cache", "skills"];
+const GIT_DIRECTORY = ".git";
+const COMMON_DIRECTORY_FILE = "commondir";
+const IDENTITY_HEX_LENGTH = 32;
+const LABEL_MAX_LENGTH = 48;
+const DEFAULT_REPOSITORY_LABEL = "repo";
+const DEFAULT_WORKTREE_LABEL = "worktree";
+/**
+* The home-scoped skill manifest cache for one worktree.
+*
+* This mirrors the namespace the Po launcher publishes into, so a session
+* that stages resources through the launcher and one that stages them through a
+* `/domains` switch hit the same manifests instead of rescanning every tree.
+* Two worktrees of one repository stay separate, and a checkout reached through
+* a symlink resolves to the same identity as the real path.
+*/
+function resolveSkillCacheDirectory(repositoryRoot, homeDirectory = node_os.default.homedir()) {
+	const root = canonicalPath(repositoryRoot);
+	const commonDirectory = gitCommonDirectory(root);
+	const repositoryToken = commonDirectory ? `git:${commonDirectory}` : `root:${root}`;
+	const repositoryId = identityHash(repositoryToken);
+	const worktreeId = identityHash(`${repositoryToken}\0worktree:${root}`);
+	const repoLabel = repositoryLabel(commonDirectory, root);
+	const worktreeLabel = sanitizeSyncLabel(node_path.default.basename(root), DEFAULT_WORKTREE_LABEL);
+	return node_path.default.join((0, _agimon_ai_po_core_piSettings.poHomeDirectory)(node_path.default.resolve(homeDirectory)), SYNC_DIRECTORY, `${repoLabel}--${repositoryId}`, WORKTREES_DIRECTORY, `${worktreeLabel}--${worktreeId}`, ...SKILL_CACHE_SEGMENTS);
+}
+function canonicalPath(target) {
+	const absolute = node_path.default.resolve(target);
+	try {
+		return node_fs.default.realpathSync.native(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function readGitDirectory(repositoryRoot) {
+	const gitPath = node_path.default.join(repositoryRoot, GIT_DIRECTORY);
+	try {
+		const stat = node_fs.default.statSync(gitPath);
+		if (stat.isDirectory()) return canonicalPath(gitPath);
+		if (!stat.isFile()) return void 0;
+		const match = /^gitdir:\s*(.+)$/imu.exec(node_fs.default.readFileSync(gitPath, "utf8").trim());
+		return match?.[1] ? canonicalPath(node_path.default.resolve(repositoryRoot, match[1].trim())) : void 0;
+	} catch {
+		return;
+	}
+}
+function gitCommonDirectory(repositoryRoot) {
+	const gitDirectory = readGitDirectory(repositoryRoot);
+	if (!gitDirectory) return void 0;
+	try {
+		const relative = node_fs.default.readFileSync(node_path.default.join(gitDirectory, COMMON_DIRECTORY_FILE), "utf8").trim();
+		return relative ? canonicalPath(node_path.default.resolve(gitDirectory, relative)) : gitDirectory;
+	} catch {
+		return gitDirectory;
+	}
+}
+function identityHash(value) {
+	return node_crypto.default.createHash("sha256").update(value, "utf8").digest("hex").slice(0, IDENTITY_HEX_LENGTH);
+}
+/** Keeps a repository or worktree name usable as one path segment. */
+function sanitizeSyncLabel(value, fallback) {
+	const normalized = value.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/^[._-]+|[._-]+$/gu, "").slice(0, LABEL_MAX_LENGTH).replace(/[._-]+$/gu, "");
+	return normalized === "" || normalized === "." || normalized === ".." ? fallback : normalized;
+}
+function repositoryLabel(commonDirectory, repositoryRoot) {
+	if (!commonDirectory) return sanitizeSyncLabel(node_path.default.basename(repositoryRoot), DEFAULT_REPOSITORY_LABEL);
+	const base = node_path.default.basename(commonDirectory);
+	return sanitizeSyncLabel(base === GIT_DIRECTORY ? node_path.default.basename(node_path.default.dirname(commonDirectory)) : base, DEFAULT_REPOSITORY_LABEL);
+}
+//#endregion
+//#region src/services/resourceCollector/index.ts
+const DISPATCHER_AGENT_NAME = "agiflow-dispatcher";
+const DISPATCHER_TOOLS = [
+	"read",
+	"grep",
+	"find",
+	"ls",
+	"bash",
+	"launch_workflow",
+	"list_workflows"
+];
+const SKILL_MANIFEST_VERSION = 4;
+const SKILL_MANIFEST_HASH_LENGTH = 16;
+const AGENT_PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+const PLUGIN_DATA_DIRECTORY = "plugin-data";
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalJson(value) {
+	const normalize = (candidate) => {
+		if (Array.isArray(candidate)) return candidate.map(normalize);
+		if (!isJsonObject(candidate)) return candidate;
+		return Object.fromEntries(Object.entries(candidate).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, normalize(child)]));
+	};
+	return JSON.stringify(normalize(value));
+}
+function projectionFingerprint(input) {
+	return (0, node_crypto.createHash)("sha256").update(canonicalJson(input)).digest("hex");
+}
+function stablePluginIdentity(entry) {
+	const source = entry.source;
+	const identity = source?.type === "git" ? [
+		"git",
+		source.url,
+		source.path ?? ""
+	] : source?.type === "npm" ? [
+		"npm",
+		source.registry ?? "",
+		source.package
+	] : ["local", node_fs.default.realpathSync(entry.directory)];
+	return (0, node_crypto.createHash)("sha256").update(JSON.stringify(identity)).digest("hex");
+}
+function rootAgentPluginSchema(entry) {
+	const manifestPath = node_path.default.join(entry.directory, "plugin.json");
+	if (entry.manifest?.path === manifestPath && entry.manifest.agentPluginSchema === AGENT_PLUGIN_SCHEMA) return AGENT_PLUGIN_SCHEMA;
+	try {
+		const stat = node_fs.default.lstatSync(manifestPath);
+		if (stat.isSymbolicLink() || !stat.isFile()) return void 0;
+		const parsed = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+		return isJsonObject(parsed) && parsed.$schema === AGENT_PLUGIN_SCHEMA ? AGENT_PLUGIN_SCHEMA : void 0;
+	} catch {
+		return;
+	}
+}
+async function pluginMcpSource(entry, pluginDataRoot) {
+	if (entry.mcp === false) return void 0;
+	const pluginRoot = node_fs.default.realpathSync(entry.directory);
+	const agentPlugin = rootAgentPluginSchema(entry) === AGENT_PLUGIN_SCHEMA;
+	const configPath = node_path.default.join(pluginRoot, agentPlugin ? "mcp.json" : ".mcp.json");
+	let stat;
+	try {
+		stat = await node_fs.default.promises.lstat(configPath);
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	if (!stat.isFile() || stat.isSymbolicLink()) return void 0;
+	const content = await node_fs.default.promises.readFile(configPath);
+	const contentDigest = (0, node_crypto.createHash)("sha256").update(content).digest("hex");
+	const pluginId = stablePluginIdentity(entry);
+	const sourceId = `plugin:${pluginId}`;
+	if (!agentPlugin) return {
+		sourceId,
+		owner: "plugin",
+		format: "native",
+		configPath,
+		contentDigest
+	};
+	return {
+		sourceId,
+		owner: "plugin",
+		format: "agent-plugin-v1",
+		configPath,
+		contentDigest,
+		pluginId,
+		pluginRoot,
+		pluginDataDirectory: node_path.default.join(pluginDataRoot, pluginId),
+		mcpSchemaUrl: _agimon_ai_po_core_mcpProjection.AGENT_PLUGIN_MCP_SCHEMA_URL
+	};
+}
+function splitFrontmatter(content) {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!match) throw new Error("Resource is missing YAML frontmatter");
+	return {
+		attributes: (0, yaml.parse)(match[1]),
+		body: match[2] ?? ""
+	};
+}
+const CLAUDE_MODEL_ALIASES = {
+	sonnet: "anthropic/claude-sonnet-4-6",
+	opus: "anthropic/claude-opus-4-6",
+	haiku: "anthropic/claude-haiku-4-5"
+};
+function assertSafeAgentName(name) {
+	const trimmed = name.trim();
+	if (!trimmed || trimmed !== name || trimmed === "." || trimmed === ".." || trimmed.includes("\0") || /[\\/]/.test(trimmed)) throw new Error(`Unsafe agent name: ${JSON.stringify(name)}`);
+	return trimmed;
+}
+function normalizeClaudeModel(value) {
+	if (typeof value === "string") return CLAUDE_MODEL_ALIASES[value.toLowerCase()] ?? value;
+	if (Array.isArray(value)) return value.map((entry) => normalizeClaudeModel(entry));
+	return value;
+}
+/** Rewrites a Claude-authored agent definition into the form Pi loads. */
+function adaptAgentDefinition(content) {
+	const { attributes, body } = splitFrontmatter(content);
+	const rawName = typeof attributes.name === "string" ? attributes.name : void 0;
+	if (!rawName) throw new Error("Agent definition requires a name");
+	const name = assertSafeAgentName(rawName);
+	const hasTools = Object.hasOwn(attributes, "tools");
+	const rawTools = Array.isArray(attributes.tools) ? attributes.tools.map(String) : typeof attributes.tools === "string" ? attributes.tools.split(",").map((tool) => tool.trim()).filter(Boolean) : [];
+	const mappedTools = [...new Set(rawTools.map(require_toolNames.toPiToolName).filter((tool) => Boolean(tool)))];
+	const converted = {
+		...attributes,
+		inheritProjectContext: true,
+		inheritSkills: true,
+		systemPromptMode: attributes.systemPromptMode ?? "replace"
+	};
+	if (hasTools) converted.tools = Array.isArray(attributes.tools) ? mappedTools : mappedTools.join(", ");
+	else delete converted.tools;
+	if (converted.model !== void 0) converted.model = normalizeClaudeModel(converted.model);
+	if (converted.fallbackModels !== void 0) converted.fallbackModels = normalizeClaudeModel(converted.fallbackModels);
+	if (converted.memory === "project" || converted.memory === "user") converted.memory = {
+		scope: converted.memory,
+		path: name
+	};
+	else if (converted.memory !== void 0 && (typeof converted.memory !== "object" || converted.memory === null || Array.isArray(converted.memory))) throw new Error("Unsupported memory declaration");
+	delete converted.permissionMode;
+	return {
+		name,
+		content: `---\n${(0, yaml.stringify)(converted).trim()}\n---\n\n${body.trimStart()}`
+	};
+}
+function skillManifestPath(repoRoot, skillRoot, discovery, cacheDirectory) {
+	const key = (0, node_crypto.createHash)("sha256").update(`${node_path.default.resolve(skillRoot)}\0${discovery}`).digest("hex").slice(0, SKILL_MANIFEST_HASH_LENGTH);
+	return node_path.default.join(cacheDirectory ?? resolveSkillCacheDirectory(repoRoot), `${key}.json`);
+}
+function fileMatches(previous) {
+	try {
+		const stat = node_fs.default.statSync(previous.path);
+		return stat.isFile() && stat.size === previous.size && stat.mtimeMs === previous.mtimeMs && stat.ctimeMs === previous.ctimeMs;
+	} catch {
+		return false;
+	}
+}
+function directoryMatches(previous) {
+	try {
+		const stat = node_fs.default.statSync(previous.path);
+		return stat.isDirectory() && stat.mtimeMs === previous.mtimeMs && stat.ctimeMs === previous.ctimeMs;
+	} catch {
+		return false;
+	}
+}
+function readSkillManifest(manifestPath, root, discovery) {
+	try {
+		const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+		if (manifest.version !== SKILL_MANIFEST_VERSION || manifest.root !== node_path.default.resolve(root) || manifest.discovery !== discovery || !Array.isArray(manifest.files) || !Array.isArray(manifest.directories) || !manifest.files.every(fileMatches) || !manifest.directories.every(directoryMatches)) return;
+		return manifest;
+	} catch {
+		return;
+	}
+}
+function writeSkillManifest(manifestPath, manifest) {
+	node_fs.default.mkdirSync(node_path.default.dirname(manifestPath), {
+		recursive: true,
+		mode: 448
+	});
+	const temporary = `${manifestPath}.${process.pid}.${Date.now()}.tmp`;
+	node_fs.default.writeFileSync(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 384 });
+	try {
+		node_fs.default.renameSync(temporary, manifestPath);
+	} catch (error) {
+		node_fs.default.rmSync(temporary, { force: true });
+		if (!node_fs.default.existsSync(manifestPath)) throw error;
+	}
+}
+async function pathExists(target) {
+	try {
+		await node_fs.default.promises.access(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readSkillManifestAsync(manifestPath, root, discovery) {
+	try {
+		const manifest = JSON.parse(await node_fs.default.promises.readFile(manifestPath, "utf8"));
+		if (manifest.version !== SKILL_MANIFEST_VERSION || manifest.root !== node_path.default.resolve(root) || manifest.discovery !== discovery || !Array.isArray(manifest.files) || !Array.isArray(manifest.directories)) return;
+		for (const previous of manifest.files) {
+			const stat = await node_fs.default.promises.stat(previous.path);
+			if (!stat.isFile() || stat.size !== previous.size || stat.mtimeMs !== previous.mtimeMs || stat.ctimeMs !== previous.ctimeMs) return;
+		}
+		for (const previous of manifest.directories) {
+			const stat = await node_fs.default.promises.stat(previous.path);
+			if (!stat.isDirectory() || stat.mtimeMs !== previous.mtimeMs || stat.ctimeMs !== previous.ctimeMs) return;
+		}
+		return manifest;
+	} catch {
+		return;
+	}
+}
+async function writeSkillManifestAsync(manifestPath, manifest) {
+	await node_fs.default.promises.mkdir(node_path.default.dirname(manifestPath), {
+		recursive: true,
+		mode: 448
+	});
+	const temporary = `${manifestPath}.${process.pid}.${Date.now()}.tmp`;
+	await node_fs.default.promises.writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 384 });
+	try {
+		await node_fs.default.promises.rename(temporary, manifestPath);
+	} catch (error) {
+		await node_fs.default.promises.rm(temporary, { force: true });
+		if (!await pathExists(manifestPath)) throw error;
+	}
+}
+/**
+* A directory entry resolved through any symlink, or undefined for a broken one.
+*
+* `readdir` reports symlinks with lstat semantics, so a symlinked skill
+* directory answers false to both `isDirectory()` and `isFile()` and would be
+* skipped by a naive branch. Pi stats through the link instead
+* (dist/core/skills.js:171-183) and treats a failing stat as a broken link to
+* skip, which is what keeps a shared skill published as a symlink visible.
+*/
+function resolveEntryKind(entry, candidate) {
+	if (!entry.isSymbolicLink()) return {
+		directory: entry.isDirectory(),
+		file: entry.isFile()
+	};
+	try {
+		const stat = node_fs.default.statSync(candidate);
+		return {
+			directory: stat.isDirectory(),
+			file: stat.isFile()
+		};
+	} catch {
+		return;
+	}
+}
+async function resolveEntryKindAsync(entry, candidate) {
+	if (!entry.isSymbolicLink()) return {
+		directory: entry.isDirectory(),
+		file: entry.isFile()
+	};
+	try {
+		const stat = await node_fs.default.promises.stat(candidate);
+		return {
+			directory: stat.isDirectory(),
+			file: stat.isFile()
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* The skill's declared name, or the name of the directory holding it.
+*
+* Pi falls back to the containing directory rather than rejecting the file
+* (dist/core/skills.js:245). Rejecting is worse than one missing skill here:
+* this walk feeds the whole resource collection, so a single unnamed SKILL.md
+* from a third-party plugin would fail session launch outright rather than
+* degrade.
+*/
+function skillName(filePath, attributes) {
+	const declared = typeof attributes.name === "string" ? attributes.name.trim() : "";
+	if (declared) return declared;
+	const fallback = node_path.default.basename(node_path.default.dirname(filePath));
+	if (!fallback) throw new Error(`Resource requires a name: ${filePath}`);
+	return fallback;
+}
+function scanSkillManifest(root, discovery) {
+	const directories = [];
+	const files = [];
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (directory, depth) => {
+		if (!node_fs.default.existsSync(directory)) return;
+		const realDirectory = node_fs.default.realpathSync(directory);
+		if (visited.has(realDirectory)) return;
+		visited.add(realDirectory);
+		const directoryStat = node_fs.default.statSync(directory);
+		directories.push({
+			path: directory,
+			mtimeMs: directoryStat.mtimeMs,
+			ctimeMs: directoryStat.ctimeMs
+		});
+		for (const entry of node_fs.default.readdirSync(directory, { withFileTypes: true })) {
+			const candidate = node_path.default.join(directory, entry.name);
+			const kind = resolveEntryKind(entry, candidate);
+			if (!kind) continue;
+			if (kind.directory) {
+				if (discovery === "recursive" || depth === 0) walk(candidate, depth + 1);
+				continue;
+			}
+			if (!kind.file || entry.name !== "SKILL.md" || discovery === "direct-children" && depth !== 1) continue;
+			const content = node_fs.default.readFileSync(candidate, "utf8");
+			const { attributes } = splitFrontmatter(content);
+			const stat = node_fs.default.statSync(candidate);
+			files.push({
+				path: candidate,
+				name: skillName(candidate, attributes),
+				...typeof attributes.description === "string" ? { description: attributes.description.trim() } : {},
+				digest: (0, node_crypto.createHash)("sha256").update(content).digest("hex"),
+				size: stat.size,
+				mtimeMs: stat.mtimeMs,
+				ctimeMs: stat.ctimeMs
+			});
+		}
+	};
+	const resolvedRoot = node_path.default.resolve(root);
+	walk(resolvedRoot, 0);
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	directories.sort((left, right) => left.path.localeCompare(right.path));
+	return {
+		version: SKILL_MANIFEST_VERSION,
+		root: resolvedRoot,
+		discovery,
+		files,
+		directories
+	};
+}
+/** Cached skill metadata and exact files, ready for Pi without a second tree walk. */
+function discoverSkills(repoRoot, root, discovery = "recursive", cacheDirectory) {
+	if (!node_fs.default.existsSync(root)) return [];
+	const manifestPath = skillManifestPath(repoRoot, root, discovery, cacheDirectory);
+	const cached = readSkillManifest(manifestPath, root, discovery);
+	const manifest = cached ?? scanSkillManifest(root, discovery);
+	if (!cached) writeSkillManifest(manifestPath, manifest);
+	return manifest.files.map(({ name, path: filePath, description, digest }) => ({
+		name,
+		path: filePath,
+		digest,
+		...description === void 0 ? {} : { description }
+	}));
+}
+async function scanSkillManifestAsync(root, discovery) {
+	const directories = [];
+	const files = [];
+	const visited = /* @__PURE__ */ new Set();
+	const walk = async (directory, depth) => {
+		let entries;
+		try {
+			const realDirectory = await node_fs.default.promises.realpath(directory);
+			if (visited.has(realDirectory)) return;
+			visited.add(realDirectory);
+			const directoryStat = await node_fs.default.promises.stat(directory);
+			directories.push({
+				path: directory,
+				mtimeMs: directoryStat.mtimeMs,
+				ctimeMs: directoryStat.ctimeMs
+			});
+			entries = await node_fs.default.promises.readdir(directory, { withFileTypes: true });
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+		for (const entry of entries) {
+			const candidate = node_path.default.join(directory, entry.name);
+			const kind = await resolveEntryKindAsync(entry, candidate);
+			if (!kind) continue;
+			if (kind.directory) {
+				if (discovery === "recursive" || depth === 0) await walk(candidate, depth + 1);
+				continue;
+			}
+			if (!kind.file || entry.name !== "SKILL.md" || discovery === "direct-children" && depth !== 1) continue;
+			const content = await node_fs.default.promises.readFile(candidate, "utf8");
+			const { attributes } = splitFrontmatter(content);
+			const stat = await node_fs.default.promises.stat(candidate);
+			files.push({
+				path: candidate,
+				name: skillName(candidate, attributes),
+				...typeof attributes.description === "string" ? { description: attributes.description.trim() } : {},
+				digest: (0, node_crypto.createHash)("sha256").update(content).digest("hex"),
+				size: stat.size,
+				mtimeMs: stat.mtimeMs,
+				ctimeMs: stat.ctimeMs
+			});
+		}
+	};
+	const resolvedRoot = node_path.default.resolve(root);
+	await walk(resolvedRoot, 0);
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	directories.sort((left, right) => left.path.localeCompare(right.path));
+	return {
+		version: SKILL_MANIFEST_VERSION,
+		root: resolvedRoot,
+		discovery,
+		files,
+		directories
+	};
+}
+async function discoverSkillsAsync(repoRoot, root, discovery = "recursive", cacheDirectory) {
+	if (!await pathExists(root)) return [];
+	const manifestPath = skillManifestPath(repoRoot, root, discovery, cacheDirectory);
+	const cached = await readSkillManifestAsync(manifestPath, root, discovery);
+	const manifest = cached ?? await scanSkillManifestAsync(root, discovery);
+	if (!cached) await writeSkillManifestAsync(manifestPath, manifest);
+	return manifest.files.map(({ name, path: filePath, description, digest }) => ({
+		name,
+		path: filePath,
+		digest,
+		...description === void 0 ? {} : { description }
+	}));
+}
+async function markdownFilesAsync(directory) {
+	let entries;
+	try {
+		entries = await node_fs.default.promises.readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const results = [];
+	for (const entry of entries) {
+		const candidate = node_path.default.join(directory, entry.name);
+		if (entry.isDirectory()) results.push(...await markdownFilesAsync(candidate));
+		if (entry.isFile() && entry.name.endsWith(".md")) results.push(candidate);
+	}
+	return results;
+}
+async function frontmatterNameAsync(filePath) {
+	const { attributes } = splitFrontmatter(await node_fs.default.promises.readFile(filePath, "utf8"));
+	if (typeof attributes.name !== "string") throw new Error(`Resource requires a name: ${filePath}`);
+	return attributes.name;
+}
+async function assertUniqueAsync(resources, kind) {
+	const seen = /* @__PURE__ */ new Map();
+	const digestByName = /* @__PURE__ */ new Map();
+	for (const resource of resources) {
+		const previous = seen.get(resource.name);
+		const digest = resource.digest ?? (0, node_crypto.createHash)("sha256").update(await node_fs.default.promises.readFile(resource.path)).digest("hex");
+		if (previous && digestByName.get(resource.name) !== digest) throw new Error(`Conflicting ${kind} "${resource.name}": ${previous} and ${resource.path}`);
+		seen.set(resource.name, resource.path);
+		digestByName.set(resource.name, digest);
+	}
+}
+function dispatcherAgentSource() {
+	const attributes = {
+		name: DISPATCHER_AGENT_NAME,
+		description: "Selects and launches Agiflow workflows for one loop pass without implementing the work.",
+		thinking: "high",
+		systemPromptMode: "replace",
+		inheritProjectContext: true,
+		inheritSkills: true,
+		tools: DISPATCHER_TOOLS.join(", "),
+		defaultContext: "fresh",
+		defaultProgress: false
+	};
+	const body = [
+		"You are the Agiflow workflow dispatcher.",
+		"Reason about the supplied dispatch context and launch eligible workflows.",
+		"Launch workflows without monitoring them. After dispatching, report and exit.",
+		"Follow the task restrictions exactly. Do not implement jobs or edit repository files."
+	].join("\n");
+	return `---\n${(0, yaml.stringify)(attributes).trim()}\n---\n\n${body}\n`;
+}
+function mergeMcpConfigs(configPaths) {
+	const merged = { mcpServers: {} };
+	const servers = merged.mcpServers;
+	const sources = /* @__PURE__ */ new Map();
+	for (const configPath of configPaths) {
+		if (!node_fs.default.existsSync(configPath)) continue;
+		const incoming = JSON.parse(node_fs.default.readFileSync(configPath, "utf8")).mcpServers ?? {};
+		for (const [name, definition] of Object.entries(incoming)) {
+			const previous = servers[name];
+			if (previous && JSON.stringify(previous) !== JSON.stringify(definition)) throw new Error(`Conflicting MCP server "${name}": ${sources.get(name)} and ${configPath}`);
+			servers[name] = definition;
+			sources.set(name, configPath);
+		}
+	}
+	return merged;
+}
+async function mergeMcpConfigsAsync(configPaths) {
+	const merged = { mcpServers: {} };
+	const servers = merged.mcpServers;
+	const sources = /* @__PURE__ */ new Map();
+	for (const configPath of configPaths) {
+		let content;
+		try {
+			content = await node_fs.default.promises.readFile(configPath, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		const incoming = JSON.parse(content).mcpServers ?? {};
+		for (const [name, definition] of Object.entries(incoming)) {
+			const previous = servers[name];
+			if (previous && JSON.stringify(previous) !== JSON.stringify(definition)) throw new Error(`Conflicting MCP server "${name}": ${sources.get(name)} and ${configPath}`);
+			servers[name] = definition;
+			sources.set(name, configPath);
+		}
+	}
+	return merged;
+}
+async function mergeProjectedMcpConfigs(sources, stagingDirectory) {
+	const merged = { mcpServers: {} };
+	const servers = merged.mcpServers;
+	const origins = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		let config;
+		if (source.format === "agent-plugin-v1") config = (0, _agimon_ai_po_config_agentPluginMcp.normalizeAgentPluginMcpSource)(source, {
+			stagingDirectory,
+			stripProxyWrappers: false
+		}).claudeConfig;
+		else {
+			let content;
+			try {
+				content = await node_fs.default.promises.readFile(source.configPath, "utf8");
+			} catch (error) {
+				if (error.code === "ENOENT") continue;
+				throw error;
+			}
+			config = JSON.parse(content);
+		}
+		const incoming = config.mcpServers ?? {};
+		for (const [name, definition] of Object.entries(incoming)) {
+			const previous = servers[name];
+			if (previous && JSON.stringify(previous) !== JSON.stringify(definition)) throw new Error(`Conflicting MCP server "${name}": ${origins.get(name)} and ${source.configPath}`);
+			servers[name] = definition;
+			origins.set(name, source.configPath);
+		}
+	}
+	return merged;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Matches a resource name against a subset filter. Undefined keeps everything. */
+function keepsName(allowed, name) {
+	if (!allowed) return true;
+	return allowed.some((pattern) => pattern.includes("*") ? new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`).test(name) : pattern === name);
+}
+/** Stages only the MCP slice shared by Po and compatibility frontends. */
+async function stageMcpResources(repoRoot, plugins, options) {
+	const pluginEntries = plugins.map((plugin) => typeof plugin === "string" ? { directory: plugin } : plugin);
+	const pluginMcpConfigPaths = [];
+	const pluginMcpSources = [];
+	const mcpSources = [];
+	const pluginDataRoot = options.pluginDataRoot ?? node_path.default.join((0, _agimon_ai_po_config_config.globalDoomConfigDirectory)(), PLUGIN_DATA_DIRECTORY);
+	const repositoryMcpPath = node_path.default.join(repoRoot, ".mcp.json");
+	await node_fs.default.promises.mkdir(options.temporaryDirectory, {
+		mode: 448,
+		recursive: true
+	});
+	await node_fs.default.promises.chmod(options.temporaryDirectory, 448);
+	if (options.enabled && await pathExists(repositoryMcpPath)) {
+		const content = await node_fs.default.promises.readFile(repositoryMcpPath);
+		mcpSources.push({
+			sourceId: "repository:.mcp.json",
+			owner: "repository",
+			format: "native",
+			configPath: repositoryMcpPath,
+			contentDigest: (0, node_crypto.createHash)("sha256").update(content).digest("hex")
+		});
+	}
+	if (options.enabled) for (const entry of pluginEntries) {
+		const source = await pluginMcpSource(entry, pluginDataRoot);
+		if (!source) continue;
+		mcpSources.push(source);
+		pluginMcpSources.push(source);
+		pluginMcpConfigPaths.push(source.configPath);
+	}
+	let mcpConfigPath;
+	if (options.enabled) {
+		mcpConfigPath = node_path.default.join(options.temporaryDirectory, "mcp.json");
+		const merged = await require_mcpFilter.applyMcpAllowlist(await mergeProjectedMcpConfigs(mcpSources, options.temporaryDirectory), options.mcpAllowlist, repoRoot, options.temporaryDirectory);
+		await node_fs.default.promises.writeFile(mcpConfigPath, `${JSON.stringify(merged, null, 2)}\n`, { mode: 384 });
+	}
+	const projectionWithoutRuntimePath = {
+		version: _agimon_ai_po_core_mcpProjection.DOOM_MCP_PROJECTION_VERSION,
+		enabled: options.enabled,
+		repoRoot,
+		...mcpConfigPath ? { generatedConfigPath: mcpConfigPath } : {},
+		sources: options.enabled ? mcpSources : [],
+		...options.mcpAllowlist ? { allowlist: structuredClone(options.mcpAllowlist) } : {}
+	};
+	return {
+		mcpConfigPath,
+		mcpProjection: {
+			...projectionWithoutRuntimePath,
+			stagingDirectory: options.temporaryDirectory,
+			fingerprint: projectionFingerprint(projectionWithoutRuntimePath)
+		},
+		pluginMcpSources,
+		pluginMcpConfigPaths
+	};
+}
+/**
+* Stages every resource the selected domains contribute, ready for one Pi session.
+*
+* The caller owns the returned cleanup(): the temporary directory holding agents
+* and the generated MCP config has to outlive this function and be removed once
+* the session that reads it is done.
+*/
+async function collectResources(repoRoot, plugins, options) {
+	const pluginEntries = plugins.map((plugin) => typeof plugin === "string" ? { directory: plugin } : plugin);
+	const ownsDirectory = options.temporaryDirectory === void 0;
+	const temporaryDirectory = options.temporaryDirectory ?? await node_fs.default.promises.mkdtemp(node_path.default.join(node_os.default.tmpdir(), "po-"));
+	await node_fs.default.promises.mkdir(temporaryDirectory, {
+		mode: 448,
+		recursive: true
+	});
+	await node_fs.default.promises.chmod(temporaryDirectory, 448);
+	const sharedSkills = node_path.default.join(repoRoot, ".claude", "skills");
+	const sharedSkillSources = options.sharedSkills === false ? [] : await discoverSkillsAsync(repoRoot, sharedSkills, "recursive", options.skillCacheDirectory);
+	const skillDirectories = [];
+	const skillSources = [];
+	const agentSources = [];
+	const pluginHooks = [];
+	for (const entry of pluginEntries) {
+		const pluginDirectory = entry.directory;
+		const skills = node_path.default.join(pluginDirectory, "skills");
+		if (await pathExists(skills)) {
+			const found = (await discoverSkillsAsync(repoRoot, skills, entry.skillDiscovery ?? "recursive", options.skillCacheDirectory)).filter((skill) => keepsName(entry.skills, skill.name));
+			skillDirectories.push(...found.map((skill) => skill.path));
+			skillSources.push(...found);
+		}
+		const agentFiles = await markdownFilesAsync(node_path.default.join(pluginDirectory, "agents"));
+		const agentNames = await Promise.all(agentFiles.map((filePath) => frontmatterNameAsync(filePath)));
+		agentSources.push(...agentFiles.map((filePath, index) => ({
+			name: agentNames[index] ?? "",
+			path: filePath
+		})).filter((agent) => keepsName(entry.agents, agent.name)));
+		const hookConfig = node_path.default.join(pluginDirectory, "hooks", "hooks.json");
+		if (entry.hooks !== false && await pathExists(hookConfig)) pluginHooks.push({
+			pluginRoot: pluginDirectory,
+			configPath: hookConfig
+		});
+	}
+	await assertUniqueAsync(skillSources, "skill");
+	await assertUniqueAsync(sharedSkillSources, "skill");
+	const pluginSkillNames = new Set(skillSources.map((skill) => skill.name));
+	const fallbackSharedSkills = sharedSkillSources.filter((skill) => !pluginSkillNames.has(skill.name));
+	skillDirectories.push(...fallbackSharedSkills.map((skill) => skill.path));
+	skillSources.push(...fallbackSharedSkills);
+	await assertUniqueAsync(agentSources, "agent");
+	if (agentSources.some((source) => source.name === "agiflow-dispatcher")) throw new Error(`Conflicting agent "${DISPATCHER_AGENT_NAME}": reserved by the agent harness`);
+	const agentDirectories = [];
+	const outputDirectory = node_path.default.join(temporaryDirectory, "agents");
+	await node_fs.default.promises.rm(outputDirectory, {
+		recursive: true,
+		force: true
+	});
+	if (options.agents) {
+		await node_fs.default.promises.mkdir(outputDirectory, { mode: 448 });
+		for (const source of agentSources) {
+			const adapted = adaptAgentDefinition(await node_fs.default.promises.readFile(source.path, "utf8"));
+			await node_fs.default.promises.writeFile(node_path.default.join(outputDirectory, `${assertSafeAgentName(adapted.name)}.md`), adapted.content, { mode: 384 });
+		}
+		await node_fs.default.promises.writeFile(node_path.default.join(outputDirectory, `${DISPATCHER_AGENT_NAME}.md`), dispatcherAgentSource(), { mode: 384 });
+		agentDirectories.push(outputDirectory);
+	}
+	const { mcpConfigPath, mcpProjection, pluginMcpSources, pluginMcpConfigPaths } = await stageMcpResources(repoRoot, pluginEntries, {
+		enabled: options.mcp,
+		temporaryDirectory,
+		...options.mcpAllowlist ? { mcpAllowlist: options.mcpAllowlist } : {},
+		...options.pluginDataRoot ? { pluginDataRoot: options.pluginDataRoot } : {}
+	});
+	return {
+		temporaryDirectory,
+		skillDirectories,
+		skillSources,
+		skillCount: skillSources.length,
+		agentCount: agentSources.length,
+		agentDirectories,
+		pluginHooks,
+		mcpConfigPath,
+		mcpProjection,
+		pluginMcpSources,
+		pluginMcpConfigPaths,
+		cleanup: () => ownsDirectory ? node_fs.default.promises.rm(temporaryDirectory, {
+			recursive: true,
+			force: true
+		}) : Promise.resolve()
+	};
+}
+//#endregion
+Object.defineProperty(exports, "DISPATCHER_AGENT_NAME", {
+	enumerable: true,
+	get: function() {
+		return DISPATCHER_AGENT_NAME;
+	}
+});
+Object.defineProperty(exports, "adaptAgentDefinition", {
+	enumerable: true,
+	get: function() {
+		return adaptAgentDefinition;
+	}
+});
+Object.defineProperty(exports, "collectResources", {
+	enumerable: true,
+	get: function() {
+		return collectResources;
+	}
+});
+Object.defineProperty(exports, "discoverSkills", {
+	enumerable: true,
+	get: function() {
+		return discoverSkills;
+	}
+});
+Object.defineProperty(exports, "discoverSkillsAsync", {
+	enumerable: true,
+	get: function() {
+		return discoverSkillsAsync;
+	}
+});
+Object.defineProperty(exports, "mergeMcpConfigs", {
+	enumerable: true,
+	get: function() {
+		return mergeMcpConfigs;
+	}
+});
+Object.defineProperty(exports, "mergeMcpConfigsAsync", {
+	enumerable: true,
+	get: function() {
+		return mergeMcpConfigsAsync;
+	}
+});
+Object.defineProperty(exports, "resolveSkillCacheDirectory", {
+	enumerable: true,
+	get: function() {
+		return resolveSkillCacheDirectory;
+	}
+});
+Object.defineProperty(exports, "sanitizeSyncLabel", {
+	enumerable: true,
+	get: function() {
+		return sanitizeSyncLabel;
+	}
+});
+Object.defineProperty(exports, "stageMcpResources", {
+	enumerable: true,
+	get: function() {
+		return stageMcpResources;
+	}
+});
+
+//# sourceMappingURL=resourceCollector-Cu-lp5hJ.cjs.map