@agimon-ai/po-team 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/{agentDiscovery-Whwzc4dP.cjs → agentDiscovery-DTTlM_LT.cjs}

@@ -1,88 +1,12 @@
-const require_atomicJson = require("./atomicJson-D0346bt5.cjs");
-let node_fs = require("node:fs");
-node_fs = require_atomicJson.__toESM(node_fs, 1);
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
 let node_path = require("node:path");
-node_path = require_atomicJson.__toESM(node_path, 1);
-let _agimon_ai_po_config = require("@agimon-ai/po-config");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let _agimon_ai_po_core_platform = require("@agimon-ai/po-core/platform");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
 let node_os = require("node:os");
-node_os = require_atomicJson.__toESM(node_os, 1);
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
 let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
-//#region src/schemas/team/packageConfig.ts
-const PO_TEAM_PACKAGE = "@agimon-ai/po-team";
-const TEAM_CONFIG_KEYS = ["models", "excludeTools"];
-const TEAM_MODEL_KEYS = ["model", "thinking"];
-const THINKING_VALUES = /* @__PURE__ */ new Set([
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-]);
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assertKnownKeys(value, keys, location) {
-	const unsupported = Object.keys(value).filter((key) => !keys.includes(key));
-	if (unsupported.length > 0) throw new Error(`${location} has unsupported field(s): ${unsupported.join(", ")}`);
-}
-/** Validate and normalize one Team-owned package configuration mapping. */
-function parseTeamPackageConfig(value, location) {
-	if (!isRecord(value)) throw new Error(`${location} must be a mapping`);
-	assertKnownKeys(value, TEAM_CONFIG_KEYS, location);
-	const hasModels = Object.hasOwn(value, "models");
-	const hasExcludeTools = Object.hasOwn(value, "excludeTools");
-	if (!hasModels && !hasExcludeTools) throw new Error(`${location} must define models or excludeTools`);
-	let models;
-	if (hasModels) {
-		if (!Array.isArray(value.models) || value.models.length === 0) throw new Error(`${location}.models must be a non-empty array`);
-		models = value.models.map((entry, index) => {
-			const entryLocation = `${location}.models[${index}]`;
-			if (!isRecord(entry)) throw new Error(`${entryLocation} must be a mapping`);
-			assertKnownKeys(entry, TEAM_MODEL_KEYS, entryLocation);
-			if (typeof entry.model !== "string" || !entry.model.trim()) throw new Error(`${entryLocation}.model must be a non-empty string`);
-			if (entry.thinking !== void 0 && (typeof entry.thinking !== "string" || !THINKING_VALUES.has(entry.thinking))) throw new Error(`${entryLocation}.thinking must be one of: ${[...THINKING_VALUES].join(", ")}`);
-			return {
-				model: entry.model.trim(),
-				...entry.thinking ? { thinking: entry.thinking } : {}
-			};
-		});
-	}
-	let excludeTools;
-	if (hasExcludeTools) {
-		if (!Array.isArray(value.excludeTools) || value.excludeTools.length === 0) throw new Error(`${location}.excludeTools must be a non-empty array`);
-		excludeTools = [...new Set(value.excludeTools.map((entry, index) => {
-			if (typeof entry !== "string" || !entry.trim()) throw new Error(`${location}.excludeTools[${index}] must be a non-empty string`);
-			return entry.trim();
-		}))];
-	}
-	return {
-		...models ? { models } : {},
-		...excludeTools ? { excludeTools } : {}
-	};
-}
-/** Merge Team configurations contributed by selected layers in selection order. */
-function mergeTeamPackageConfigurations(entries) {
-	let models;
-	const excludeTools = /* @__PURE__ */ new Set();
-	let hasExcludeTools = false;
-	for (const entry of entries) {
-		const location = `Package "${entry.specifier}" config in layer "${entry.layer}" of .po/modes.yaml`;
-		const next = parseTeamPackageConfig(entry.config, location);
-		if (next.models) models = next.models.map((model) => ({ ...model }));
-		if (next.excludeTools) {
-			hasExcludeTools = true;
-			for (const tool of next.excludeTools) excludeTools.add(tool);
-		}
-	}
-	if (!models && !hasExcludeTools) return void 0;
-	return {
-		...models ? { models } : {},
-		...hasExcludeTools ? { excludeTools: [...excludeTools] } : {}
-	};
-}
-//#endregion
 //#region src/services/agentFrontmatter/index.ts
 /**
 * Parsing the YAML frontmatter block at the head of an agent or chain file.
@@ -312,29 +236,133 @@ function getConfigDirName(environment = process.env) {
 function getProjectConfigDir(projectRoot, environment = process.env) {
 	return node_path.join(projectRoot, getConfigDirName(environment));
 }
-/** Read a JSON settings file as an object, retaining strict path-specific errors. */
-function readSettingsFileStrict(filePath) {
-	if (!node_fs.existsSync(filePath)) return {};
-	let raw;
+/** The user-level agent directory Po runs with, from Po's own resolver. */
+function getAgentDir(environment = process.env) {
+	return (0, _agimon_ai_po_core_piSettings.piAgentDirectory)(environment, environment.HOME ?? node_os.homedir());
+}
+//#endregion
+//#region src/services/agentProjectRoot/sync.ts
+/** @deprecated Node-only shim. */
+/**
+* Locating the project root that agent configuration hangs off.
+*
+* A project root is any ancestor of the working directory that carries a config
+* directory or a legacy `.agents` directory. There can be several: a package
+* inside a monorepo and the monorepo itself both qualify. Which one wins is a
+* setting, because both answers are legitimate. Teams that keep one shared set
+* of agents at the repository root want `git-root`, teams that give each package
+* its own want `nearest`, and neither can be inferred from the tree alone.
+*
+* DESIGN PATTERNS:
+* - Candidates are collected once, nearest first, then a policy picks from them.
+*   Separating collection from policy is what lets `git-root` be answered
+*   without a second walk
+* - Path derivation goes through `shared/configDir.ts`, so a rebranded build
+*   that renames its config directory needs no change here
+*
+* AVOID:
+* - Hardcoding the config directory name; it is discovered, not assumed
+* - Treating the nearest candidate as the project root without reading the
+*   setting first
+*/
+/** Stable cache identity for equivalent absolute, relative, and symlinked cwd spellings. */
+function canonicalizeDiscoveryCwd$1(cwd) {
+	const resolved = node_path.resolve(cwd);
 	try {
-		raw = node_fs.readFileSync(filePath, "utf-8");
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to read settings file '${filePath}': ${message}`, { cause: error });
+		return node_fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
 	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to parse settings file '${filePath}': ${message}`, { cause: error });
+}
+//#endregion
+//#region src/services/agentMemory/index.ts
+/**
+* Per-agent persistent memory, injected into a child system prompt.
+*
+* An agent may opt into a durable, role-specific memory scope via its `memory`
+* frontmatter. The opening lines of a `MEMORY.md` in the resolved directory are
+* injected so a recurring custom agent can recall accumulated role notes:
+* threat models, gotchas, verified commands, decisions. An agent with no write
+* tools gets a read-only variant of the block instead.
+*
+* DESIGN PATTERNS:
+* - The directory is derived from the agent's name, never from a user-supplied
+*   path, so no agent can name its way into another agent's notes
+* - The file is opened once with O_NOFOLLOW and every subsequent check runs on
+*   that descriptor, so a symlink swapped in after the check cannot be followed
+* - Reads are capped in both lines and bytes, and stop early. A memory file that
+*   grew unbounded must not be able to consume the child's whole context window
+* - Every containment failure degrades to no injection. A prompt with no memory
+*   is correct; a prompt pointed at an unverified path is not
+*
+* WHY THE DIRECTORY IS NAMESPACED:
+* Memory lives under a dedicated `agent-memory/` subdirectory so it can never
+* collide with the coding agent's own `memory/{project}/` tree.
+*
+* AVOID:
+* - Injecting memory contents without the boundary instruction; the file is data
+*   a previous run wrote, and a prompt-injection payload could have landed in it
+* - Re-stat'ing by path between the open and the read
+*/
+/** Tools that let an agent append to its own memory file. */
+const WRITE_TOOLS = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"bash"
+]);
+function unquoteFrontmatterValue(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function parseMemoryScope(value) {
+	return value === "project" || value === "user" ? value : void 0;
+}
+function parseMemoryBoolean(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+}
+function parsePositiveInteger(value) {
+	if (value === void 0) return void 0;
+	const parsed = Number(value);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+/** Split a `memory` frontmatter block into key/value pairs, either spelling. */
+function readMemoryEntries(raw) {
+	const entries = /* @__PURE__ */ new Map();
+	const inlineObject = raw.trim().match(/^\{(.*)\}$/s);
+	const parts = inlineObject?.[1] !== void 0 ? inlineObject[1].split(",") : raw.split("\n");
+	for (const part of parts) {
+		const match = part.trim().match(/^([\w-]+)\s*:\s*(.*)$/);
+		if (!match?.[1] || match[2] === void 0) continue;
+		entries.set(match[1], unquoteFrontmatterValue(match[2]));
 	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Settings file '${filePath}' must contain a JSON object.`);
-	return parsed;
+	return entries;
 }
-/** The user-level agent directory Po runs with, from Po's own resolver. */
-function getAgentDir(environment = process.env) {
-	return (0, _agimon_ai_po_core_piSettings.piAgentDirectory)(environment, environment.HOME ?? node_os.homedir());
+/**
+* Parse a `memory` frontmatter block, or undefined when it declares nothing.
+*
+* Accepts both the inline `{ scope: project }` form and the indented block form,
+* because agent files in the wild use each.
+*/
+function parseMemoryFrontmatter(raw) {
+	if (!raw) return void 0;
+	const entries = readMemoryEntries(raw);
+	const enabled = parseMemoryBoolean(entries.get("enabled"));
+	const scope = parseMemoryScope(entries.get("scope"));
+	const maxEntries = parsePositiveInteger(entries.get("maxEntries"));
+	if (enabled === void 0 && scope === void 0 && maxEntries === void 0) return void 0;
+	const config = {};
+	if (enabled !== void 0) config.enabled = enabled;
+	if (scope !== void 0) config.scope = scope;
+	if (maxEntries !== void 0) config.maxEntries = maxEntries;
+	return config;
+}
+/** Whether an agent can write files this run. An unset `tools` inherits the builtins. */
+function agentHasWriteTools(agent) {
+	const tools = agent.tools;
+	if (!tools) return true;
+	return tools.some((tool) => WRITE_TOOLS.has(tool));
 }
 //#endregion
 //#region src/services/agentProjectRoot/index.ts
@@ -352,7 +380,7 @@ function getAgentDir(environment = process.env) {
 * - Candidates are collected once, nearest first, then a policy picks from them.
 *   Separating collection from policy is what lets `git-root` be answered
 *   without a second walk
-* - Path derivation goes through `shared/configDir.ts`, so a rebranded build
+* - Path derivation uses injected directory settings, so a rebranded build
 *   that renames its config directory needs no change here
 *
 * AVOID:
@@ -360,6 +388,25 @@ function getAgentDir(environment = process.env) {
 * - Treating the nearest candidate as the project root without reading the
 *   setting first
 */
+async function readSettingsFile(io, filePath) {
+	let raw;
+	try {
+		raw = await (0, _agimon_ai_po_core_platform.readTextIfExists)(io.fs, filePath, io.context);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to read settings file '${filePath}': ${message}`, { cause: error });
+	}
+	if (raw === void 0) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to parse settings file '${filePath}': ${message}`, { cause: error });
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Settings file '${filePath}' must contain a JSON object.`);
+	return parsed;
+}
 const SETTINGS_FILE_NAME = "settings.json";
 const GIT_DIR_NAME$1 = ".git";
 /**
@@ -373,32 +420,33 @@ const AGENTS_DIR_NAME = "agents";
 const SUBAGENTS_SETTINGS_KEY$1 = "subagents";
 const PROJECT_ROOT_RESOLUTION_KEY = "projectRootResolution";
 /** Stable cache identity for equivalent absolute, relative, and symlinked cwd spellings. */
-function canonicalizeDiscoveryCwd(cwd) {
+async function canonicalizeDiscoveryCwd(io, cwd) {
 	const resolved = node_path.resolve(cwd);
 	try {
-		return node_fs.realpathSync.native(resolved);
+		return (0, _agimon_ai_po_core_platform.getOrThrow)(await io.fs.canonicalPath(resolved, io.context));
 	} catch {
 		return resolved;
 	}
 }
 /** Whether a path exists and is a directory. Any failure reads as "no". */
-function isDirectory$1(dirPath) {
+async function isDirectory(io, dirPath) {
 	try {
-		return node_fs.statSync(dirPath).isDirectory();
+		const canonical = (0, _agimon_ai_po_core_platform.getOrThrow)(await io.fs.canonicalPath(dirPath, io.context));
+		return (0, _agimon_ai_po_core_platform.getOrThrow)(await io.fs.fileInfo(canonical, io.context)).kind === "directory";
 	} catch {
 		return false;
 	}
 }
 /** True when `dir` carries either marker that makes it a project root. */
-function isProjectRootCandidate(dir, environment = process.env) {
-	return isDirectory$1(getProjectConfigDir(dir, environment)) || isDirectory$1(node_path.join(dir, DOT_AGENTS_DIR_NAME));
+async function isProjectRootCandidate(io, dir) {
+	return await isDirectory(io, node_path.join(dir, io.configDirName)) || await isDirectory(io, node_path.join(dir, DOT_AGENTS_DIR_NAME));
 }
 /** Every project root above `cwd`, nearest first. */
-function findProjectRootCandidates(cwd, environment = process.env) {
+async function findProjectRootCandidates(io, cwd) {
 	const roots = [];
 	let currentDir = cwd;
 	while (true) {
-		if (isProjectRootCandidate(currentDir, environment)) roots.push(currentDir);
+		if (await isProjectRootCandidate(io, currentDir)) roots.push(currentDir);
 		const parentDir = node_path.dirname(currentDir);
 		if (parentDir === currentDir) return roots;
 		currentDir = parentDir;
@@ -410,10 +458,11 @@ function findProjectRootCandidates(cwd, environment = process.env) {
 * Existence is enough: a worktree or submodule has a `.git` file rather than a
 * directory, and both are real repository roots.
 */
-function findNearestGitRoot(cwd) {
+async function findNearestGitRoot(io, cwd) {
 	let currentDir = cwd;
 	while (true) {
-		if (node_fs.existsSync(node_path.join(currentDir, GIT_DIR_NAME$1))) return currentDir;
+		const gitMarker = await io.fs.exists(node_path.join(currentDir, GIT_DIR_NAME$1), io.context);
+		if (gitMarker.ok && gitMarker.value) return currentDir;
 		const parentDir = node_path.dirname(currentDir);
 		if (parentDir === currentDir) return null;
 		currentDir = parentDir;
@@ -425,10 +474,9 @@ function findNearestGitRoot(cwd) {
 * Deliberately throws on an unrecognised value rather than falling back: a typo
 * here silently changes which agents the whole session sees.
 */
-function readProjectRootResolution(projectRoot, environment = process.env) {
-	const settingsPath = node_path.join(getProjectConfigDir(projectRoot, environment), SETTINGS_FILE_NAME);
-	if (!node_fs.existsSync(settingsPath)) return void 0;
-	const subagents = readSettingsFileStrict(settingsPath)[SUBAGENTS_SETTINGS_KEY$1];
+async function readProjectRootResolution(io, projectRoot) {
+	const settingsPath = node_path.join(projectRoot, io.configDirName, SETTINGS_FILE_NAME);
+	const subagents = (await readSettingsFile(io, settingsPath))[SUBAGENTS_SETTINGS_KEY$1];
 	if (!subagents || typeof subagents !== "object" || Array.isArray(subagents)) return void 0;
 	const value = subagents[PROJECT_ROOT_RESOLUTION_KEY];
 	if (value === void 0) return void 0;
@@ -442,15 +490,15 @@ function readProjectRootResolution(projectRoot, environment = process.env) {
 * of its monorepo's shared agents, and from the git root second so a repository
 * can claim its packages without editing each one.
 */
-function findConfiguredProjectRoot(cwd, environment = process.env) {
-	const candidates = findProjectRootCandidates(cwd, environment);
+async function findConfiguredProjectRoot(io, cwd) {
+	const candidates = await findProjectRootCandidates(io, cwd);
 	const nearestRoot = candidates[0];
 	if (!nearestRoot) return null;
-	const nearestMode = readProjectRootResolution(nearestRoot, environment);
+	const nearestMode = await readProjectRootResolution(io, nearestRoot);
 	if (nearestMode === "nearest") return nearestRoot;
-	const gitRoot = findNearestGitRoot(cwd);
+	const gitRoot = await findNearestGitRoot(io, cwd);
 	const gitProjectRoot = gitRoot ? candidates.find((candidate) => node_path.resolve(candidate) === node_path.resolve(gitRoot)) : void 0;
-	if (gitProjectRoot && (nearestMode === "git-root" || readProjectRootResolution(gitProjectRoot, environment) === "git-root")) return gitProjectRoot;
+	if (gitProjectRoot && (nearestMode === "git-root" || await readProjectRootResolution(io, gitProjectRoot) === "git-root")) return gitProjectRoot;
 	return nearestRoot;
 }
 /**
@@ -461,17 +509,17 @@ function findConfiguredProjectRoot(cwd, environment = process.env) {
 * working after the move. Returned unfiltered because the caller reads each
 * directory anyway and a missing one costs nothing.
 */
-function userAgentDirs(environment = process.env) {
-	return [node_path.join(getAgentDir(environment), AGENTS_DIR_NAME), node_path.join(environment.HOME ?? node_os.homedir(), DOT_AGENTS_DIR_NAME)];
+function userAgentDirs(io) {
+	return [node_path.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(io.environment, io.homeDirectory), AGENTS_DIR_NAME), node_path.join(io.homeDirectory, DOT_AGENTS_DIR_NAME)];
 }
 /** The user-level settings file. Always resolvable, unlike the project one. */
-function getUserAgentSettingsPath(environment = process.env) {
-	return node_path.join(getAgentDir(environment), SETTINGS_FILE_NAME);
+function getUserAgentSettingsPath(io) {
+	return node_path.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(io.environment, io.homeDirectory), SETTINGS_FILE_NAME);
 }
 /** The project settings file, or null when `cwd` sits under no project root. */
-function getProjectAgentSettingsPath(cwd, environment = process.env) {
-	const projectRoot = findConfiguredProjectRoot(cwd, environment);
-	return projectRoot ? node_path.join(getProjectConfigDir(projectRoot, environment), SETTINGS_FILE_NAME) : null;
+async function getProjectAgentSettingsPath(io, cwd) {
+	const projectRoot = await findConfiguredProjectRoot(io, cwd);
+	return projectRoot ? node_path.join(projectRoot, io.configDirName, SETTINGS_FILE_NAME) : null;
 }
 /**
 * Project agent directories for `cwd`.
@@ -481,144 +529,24 @@ function getProjectAgentSettingsPath(cwd, environment = process.env) {
 * `preferredDir` is where a newly created agent should be written, and is
 * returned whether or not it exists yet.
 */
-function resolveNearestProjectAgentDirs(cwd, environment = process.env) {
-	const projectRoot = findConfiguredProjectRoot(cwd, environment);
+async function resolveNearestProjectAgentDirs(io, cwd) {
+	const projectRoot = await findConfiguredProjectRoot(io, cwd);
 	if (!projectRoot) return {
 		readDirs: [],
 		preferredDir: null
 	};
 	const legacyDir = node_path.join(projectRoot, DOT_AGENTS_DIR_NAME);
-	const preferredDir = node_path.join(getProjectConfigDir(projectRoot, environment), AGENTS_DIR_NAME);
+	const preferredDir = node_path.join(projectRoot, io.configDirName, AGENTS_DIR_NAME);
 	const readDirs = [];
-	if (isDirectory$1(legacyDir)) readDirs.push(legacyDir);
-	if (isDirectory$1(preferredDir)) readDirs.push(preferredDir);
+	if (await isDirectory(io, legacyDir)) readDirs.push(legacyDir);
+	if (await isDirectory(io, preferredDir)) readDirs.push(preferredDir);
 	return {
 		readDirs,
 		preferredDir
 	};
 }
 //#endregion
-//#region src/services/agentMemory/index.ts
-/**
-* Per-agent persistent memory, injected into a child system prompt.
-*
-* An agent may opt into a durable, role-specific memory scope via its `memory`
-* frontmatter. The opening lines of a `MEMORY.md` in the resolved directory are
-* injected so a recurring custom agent can recall accumulated role notes:
-* threat models, gotchas, verified commands, decisions. An agent with no write
-* tools gets a read-only variant of the block instead.
-*
-* DESIGN PATTERNS:
-* - The directory is derived from the agent's name, never from a user-supplied
-*   path, so no agent can name its way into another agent's notes
-* - The file is opened once with O_NOFOLLOW and every subsequent check runs on
-*   that descriptor, so a symlink swapped in after the check cannot be followed
-* - Reads are capped in both lines and bytes, and stop early. A memory file that
-*   grew unbounded must not be able to consume the child's whole context window
-* - Every containment failure degrades to no injection. A prompt with no memory
-*   is correct; a prompt pointed at an unverified path is not
-*
-* WHY THE DIRECTORY IS NAMESPACED:
-* Memory lives under a dedicated `agent-memory/` subdirectory so it can never
-* collide with the coding agent's own `memory/{project}/` tree.
-*
-* AVOID:
-* - Injecting memory contents without the boundary instruction; the file is data
-*   a previous run wrote, and a prompt-injection payload could have landed in it
-* - Re-stat'ing by path between the open and the read
-*/
-/** Tools that let an agent append to its own memory file. */
-const WRITE_TOOLS = /* @__PURE__ */ new Set([
-	"edit",
-	"write",
-	"bash"
-]);
-function unquoteFrontmatterValue(value) {
-	const trimmed = value.trim();
-	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
-	return trimmed;
-}
-function parseMemoryScope(value) {
-	return value === "project" || value === "user" ? value : void 0;
-}
-function parseMemoryBoolean(value) {
-	if (value === "true") return true;
-	if (value === "false") return false;
-}
-function parsePositiveInteger(value) {
-	if (value === void 0) return void 0;
-	const parsed = Number(value);
-	return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
-}
-/** Split a `memory` frontmatter block into key/value pairs, either spelling. */
-function readMemoryEntries(raw) {
-	const entries = /* @__PURE__ */ new Map();
-	const inlineObject = raw.trim().match(/^\{(.*)\}$/s);
-	const parts = inlineObject?.[1] !== void 0 ? inlineObject[1].split(",") : raw.split("\n");
-	for (const part of parts) {
-		const match = part.trim().match(/^([\w-]+)\s*:\s*(.*)$/);
-		if (!match?.[1] || match[2] === void 0) continue;
-		entries.set(match[1], unquoteFrontmatterValue(match[2]));
-	}
-	return entries;
-}
-/**
-* Parse a `memory` frontmatter block, or undefined when it declares nothing.
-*
-* Accepts both the inline `{ scope: project }` form and the indented block form,
-* because agent files in the wild use each.
-*/
-function parseMemoryFrontmatter(raw) {
-	if (!raw) return void 0;
-	const entries = readMemoryEntries(raw);
-	const enabled = parseMemoryBoolean(entries.get("enabled"));
-	const scope = parseMemoryScope(entries.get("scope"));
-	const maxEntries = parsePositiveInteger(entries.get("maxEntries"));
-	if (enabled === void 0 && scope === void 0 && maxEntries === void 0) return void 0;
-	const config = {};
-	if (enabled !== void 0) config.enabled = enabled;
-	if (scope !== void 0) config.scope = scope;
-	if (maxEntries !== void 0) config.maxEntries = maxEntries;
-	return config;
-}
-/** Whether an agent can write files this run. An unset `tools` inherits the builtins. */
-function agentHasWriteTools(agent) {
-	const tools = agent.tools;
-	if (!tools) return true;
-	return tools.some((tool) => WRITE_TOOLS.has(tool));
-}
-//#endregion
 //#region src/services/agentSettings/index.ts
-/**
-* Agent settings: reading them, and applying what they say to discovered agents.
-*
-* Two things live here because they are the same contract seen from both ends.
-* Reading turns untyped JSON on disk into settings; applying folds those
-* settings over the agents discovery found. The precedence is fixed: project
-* settings beat user settings, an explicit per-agent override beats a bulk
-* switch, and for a custom agent the agent's own frontmatter beats both.
-*
-* That last rule is why builtins and custom agents take different paths.
-* Overriding a builtin replaces values outright, because a builtin has no file
-* the user could have edited instead. Overriding a custom agent only fills
-* fields its frontmatter left unset, so a settings default never silently
-* contradicts what the author wrote in the file.
-*
-* DESIGN PATTERNS:
-* - Reading is strict and throws with the offending path and field. A settings
-*   file that is quietly half-ignored is worse than one that refuses to load,
-*   because the user sees agents behaving in ways their config does not explain
-* - Applying is pure and copy-on-write. Every `apply*` returns new configs and
-*   never mutates its input, so a cached discovery result cannot be corrupted
-*   by a later pass over it
-* - Overriding a builtin snapshots the values it replaced into `override.base`,
-*   which is what makes removing the override restore the builtin exactly
-*
-* AVOID:
-* - Trusting any shape read off disk without a real guard
-* - Mutating an `AgentConfig` in place
-* - Writing a settings file non-atomically; it holds the user's overrides
-*/
 const SUBAGENTS_SETTINGS_KEY = "subagents";
 const AGENT_OVERRIDES_KEY = "agentOverrides";
 /** Prefix marking a tool the child calls on an MCP server directly. */
@@ -809,9 +737,9 @@ function parseToolBudgetOverride(value, name, filePath) {
 	return budget;
 }
 /** Read and validate one settings file's `subagents` block. */
-function readSubagentSettings(filePath) {
+async function readSubagentSettings(io, filePath) {
 	if (!filePath) return EMPTY_SUBAGENT_SETTINGS;
-	const subagentsObject = readObjectField(readSettingsFileStrict(filePath), SUBAGENTS_SETTINGS_KEY);
+	const subagentsObject = readObjectField(await readSettingsFile(io, filePath), SUBAGENTS_SETTINGS_KEY);
 	if (!subagentsObject) return EMPTY_SUBAGENT_SETTINGS;
 	let disableBuiltins;
 	if ("disableBuiltins" in subagentsObject) {
@@ -1177,16 +1105,9 @@ const LEGACY_AGENTS_DIR_NAME = ".agents";
 const LEGACY_SKILLS_DIR_NAME = "skills";
 const AGENT_FILE_EXTENSION = ".md";
 const CHAIN_FILE_EXTENSION = ".chain.md";
-function isDirectory(target) {
-	try {
-		return node_fs.statSync(target).isDirectory();
-	} catch {
-		return false;
-	}
-}
 /** A directory that owns its own agent configuration is a separate project. */
-function isDiscoveryNestedProjectRoot(dir, environment) {
-	return isDirectory(getProjectConfigDir(dir, environment)) || isDirectory(node_path.join(dir, LEGACY_AGENTS_DIR_NAME));
+async function isDiscoveryNestedProjectRoot(io, dir) {
+	return await isDirectory(io, node_path.join(dir, io.configDirName)) || await isDirectory(io, node_path.join(dir, LEGACY_AGENTS_DIR_NAME));
 }
 /**
 * Decide whether the walk should skip a subdirectory.
@@ -1195,10 +1116,11 @@ function isDiscoveryNestedProjectRoot(dir, environment) {
 * belong to that project, not to the one being scanned. The root itself is
 * exempt: scanning a project's own agent directory must not prune it.
 */
-function shouldPruneDiscoveryDir(rootDir, dir, dirName, environment) {
+async function shouldPruneDiscoveryDir(io, rootDir, dir, dirName) {
 	if (DISCOVERY_PRUNED_DIR_NAMES.has(dirName)) return true;
-	if (node_fs.existsSync(node_path.join(dir, GIT_DIR_NAME))) return true;
-	return node_path.resolve(dir) !== node_path.resolve(rootDir) && isDiscoveryNestedProjectRoot(dir, environment);
+	const gitMarker = await io.fs.exists(node_path.join(dir, GIT_DIR_NAME), io.context);
+	if (gitMarker.ok && gitMarker.value) return true;
+	return node_path.resolve(dir) !== node_path.resolve(rootDir) && await isDiscoveryNestedProjectRoot(io, dir);
 }
 /**
 * Collect matching files under `dir`, sorted so discovery order is stable.
@@ -1206,24 +1128,19 @@ function shouldPruneDiscoveryDir(rootDir, dir, dirName, environment) {
 * Symlinked entries are followed as files, because staging an agent by symlink
 * is a supported way to share one definition across projects.
 */
-function listFilesRecursive(dir, predicate, rootDir = dir, environment = process.env) {
+async function listFilesRecursive(io, dir, predicate, rootDir = dir) {
 	const files = [];
-	if (!node_fs.existsSync(dir)) return files;
-	let entries;
-	try {
-		entries = node_fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-	} catch {
-		return files;
-	}
+	const result = await io.fs.listDir(dir, io.context);
+	if (!result.ok) return files;
+	const entries = result.value.sort((a, b) => a.name.localeCompare(b.name));
 	for (const entry of entries) {
 		const filePath = node_path.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			if (!shouldPruneDiscoveryDir(rootDir, filePath, entry.name, environment)) files.push(...listFilesRecursive(filePath, predicate, rootDir, environment));
+		if (entry.kind === "directory") {
+			if (!await shouldPruneDiscoveryDir(io, rootDir, filePath, entry.name)) files.push(...await listFilesRecursive(io, filePath, predicate, rootDir));
 			continue;
 		}
-		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-		if (!predicate(entry.name)) continue;
-		files.push(filePath);
+		if (entry.kind !== "file" && entry.kind !== "symlink") continue;
+		if (predicate(entry.name)) files.push(filePath);
 	}
 	return files;
 }
@@ -1267,13 +1184,15 @@ function isAgentFileName(fileName) {
 * The returned configs carry only what the file itself declared. Settings
 * defaults, builtin overrides, and cross-source precedence are the caller's job.
 */
-function loadAgentsFromDir(dir, source, environment = process.env) {
+async function loadAgentsFromDir(io, dir, source) {
 	const agents = [];
-	for (const filePath of listFilesRecursive(dir, isAgentFileName, dir, environment)) {
+	for (const filePath of await listFilesRecursive(io, dir, isAgentFileName, dir)) {
 		if (isLegacyAgentSkillPath(dir, filePath)) continue;
 		let content;
 		try {
-			content = node_fs.readFileSync(filePath, "utf-8");
+			const text = await (0, _agimon_ai_po_core_platform.readTextIfExists)(io.fs, filePath, io.context);
+			if (text === void 0) continue;
+			content = text;
 		} catch {
 			continue;
 		}
@@ -1334,7 +1253,7 @@ function loadAgentsFromDir(dir, source, environment = process.env) {
 * Read from the environment on every call rather than captured once, because a
 * host can stage a plugin directory after this module is first imported.
 */
-function pluginAgentDirs(environment = process.env) {
+function pluginAgentDirs(environment) {
 	return (environment["PI_SUBAGENT_EXTRA_AGENT_DIRS"] ?? "").split(node_path.delimiter).map((directory) => directory.trim()).filter((directory) => directory.length > 0);
 }
 //#endregion
@@ -1442,8 +1361,6 @@ const MAX_CACHED_DISCOVERIES = 64;
 const FINGERPRINT_FIELD_SEPARATOR = ":";
 const FINGERPRINT_ENTRY_SEPARATOR = "|";
 const MISSING_SOURCE_MARKER = "-";
-const MAJOR_MODES_CONFIG_RELATIVE_PATH = node_path.join(".po", "modes.yaml");
-const THINKING_SUFFIX = /:(?:off|minimal|low|medium|high|xhigh|max)$/;
 /**
 * Merge the sources into one list, later sources shadowing earlier ones.
 *
@@ -1459,37 +1376,21 @@ function mergeAgentsForScope(scope, userAgents, projectAgents, pluginAgents = []
 	return [...byName.values()];
 }
 /** Size and mtime of one path, or a marker when it does not exist. */
-function stampOf(target) {
+async function stampOf(io, target) {
 	try {
-		const stat = node_fs.statSync(target);
+		const canonical = (0, _agimon_ai_po_core_platform.getOrThrow)(await io.fs.canonicalPath(target, io.context));
+		const stat = (0, _agimon_ai_po_core_platform.getOrThrow)(await io.fs.fileInfo(canonical, io.context));
 		return `${target}${FINGERPRINT_FIELD_SEPARATOR}${stat.mtimeMs}${FINGERPRINT_FIELD_SEPARATOR}${stat.size}`;
 	} catch {
 		return `${target}${FINGERPRINT_FIELD_SEPARATOR}${MISSING_SOURCE_MARKER}`;
 	}
 }
-/** Resolve Team-owned package configuration from the current parent harness state. */
-function resolveActiveTeamPackageConfig(environment = process.env) {
-	const harness = (0, _agimon_ai_po_config.loadHarnessState)(environment).state;
-	if (!harness.root) return void 0;
-	const layers = (0, _agimon_ai_po_config.loadMajorModesConfig)(harness.root, environment.HOME);
-	const config = mergeTeamPackageConfigurations((0, _agimon_ai_po_config.resolvePackageConfigurations)(layers, harness.layers, PO_TEAM_PACKAGE));
-	return config ? {
-		config,
-		path: node_path.join(harness.root, MAJOR_MODES_CONFIG_RELATIVE_PATH)
-	} : void 0;
-}
-function teamModelSpecs(config) {
-	if (!config?.models) return void 0;
-	return config.models.map(({ model, thinking }) => thinking ? `${model.replace(THINKING_SUFFIX, "")}:${thinking}` : model);
-}
-/** Resolve Team's ordered package model policy without merging it into an agent definition. */
-function resolveActiveTeamModelSpecs(environment = process.env) {
-	return teamModelSpecs(resolveActiveTeamPackageConfig(environment)?.config);
-}
 var AgentDiscoveryService = class {
-	environment;
-	constructor(environment = process.env) {
-		this.environment = environment;
+	io;
+	agentConfig;
+	constructor(io, agentConfig) {
+		this.io = io;
+		this.agentConfig = agentConfig;
 	}
 	cache = new LruCache(MAX_CACHED_DISCOVERIES);
 	/**
@@ -1502,23 +1403,25 @@ var AgentDiscoveryService = class {
 	now() {
 		return Date.now();
 	}
-	discover(cwd, scope) {
+	async discover(cwd, scope) {
 		const resolvedCwd = node_path.resolve(cwd);
-		const canonicalCwd = canonicalizeDiscoveryCwd(resolvedCwd);
+		const canonicalCwd = await canonicalizeDiscoveryCwd(this.io, resolvedCwd);
 		const key = `${scope}${FINGERPRINT_ENTRY_SEPARATOR}${canonicalCwd}`;
 		const cached = this.cache.get(key);
 		const timestamp = this.now();
-		if (cached && cached.expiresAt > timestamp && cached.fingerprint === this.fingerprint(canonicalCwd)) return cloneResult(cached.result);
-		const result = this.load(resolvedCwd, scope);
+		const team = await this.agentConfig?.currentOrUndefined();
+		if (cached && cached.team === team && cached.expiresAt > timestamp && cached.fingerprint === await this.fingerprint(canonicalCwd)) return cloneResult(cached.result);
+		const result = await this.load(resolvedCwd, scope, team);
 		this.cache.set(key, {
 			result,
 			expiresAt: timestamp + this.ttlMs,
-			fingerprint: this.fingerprint(canonicalCwd)
+			fingerprint: await this.fingerprint(canonicalCwd),
+			team
 		});
 		return cloneResult(result);
 	}
-	find(cwd, scope, name) {
-		return this.discover(cwd, scope).agents.find((agent) => agent.name === name);
+	async find(cwd, scope, name) {
+		return (await this.discover(cwd, scope)).agents.find((agent) => agent.name === name);
 	}
 	invalidate() {
 		this.cache.clear();
@@ -1530,43 +1433,42 @@ var AgentDiscoveryService = class {
 	* from the same directory read overlapping sources, and computing one stamp
 	* keeps the stat count fixed regardless of how many scopes are queried.
 	*/
-	fingerprint(cwd) {
-		const harness = (0, _agimon_ai_po_config.loadHarnessState)(this.environment).state;
+	async fingerprint(cwd) {
 		const sources = [
-			getUserAgentSettingsPath(this.environment),
-			getProjectAgentSettingsPath(cwd, this.environment) ?? MISSING_SOURCE_MARKER,
-			...userAgentDirs(this.environment),
-			...resolveNearestProjectAgentDirs(cwd, this.environment).readDirs,
-			...pluginAgentDirs(this.environment)
+			getUserAgentSettingsPath(this.io),
+			await getProjectAgentSettingsPath(this.io, cwd) ?? MISSING_SOURCE_MARKER,
+			...userAgentDirs(this.io),
+			...(await resolveNearestProjectAgentDirs(this.io, cwd)).readDirs,
+			...pluginAgentDirs(this.io.environment)
 		];
-		if (harness.root) sources.push(node_path.join(harness.root, MAJOR_MODES_CONFIG_RELATIVE_PATH));
-		return [...sources.map(stampOf), `active-layers${FINGERPRINT_FIELD_SEPARATOR}${harness.layers.join(",")}`].join(FINGERPRINT_ENTRY_SEPARATOR);
+		return (await Promise.all(sources.map((target) => stampOf(this.io, target)))).join(FINGERPRINT_ENTRY_SEPARATOR);
 	}
 	/**
 	* The uncached read. Protected so a test can count how often it actually runs,
 	* which is the only direct way to assert that the cache is doing its job.
 	*/
-	load(cwd, scope) {
-		const userSettingsPath = getUserAgentSettingsPath(this.environment);
-		const projectSettingsPath = getProjectAgentSettingsPath(cwd, this.environment);
-		const userSettings = scope === "project" ? EMPTY_SUBAGENT_SETTINGS : readSubagentSettings(userSettingsPath);
-		const projectSettings = scope === "user" ? EMPTY_SUBAGENT_SETTINGS : readSubagentSettings(projectSettingsPath);
+	async load(cwd, scope, team) {
+		const userSettingsPath = getUserAgentSettingsPath(this.io);
+		const projectSettingsPath = await getProjectAgentSettingsPath(this.io, cwd);
+		const userSettings = scope === "project" ? EMPTY_SUBAGENT_SETTINGS : await readSubagentSettings(this.io, userSettingsPath);
+		const projectSettings = scope === "user" ? EMPTY_SUBAGENT_SETTINGS : await readSubagentSettings(this.io, projectSettingsPath);
 		const legacyDefaultModel = resolveSubagentDefaultModel(userSettings, projectSettings, userSettingsPath, projectSettingsPath);
-		const teamPackage = resolveActiveTeamPackageConfig(this.environment);
-		const packagePrimaryModel = teamModelSpecs(teamPackage?.config)?.[0];
-		const defaultModel = packagePrimaryModel && teamPackage ? {
+		const packagePrimaryModel = team?.models?.[0];
+		const defaultModel = packagePrimaryModel && team ? {
 			type: "packages.team.defaultModel",
 			scope: "package",
-			path: teamPackage.path,
+			path: team.path ?? "",
 			model: packagePrimaryModel
 		} : legacyDefaultModel;
 		const defaultThinking = resolveSubagentDefaultThinking(userSettings, projectSettings, projectSettingsPath);
 		const defaultExtensions = resolveSubagentDefaultExtensions(userSettings, projectSettings, projectSettingsPath);
 		const resolve = (agents) => applyCustomAgentOverrides(applySubagentDefaults(agents, defaultModel, defaultThinking, defaultExtensions), userSettings, projectSettings, userSettingsPath, projectSettingsPath);
-		const plugin = resolve(pluginAgentDirs(this.environment).flatMap((directory) => loadAgentsFromDir(directory, "plugin", this.environment)));
+		const projectDirs = await resolveNearestProjectAgentDirs(this.io, cwd);
+		const loadDirs = async (dirs, source) => resolve((await Promise.all(dirs.map((dir) => loadAgentsFromDir(this.io, dir, source)))).flat());
+		const plugin = await loadDirs(pluginAgentDirs(this.io.environment), "plugin");
 		return {
-			agents: mergeAgentsForScope(scope, scope === "project" ? [] : resolve(userAgentDirs(this.environment).flatMap((directory) => loadAgentsFromDir(directory, "user", this.environment))), scope === "user" ? [] : resolve(resolveNearestProjectAgentDirs(cwd, this.environment).readDirs.flatMap((directory) => loadAgentsFromDir(directory, "project", this.environment))), plugin).filter((agent) => agent.disabled !== true),
-			projectAgentsDir: resolveNearestProjectAgentDirs(cwd, this.environment).preferredDir,
+			agents: mergeAgentsForScope(scope, scope === "project" ? [] : await loadDirs(userAgentDirs(this.io), "user"), scope === "user" ? [] : await loadDirs(projectDirs.readDirs, "project"), plugin).filter((agent) => agent.disabled !== true),
+			projectAgentsDir: projectDirs.preferredDir,
 			modelScope: projectSettings.modelScope ?? userSettings.modelScope
 		};
 	}
@@ -1606,7 +1508,7 @@ Object.defineProperty(exports, "agentHasWriteTools", {
 Object.defineProperty(exports, "canonicalizeDiscoveryCwd", {
 	enumerable: true,
 	get: function() {
-		return canonicalizeDiscoveryCwd;
+		return canonicalizeDiscoveryCwd$1;
 	}
 });
 Object.defineProperty(exports, "getAgentDir", {
@@ -1615,23 +1517,17 @@ Object.defineProperty(exports, "getAgentDir", {
 		return getAgentDir;
 	}
 });
-Object.defineProperty(exports, "getProjectConfigDir", {
-	enumerable: true,
-	get: function() {
-		return getProjectConfigDir;
-	}
-});
-Object.defineProperty(exports, "resolveActiveTeamModelSpecs", {
+Object.defineProperty(exports, "getConfigDirName", {
 	enumerable: true,
 	get: function() {
-		return resolveActiveTeamModelSpecs;
+		return getConfigDirName;
 	}
 });
-Object.defineProperty(exports, "resolveActiveTeamPackageConfig", {
+Object.defineProperty(exports, "getProjectConfigDir", {
 	enumerable: true,
 	get: function() {
-		return resolveActiveTeamPackageConfig;
+		return getProjectConfigDir;
 	}
 });
 
-//# sourceMappingURL=agentDiscovery-Whwzc4dP.cjs.map
+//# sourceMappingURL=agentDiscovery-DTTlM_LT.cjs.map