@agntn/harnesses 0.0.1

package/dist/_chunks/agents-sync.mjs

@@ -0,0 +1,2719 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, renameSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { basename, dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
+import os, { homedir } from "node:os";
+import { stripVTControlCharacters } from "node:util";
+import { parse } from "smol-toml";
+function resolvePathTemplate(template, options = {}) {
+	const homeDir = options.homeDir ?? os.homedir();
+	const projectRoot = options.projectRoot ?? process.cwd();
+	return template.replace(/^~(?=\/|$)/, homeDir).replaceAll("${HOME}", homeDir).replaceAll("${PROJECT_ROOT}", projectRoot).replaceAll(/%([^%]+)%/g, (match, name) => process.env[name] ?? match);
+}
+function agntnConfigDir(options = {}) {
+	const base = process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME !== "" ? process.env.XDG_CONFIG_HOME : join(options.homeDir ?? os.homedir(), ".config");
+	return join(base, "agntn");
+}
+const SUPPORTED_PLATFORMS = {
+	linux: true,
+	darwin: true,
+	win32: true
+};
+const ALTERNATE_INVOCATION_MODE = {
+	advisor: "agent",
+	advisorStructured: "agentStructured",
+	agent: "advisor",
+	agentStructured: "advisorStructured"
+};
+const INVOCATION_MODE_DESCRIPTION = {
+	advisor: "advisor without tools",
+	advisorStructured: "structured (JSON) advisor without tools",
+	readOnly: "read-only full agent",
+	readOnlyStructured: "structured (JSON) read-only full agent",
+	agent: "full agent",
+	agentStructured: "structured (JSON) full agent"
+};
+const INVOCATION_RETRY_HINT = {
+	advisor: "; retry with tools: true to start its full agent",
+	advisorStructured: "; retry with tools: true to start its full agent",
+	agent: "; retry with tools: false to use its advisor without tools",
+	agentStructured: "; retry with tools: false to use its advisor without tools"
+};
+function requestedInvocationMode(options) {
+	if (options.readOnly === true) return options.structured === true ? "readOnlyStructured" : "readOnly";
+	if (options.tools === true) return options.structured === true ? "agentStructured" : "agent";
+	return options.structured === true ? "advisorStructured" : "advisor";
+}
+function invocationTemplate(invocation, mode) {
+	switch (mode) {
+		case "advisor": return invocation.noToolsArgs;
+		case "advisorStructured": return invocation.noToolsJsonArgs;
+		case "readOnly": return invocation.readOnlyArgs;
+		case "readOnlyStructured": return invocation.readOnlyJsonArgs;
+		case "agent": return invocation.args;
+		case "agentStructured": return invocation.jsonArgs;
+	}
+}
+function buildInvocationArgs(template, prompt, modelArgs, model) {
+	const args = template.map((arg) => arg.replaceAll("{prompt}", prompt));
+	if (model !== void 0 && modelArgs) args.push(...modelArgs.map((arg) => arg.replaceAll("{model}", model)));
+	return args;
+}
+function executeCommand(command, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			env: options.env ? {
+				...process.env,
+				...options.env
+			} : process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		let timedOut = false;
+		const timer = options.timeoutMs ? setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+		}, options.timeoutMs) : void 0;
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+		});
+		child.on("error", (error) => {
+			if (timer) clearTimeout(timer);
+			reject(error);
+		});
+		child.on("close", (code) => {
+			if (timer) clearTimeout(timer);
+			resolve({
+				command,
+				args: [...args],
+				stdout,
+				stderr,
+				exitCode: timedOut ? null : code,
+				timedOut
+			});
+		});
+	});
+}
+var Harness = class {
+	modelListing = null;
+	mcpConfigs = [];
+	agentsFile = null;
+	isInstalled() {
+		const cmd = process.platform === "win32" ? "where" : "which";
+		return this.binaries.some((binary) => {
+			try {
+				execFileSync(cmd, [binary], { stdio: "pipe" });
+				return true;
+			} catch {
+				return false;
+			}
+		});
+	}
+	detectEnv() {
+		return this.detection.envVars.some((v) => !!process.env[v]);
+	}
+	detectProject(cwd) {
+		const dir = cwd ?? process.cwd();
+		return this.detection.projectMarkers.some((marker) => existsSync(join(dir, marker)));
+	}
+	get version() {
+		for (const binary of this.binaries) try {
+			const match = execFileSync(binary, ["--version"], {
+				encoding: "utf8",
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				timeout: 5e3
+			}).match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+			if (match?.[1]) return match[1];
+		} catch {
+			continue;
+		}
+		return null;
+	}
+	get invocationModes() {
+		return {
+			advisor: this.invocation?.noToolsArgs !== void 0,
+			advisorStructured: this.invocation?.noToolsJsonArgs !== void 0,
+			readOnly: this.invocation?.readOnlyArgs !== void 0,
+			readOnlyStructured: this.invocation?.readOnlyJsonArgs !== void 0,
+			agent: this.invocation?.args !== void 0,
+			agentStructured: this.invocation?.jsonArgs !== void 0
+		};
+	}
+	buildInvocation(prompt, options = {}) {
+		if (!this.invocation) return null;
+		const command = this.invocation.binary ?? this.binaries[0];
+		if (!command) return null;
+		if (options.model !== void 0 && !this.invocation.modelArgs) return null;
+		const template = invocationTemplate(this.invocation, requestedInvocationMode(options));
+		if (!template) return null;
+		return {
+			command,
+			args: buildInvocationArgs(template, prompt, this.invocation.modelArgs, options.model)
+		};
+	}
+	invocationError(options = {}) {
+		if (!this.invocation) return `Harness ${this.id} has no non-interactive invocation`;
+		if (options.model !== void 0 && !this.invocation.modelArgs) return `Harness ${this.id} does not support model selection`;
+		const mode = requestedInvocationMode(options);
+		if (invocationTemplate(this.invocation, mode)) return null;
+		const alternateMode = ALTERNATE_INVOCATION_MODE[mode];
+		const retry = (alternateMode === void 0 ? void 0 : invocationTemplate(this.invocation, alternateMode)) ? INVOCATION_RETRY_HINT[mode] ?? "" : "";
+		return `Harness ${this.id} has no ${INVOCATION_MODE_DESCRIPTION[mode]} invocation${retry}`;
+	}
+	invoke(prompt, options = {}) {
+		const invocationOptions = {
+			model: options.model,
+			structured: options.structured,
+			tools: options.tools,
+			readOnly: options.readOnly
+		};
+		const built = this.buildInvocation(prompt, invocationOptions);
+		if (!built) return Promise.reject(new Error(this.invocationError(invocationOptions) ?? "Invalid invocation"));
+		return executeCommand(built.command, built.args, options);
+	}
+	buildModelListInvocation(search) {
+		if (!this.modelListing) return null;
+		const command = this.binaries[0];
+		if (!command) return null;
+		const template = search === void 0 ? this.modelListing.args : this.modelListing.searchArgs;
+		if (!template) return null;
+		return {
+			command,
+			args: template.map((arg) => arg.replaceAll("{search}", search ?? ""))
+		};
+	}
+	async listModels(options = {}) {
+		const built = this.buildModelListInvocation(options.search);
+		if (!built) throw new Error(this.modelListing ? `Harness ${this.id} does not support filtering its model listing` : `Harness ${this.id} does not support model listing`);
+		const result = await executeCommand(built.command, built.args, options);
+		return {
+			...result,
+			models: !result.timedOut && result.exitCode === 0 ? this.parseModelListingOutput(result.stdout) : []
+		};
+	}
+	parseModelListingOutput(_stdout) {
+		throw new Error(`Harness ${this.id} does not implement model-list output parsing`);
+	}
+	resolveCandidates(entries, options = {}) {
+		const raw = options.platform ?? process.platform;
+		if (!Object.hasOwn(SUPPORTED_PLATFORMS, raw)) throw new Error(`Unsupported platform: ${raw}. Expected one of: linux, darwin, win32`);
+		const platform = raw;
+		return entries.filter((entry) => !entry.platforms || entry.platforms.includes(platform)).map((entry) => ({
+			...entry,
+			path: resolvePathTemplate(entry.path, options)
+		}));
+	}
+	resolve(options = {}) {
+		return {
+			config: this.resolveCandidates(this.config, options),
+			sessions: this.resolveCandidates(this.sessions, options),
+			instructions: this.resolveCandidates(this.instructions, options),
+			skills: this.resolveCandidates(this.skills, options),
+			commands: this.resolveCandidates(this.commands, options),
+			hooks: this.resolveCandidates(this.hooks, options)
+		};
+	}
+};
+var Antigravity = class extends Harness {
+	id = "antigravity";
+	name = "Google Antigravity CLI";
+	binaries = ["agy"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: true,
+		video: true,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.gemini/config/config.json",
+			scope: "user",
+			level: "official",
+			note: "Shared Antigravity configuration and user settings."
+		},
+		{
+			path: "~/.gemini/antigravity-cli/settings.json",
+			scope: "user",
+			level: "official",
+			note: "CLI-specific settings, including trusted workspaces."
+		},
+		{
+			path: "~/.gemini/config/skills.json",
+			scope: "user",
+			level: "official",
+			note: "Explicit registrations of skill directories outside the default locations."
+		},
+		{
+			path: "~/.gemini/config/plugins.json",
+			scope: "user",
+			level: "official",
+			note: "Explicit registrations of plugin directories outside the default locations."
+		},
+		{
+			path: ".agents/skills.json",
+			scope: "project",
+			level: "official",
+			note: "Workspace registrations of skill directories outside .agents/skills/."
+		},
+		{
+			path: ".agents/plugins.json",
+			scope: "project",
+			level: "official",
+			note: "Workspace registrations of plugin directories outside .agents/plugins/."
+		}
+	];
+	sessions = [
+		{
+			path: "~/.gemini/antigravity-cli/conversations/",
+			scope: "data",
+			level: "official",
+			note: "Persisted CLI conversations."
+		},
+		{
+			path: "~/.gemini/antigravity-cli/history.jsonl",
+			scope: "data",
+			level: "official",
+			note: "CLI prompt history."
+		},
+		{
+			path: "~/.gemini/antigravity-cli/conversation_summaries.db",
+			scope: "data",
+			level: "official",
+			note: "Conversation summary index."
+		}
+	];
+	persistence = [
+		{
+			format: "JSON",
+			level: "official",
+			note: "Settings and project metadata."
+		},
+		{
+			format: "JSONL",
+			level: "official",
+			note: "Prompt history."
+		},
+		{
+			format: "SQLite",
+			level: "official",
+			note: "Conversation summary index."
+		},
+		{
+			format: "Protocol Buffers",
+			level: "official",
+			note: "Conversation and runtime state."
+		}
+	];
+	instructions = [
+		{
+			path: "~/.gemini/config/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global rules in the shared Antigravity customization root."
+		},
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Workspace instructions; GEMINI.md is also supported."
+		},
+		{
+			path: "GEMINI.md",
+			scope: "project",
+			level: "official",
+			note: "Workspace instructions compatible with Gemini CLI."
+		}
+	];
+	skills = [{
+		path: ".agents/skills/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.gemini/config/skills/",
+		scope: "user",
+		level: "official"
+	}];
+	commands = [];
+	hooks = [{
+		path: ".agents/hooks.json",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.gemini/config/hooks.json",
+		scope: "user",
+		level: "official"
+	}];
+	invocation = {
+		args: ["--print", "{prompt}"],
+		jsonArgs: [
+			"--print",
+			"--output-format",
+			"json",
+			"{prompt}"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Non-interactive print mode."
+	};
+	mcpConfigs = [{
+		path: "~/.gemini/config/mcp_config.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "antigravity"
+	}];
+	agentsFile = "~/.gemini/config/AGENTS.md";
+	detection = {
+		envVars: [],
+		projectMarkers: [".antigravitycli"]
+	};
+};
+var Claude = class extends Harness {
+	id = "claude";
+	name = "Anthropic Claude Code";
+	binaries = ["claude"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.claude/settings.json",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "~/.claude.json",
+			scope: "user",
+			level: "official",
+			note: "Global MCP server configurations."
+		},
+		{
+			path: ".claude/settings.json",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".claude/settings.local.json",
+			scope: "project",
+			level: "official",
+			note: "Local overrides, typically gitignored."
+		},
+		{
+			path: ".claude/.mcp.json",
+			scope: "project",
+			level: "official",
+			note: "Project-scoped MCP server configurations."
+		},
+		{
+			path: "/etc/claude-code/managed-settings.json",
+			scope: "system",
+			level: "official",
+			platforms: ["linux"],
+			note: "Enterprise managed settings."
+		},
+		{
+			path: "/Library/Application Support/ClaudeCode/managed-settings.json",
+			scope: "system",
+			level: "official",
+			platforms: ["darwin"],
+			note: "Enterprise managed settings."
+		}
+	];
+	sessions = [{
+		path: "~/.claude/projects/<dash-encoded-cwd>/*.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Per-project session transcripts in JSONL format."
+	}, {
+		path: "~/.claude/history.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Global prompt history across all projects."
+	}];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Settings and MCP config files."
+	}, {
+		format: "JSONL",
+		level: "official",
+		note: "Session transcripts and global history."
+	}];
+	instructions = [
+		{
+			path: "CLAUDE.md",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".claude/CLAUDE.md",
+			scope: "project",
+			level: "official",
+			note: "Alternative project-level location."
+		},
+		{
+			path: "~/.claude/CLAUDE.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		}
+	];
+	skills = [{
+		path: ".claude/skills/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.claude/skills/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level skills."
+	}];
+	commands = [{
+		path: ".claude/commands/",
+		scope: "project",
+		level: "official",
+		note: "Legacy slash commands, merged into skills."
+	}, {
+		path: "~/.claude/commands/",
+		scope: "user",
+		level: "official",
+		note: "Legacy global slash commands."
+	}];
+	hooks = [{
+		path: ".claude/hooks/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.claude/hooks/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level hooks."
+	}];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"--output-format",
+			"json",
+			"{prompt}"
+		],
+		noToolsArgs: [
+			"-p",
+			"{prompt}",
+			"--tools",
+			""
+		],
+		noToolsJsonArgs: [
+			"-p",
+			"--output-format",
+			"json",
+			"{prompt}",
+			"--tools",
+			""
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Headless print mode; add --output-format json for structured output."
+	};
+	mcpConfigs = [{
+		path: "~/.claude.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}, {
+		path: ".mcp.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}];
+	agentsFile = "~/.claude/CLAUDE.md";
+	detection = {
+		envVars: [
+			"CLAUDE_CODE",
+			"CLAUDECODE",
+			"CLAUDE_CODE_ENTRYPOINT",
+			"CLAUDE_CONFIG_DIR"
+		],
+		projectMarkers: [
+			".claude/settings.json",
+			".claude/settings.local.json",
+			".claude/skills",
+			"CLAUDE.md"
+		]
+	};
+};
+var Codex = class extends Harness {
+	id = "codex";
+	name = "OpenAI Codex CLI";
+	binaries = ["codex"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.codex/config.toml",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: ".codex/config.toml",
+			scope: "project",
+			level: "official",
+			note: "Searched from cwd up to project root (.git boundary)."
+		},
+		{
+			path: "/etc/codex/config.toml",
+			scope: "system",
+			level: "official",
+			platforms: ["linux", "darwin"]
+		}
+	];
+	sessions = [
+		{
+			path: "~/.codex/sessions/",
+			scope: "data",
+			level: "official",
+			note: "Session rollouts in JSONL format, organized by date."
+		},
+		{
+			path: "~/.codex/history.jsonl",
+			scope: "data",
+			level: "official",
+			note: "Command history."
+		},
+		{
+			path: "~/.codex/state_5.sqlite",
+			scope: "data",
+			level: "official",
+			note: "SQLite state database for threads and agent state."
+		}
+	];
+	persistence = [
+		{
+			format: "TOML",
+			level: "official",
+			note: "Configuration files."
+		},
+		{
+			format: "JSONL",
+			level: "official",
+			note: "Conversation transcripts."
+		},
+		{
+			format: "SQLite",
+			level: "official",
+			note: "Thread and agent state."
+		}
+	];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "AGENTS.override.md",
+			scope: "project",
+			level: "official",
+			note: "Local override, takes precedence over AGENTS.md."
+		},
+		{
+			path: "~/.codex/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		},
+		{
+			path: "~/.codex/AGENTS.override.md",
+			scope: "user",
+			level: "official",
+			note: "Global override, takes precedence over global AGENTS.md."
+		}
+	];
+	skills = [
+		{
+			path: ".codex/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".agents/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "~/.codex/skills/",
+			scope: "user",
+			level: "official",
+			note: "Deprecated, use ~/.agents/skills/ instead."
+		},
+		{
+			path: "~/.agents/skills/",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "/etc/codex/skills/",
+			scope: "system",
+			level: "official",
+			platforms: ["linux", "darwin"]
+		}
+	];
+	commands = [];
+	hooks = [];
+	invocation = {
+		args: ["exec", "{prompt}"],
+		jsonArgs: [
+			"exec",
+			"--json",
+			"{prompt}"
+		],
+		readOnlyArgs: [
+			"exec",
+			"--sandbox",
+			"read-only",
+			"{prompt}"
+		],
+		readOnlyJsonArgs: [
+			"exec",
+			"--sandbox",
+			"read-only",
+			"--json",
+			"{prompt}"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Non-interactive exec subcommand; add --json for structured output."
+	};
+	mcpConfigs = [{
+		path: "~/.codex/config.toml",
+		scope: "user",
+		level: "official",
+		format: "toml",
+		key: ["mcp_servers"],
+		dialect: "standard"
+	}, {
+		path: ".codex/config.toml",
+		scope: "project",
+		level: "official",
+		format: "toml",
+		key: ["mcp_servers"],
+		dialect: "standard"
+	}];
+	agentsFile = "~/.codex/AGENTS.md";
+	detection = {
+		envVars: [],
+		projectMarkers: [
+			".codex",
+			"AGENTS.md",
+			"AGENTS.override.md",
+			".agents/skills"
+		]
+	};
+};
+var Cursor = class extends Harness {
+	id = "cursor";
+	name = "Cursor";
+	binaries = ["cursor"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.cursor/settings.json",
+		scope: "user",
+		level: "official"
+	}];
+	sessions = [];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Settings and rules files."
+	}];
+	instructions = [{
+		path: ".cursor/rules/skilld-activation.mdc",
+		scope: "project",
+		level: "official",
+		note: "MDC format rule for skill activation."
+	}, {
+		path: ".cursorrules",
+		scope: "project",
+		level: "official",
+		note: "Legacy project-level instructions."
+	}];
+	skills = [
+		{
+			path: ".cursor/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "~/.cursor/skills/",
+			scope: "user",
+			level: "official",
+			note: "Global user-level skills."
+		},
+		{
+			path: ".claude/skills/",
+			scope: "project",
+			level: "official",
+			note: "Cursor natively scans Claude skills directory."
+		},
+		{
+			path: ".codex/skills/",
+			scope: "project",
+			level: "official",
+			note: "Cursor natively scans Codex skills directory."
+		}
+	];
+	commands = [];
+	hooks = [];
+	invocation = {
+		binary: "cursor-agent",
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"--output-format",
+			"json",
+			"{prompt}"
+		],
+		level: "community",
+		note: "Cursor CLI agent binary, separate from the editor binary."
+	};
+	mcpConfigs = [{
+		path: "~/.cursor/mcp.json",
+		scope: "user",
+		level: "community",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}, {
+		path: ".cursor/mcp.json",
+		scope: "project",
+		level: "community",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}];
+	detection = {
+		envVars: ["CURSOR_SESSION", "CURSOR_TRACE_ID"],
+		projectMarkers: [".cursor", ".cursorrules"]
+	};
+};
+var Freebuff = class extends Harness {
+	id = "freebuff";
+	name = "Freebuff";
+	binaries = ["freebuff"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.config/manicode/settings.json",
+		scope: "user",
+		level: "official",
+		note: "Freebuff is Codebuff-based; user data lives under ~/.config/manicode/ on all platforms."
+	}, {
+		path: "~/.config/manicode/credentials.json",
+		scope: "user",
+		level: "official",
+		note: "Authentication credentials."
+	}];
+	sessions = [{
+		path: "~/.config/manicode/projects/<project-name>/chats/<timestamp>/",
+		scope: "data",
+		level: "official",
+		note: "Per-chat directories with chat-messages.json, chat-meta.json, run-state.json, and log.jsonl."
+	}, {
+		path: "~/.config/manicode/message-history.json",
+		scope: "data",
+		level: "official",
+		note: "Prompt history."
+	}];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Settings, credentials, chat messages, and run state."
+	}, {
+		format: "JSONL",
+		level: "official",
+		note: "Per-chat logs (log.jsonl)."
+	}];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Knowledge files; scaffolded by the init flow. knowledge.md, *.knowledge.md, and CLAUDE.md in any project directory are loaded the same way."
+		},
+		{
+			path: "knowledge.md",
+			scope: "project",
+			level: "official",
+			note: "Per-directory project knowledge."
+		},
+		{
+			path: "~/.AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "User-level knowledge files in the home directory; ~/.knowledge.md and ~/.CLAUDE.md are accepted too. Read-only for the agent."
+		}
+	];
+	skills = [{
+		path: ".agents/skills/",
+		scope: "project",
+		level: "official",
+		note: "Also the install target for community skills via npx skills add; .agents/types/ holds agent template types."
+	}];
+	commands = [];
+	hooks = [];
+	invocation = null;
+	mcpConfigs = [{
+		path: "~/.agents/mcp.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}, {
+		path: ".agents/mcp.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard",
+		note: "The parent directory's .agents/mcp.json is scanned too; agent templates can also embed their own mcpServers."
+	}];
+	agentsFile = "~/.AGENTS.md";
+	detection = {
+		envVars: [],
+		projectMarkers: [".agents", "knowledge.md"]
+	};
+};
+var Gemini = class extends Harness {
+	id = "gemini";
+	name = "Google Gemini CLI";
+	binaries = ["gemini"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: true,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.gemini/settings.json",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: ".gemini/settings.json",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "/etc/gemini-cli/settings.json",
+			scope: "system",
+			level: "official",
+			platforms: ["linux"]
+		},
+		{
+			path: "/Library/Application Support/GeminiCli/settings.json",
+			scope: "system",
+			level: "official",
+			platforms: ["darwin"]
+		},
+		{
+			path: "%PROGRAMDATA%/gemini-cli/settings.json",
+			scope: "system",
+			level: "official",
+			platforms: ["win32"]
+		}
+	];
+	sessions = [{
+		path: "~/.gemini/history/<project-id>/",
+		scope: "data",
+		level: "official",
+		note: "Conversation history per project (project-id is a slug from projects.json)."
+	}, {
+		path: "~/.gemini/tmp/<project-id>/chats/",
+		scope: "data",
+		level: "official",
+		note: "Active chat session data."
+	}];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Settings files."
+	}, {
+		format: "JSON",
+		level: "official",
+		note: "Session and history records."
+	}];
+	instructions = [{
+		path: "GEMINI.md",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.gemini/GEMINI.md",
+		scope: "user",
+		level: "official",
+		note: "Global instruction/memory file."
+	}];
+	skills = [
+		{
+			path: ".gemini/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".agents/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "~/.gemini/skills/",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "~/.agents/skills/",
+			scope: "user",
+			level: "official"
+		}
+	];
+	commands = [{
+		path: ".gemini/commands/",
+		scope: "project",
+		level: "official",
+		note: "Custom commands in TOML format."
+	}, {
+		path: "~/.gemini/commands/",
+		scope: "user",
+		level: "official",
+		note: "Global custom commands in TOML format."
+	}];
+	hooks = [];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"{prompt}",
+			"--output-format",
+			"json"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Non-interactive (headless) mode."
+	};
+	mcpConfigs = [{
+		path: "~/.gemini/settings.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}, {
+		path: ".gemini/settings.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}];
+	agentsFile = "~/.gemini/GEMINI.md";
+	detection = {
+		envVars: ["GEMINI_CLI"],
+		projectMarkers: [".gemini", "GEMINI.md"]
+	};
+};
+var GitHubCopilot = class extends Harness {
+	id = "github-copilot";
+	name = "GitHub Copilot";
+	binaries = [];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.copilot/config.json",
+		scope: "user",
+		level: "inferred"
+	}];
+	sessions = [];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Configuration files."
+	}];
+	instructions = [{
+		path: ".github/copilot-instructions.md",
+		scope: "project",
+		level: "official"
+	}, {
+		path: ".github/instructions/",
+		scope: "project",
+		level: "official",
+		note: "Modular instructions in .instructions.md files."
+	}];
+	skills = [{
+		path: ".github/skills/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: ".claude/skills/",
+		scope: "project",
+		level: "official",
+		note: "Copilot auto-detects Claude skills directory."
+	}];
+	commands = [];
+	hooks = [];
+	invocation = {
+		binary: "copilot",
+		args: ["-p", "{prompt}"],
+		level: "community",
+		note: "GitHub Copilot CLI, separate from the editor integration."
+	};
+	mcpConfigs = [{
+		path: ".vscode/mcp.json",
+		scope: "project",
+		level: "community",
+		format: "json",
+		key: ["servers"],
+		dialect: "vscode"
+	}];
+	detection = {
+		envVars: ["COPILOT_RUN_APP"],
+		projectMarkers: [
+			".github/copilot-instructions.md",
+			".github/skills",
+			".github/instructions"
+		]
+	};
+};
+var Grok = class extends Harness {
+	id = "grok";
+	name = "xAI Grok CLI";
+	binaries = ["grok"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.grok/config.toml",
+		scope: "user",
+		level: "official",
+		note: "Base directory overridable with GROK_HOME."
+	}, {
+		path: ".grok/config.toml",
+		scope: "project",
+		level: "official"
+	}];
+	sessions = [{
+		path: "~/.grok/sessions/<encoded-cwd>/<session-id>/updates.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Authoritative ACP session update stream (conversation + tool calls); session dirs also hold chat_history.jsonl, summary.json, rewind_points.jsonl."
+	}, {
+		path: "~/.grok/sessions/<encoded-cwd>/prompt_history.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Per-project prompt history."
+	}];
+	persistence = [
+		{
+			format: "TOML",
+			level: "official",
+			note: "Configuration files."
+		},
+		{
+			format: "JSONL",
+			level: "official",
+			note: "Session update streams, chat history, prompt history."
+		},
+		{
+			format: "JSON",
+			level: "official",
+			note: "Session state files (summary.json, plan.json, signals.json)."
+		},
+		{
+			format: "SQLite",
+			level: "official",
+			note: "Local FTS5 index over session titles and prompts for sessions search."
+		}
+	];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Also accepts Agents.md, AGENT.md, Claude.md, CLAUDE.md, CLAUDE.local.md; every matching file in a directory is loaded."
+		},
+		{
+			path: ".grok/rules/",
+			scope: "project",
+			level: "official",
+			note: "*.md rules scanned at each level from repo root to cwd; .claude/rules/ and .cursor/rules/ scanned via vendor compatibility."
+		},
+		{
+			path: "~/.grok/rules/",
+			scope: "user",
+			level: "official",
+			note: "Global user-level rules."
+		}
+	];
+	skills = [{
+		path: ".grok/skills/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.grok/skills/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level skills."
+	}];
+	commands = [{
+		path: ".grok/commands/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.grok/commands/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level slash commands."
+	}];
+	hooks = [{
+		path: ".grok/hooks/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.grok/hooks/",
+		scope: "user",
+		level: "official",
+		note: "JSON hook definitions (e.g. session-start.json); Claude/Cursor hook sources scanned via vendor compatibility."
+	}];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"{prompt}",
+			"--output-format",
+			"json"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "-p is short for --single; add --output-format json for structured output."
+	};
+	mcpConfigs = [{
+		path: "~/.grok/config.toml",
+		scope: "user",
+		level: "official",
+		format: "toml",
+		key: ["mcp_servers"],
+		dialect: "standard",
+		note: "grok mcp add/remove manage this file; Claude and Cursor configs are also scanned via vendor compatibility."
+	}, {
+		path: ".grok/config.toml",
+		scope: "project",
+		level: "official",
+		format: "toml",
+		key: ["mcp_servers"],
+		dialect: "standard"
+	}];
+	detection = {
+		envVars: [
+			"GROK_SESSION_ID",
+			"GROK_WORKSPACE_ROOT",
+			"GROK_HOME"
+		],
+		projectMarkers: [".grok"]
+	};
+};
+var MastraCode = class extends Harness {
+	id = "mastracode";
+	name = "Mastra Code";
+	binaries = ["mastracode"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: ".mastracode/mcp.json",
+			scope: "project",
+			level: "official",
+			note: "Project-scoped MCP server configurations."
+		},
+		{
+			path: "~/.mastracode/mcp.json",
+			scope: "user",
+			level: "official",
+			note: "Global MCP server configurations."
+		},
+		{
+			path: ".mastracode/hooks.json",
+			scope: "project",
+			level: "official",
+			note: "Project-scoped hooks."
+		},
+		{
+			path: "~/.mastracode/hooks.json",
+			scope: "user",
+			level: "official",
+			note: "Global hooks."
+		}
+	];
+	sessions = [{
+		path: "~/.local/share/mastracode/mastra.db",
+		scope: "data",
+		level: "official",
+		platforms: ["linux"],
+		note: "LibSQL database with threads, messages, and observational memory."
+	}];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "MCP and hooks config files."
+	}, {
+		format: "SQLite",
+		level: "official",
+		note: "LibSQL database for threads, messages, and observational memory."
+	}];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "CLAUDE.md",
+			scope: "project",
+			level: "official",
+			note: "Supported for Claude Code compatibility."
+		},
+		{
+			path: ".claude/CLAUDE.md",
+			scope: "project",
+			level: "official",
+			note: "Claude Code compatible."
+		},
+		{
+			path: ".mastracode/AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Alternative project-level location."
+		},
+		{
+			path: "~/.claude/CLAUDE.md",
+			scope: "user",
+			level: "official",
+			note: "Claude Code compatible."
+		},
+		{
+			path: "~/.mastracode/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		}
+	];
+	skills = [
+		{
+			path: ".mastracode/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "~/.mastracode/skills/",
+			scope: "user",
+			level: "official",
+			note: "Global user-level skills."
+		},
+		{
+			path: ".claude/skills/",
+			scope: "project",
+			level: "official",
+			note: "Claude Code compatible."
+		},
+		{
+			path: "~/.claude/skills/",
+			scope: "user",
+			level: "official",
+			note: "Claude Code compatible."
+		}
+	];
+	commands = [{
+		path: ".mastracode/commands/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.mastracode/commands/",
+		scope: "user",
+		level: "official",
+		note: "Global commands."
+	}];
+	hooks = [{
+		path: ".mastracode/hooks.json",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.mastracode/hooks.json",
+		scope: "user",
+		level: "official",
+		note: "Global hooks."
+	}];
+	invocation = null;
+	detection = {
+		envVars: [],
+		projectMarkers: [".mastracode"]
+	};
+};
+var Omp = class extends Harness {
+	id = "omp";
+	name = "OMP (oh-my-pi)";
+	binaries = ["omp"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.omp/agent/config.yml",
+			scope: "user",
+			level: "official",
+			note: "Agent dir overridable with PI_CODING_AGENT_DIR; profiles use ~/.omp/profiles/<name>/agent."
+		},
+		{
+			path: "~/.omp/agent/settings.json",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "~/.omp/agent/mcp.json",
+			scope: "user",
+			level: "official",
+			note: "MCP server configurations."
+		},
+		{
+			path: ".omp/config.yml",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".omp/settings.json",
+			scope: "project",
+			level: "official"
+		}
+	];
+	sessions = [
+		{
+			path: "~/.omp/agent/sessions/<dash-encoded-cwd>/<timestamp>_<session-id>.jsonl",
+			scope: "data",
+			level: "official",
+			note: "Per-project session transcripts in JSONL format; session ids are UUIDv7."
+		},
+		{
+			path: "~/.omp/agent/history.db",
+			scope: "data",
+			level: "official",
+			note: "SQLite prompt history."
+		},
+		{
+			path: "~/.omp/agent/agent.db",
+			scope: "data",
+			level: "official",
+			note: "SQLite agent state database."
+		}
+	];
+	persistence = [
+		{
+			format: "YAML",
+			level: "official",
+			note: "config.yml configuration files."
+		},
+		{
+			format: "JSON",
+			level: "official",
+			note: "settings.json and mcp.json."
+		},
+		{
+			format: "JSONL",
+			level: "official",
+			note: "Session transcripts."
+		},
+		{
+			format: "SQLite",
+			level: "official",
+			note: "Agent state, prompt history, model catalog (agent.db, history.db, models.db)."
+		}
+	];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Discovered by walking up from cwd; CLAUDE.md and other vendor files loaded via compatibility providers (claude, codex, gemini, cursor, opencode, and more)."
+		},
+		{
+			path: ".omp/AGENTS.md",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".omp/RULES.md",
+			scope: "project",
+			level: "official",
+			note: "Sticky always-apply rules."
+		},
+		{
+			path: "~/.omp/agent/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		},
+		{
+			path: "~/.omp/agent/RULES.md",
+			scope: "user",
+			level: "official",
+			note: "Global sticky always-apply rules."
+		},
+		{
+			path: "~/.omp/agent/PERSONALITY.md",
+			scope: "user",
+			level: "official",
+			note: "Overrides the system prompt's personality block; replaces the configured personality preset."
+		}
+	];
+	skills = [
+		{
+			path: ".omp/skills/",
+			scope: "project",
+			level: "official",
+			note: "Scanned in ancestor directories from cwd, closest first."
+		},
+		{
+			path: "~/.omp/agent/skills/",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "~/.omp/agent/managed-skills/",
+			scope: "user",
+			level: "official",
+			note: "Auto-generated managed skills."
+		}
+	];
+	commands = [{
+		path: ".omp/commands/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.omp/agent/commands/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level prompt commands."
+	}];
+	hooks = [];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		noToolsArgs: [
+			"-p",
+			"--no-tools",
+			"{prompt}"
+		],
+		noToolsJsonArgs: [
+			"-p",
+			"--no-tools",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		modelArgs: ["--model={model}"],
+		level: "official",
+		note: "Add --mode json for structured event output."
+	};
+	mcpConfigs = [{
+		path: "~/.omp/agent/mcp.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}, {
+		path: ".omp/mcp.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "standard"
+	}];
+	agentsFile = "~/.omp/agent/AGENTS.md";
+	detection = {
+		envVars: ["OMP_PROFILE", "PI_CODING_AGENT_DIR"],
+		projectMarkers: [".omp"]
+	};
+};
+var OpenCode = class extends Harness {
+	id = "opencode";
+	name = "OpenCode CLI";
+	binaries = ["opencode"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [
+		{
+			path: "~/.config/opencode/opencode.jsonc",
+			scope: "user",
+			level: "official",
+			note: "XDG-based, same path on all platforms."
+		},
+		{
+			path: "~/.config/opencode/opencode.json",
+			scope: "user",
+			level: "official"
+		},
+		{
+			path: "opencode.jsonc",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "opencode.json",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".opencode/opencode.jsonc",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".opencode/opencode.json",
+			scope: "project",
+			level: "official"
+		}
+	];
+	sessions = [{
+		path: "~/.local/share/opencode/opencode.db",
+		scope: "data",
+		level: "official",
+		note: "SQLite database with sessions, messages, and parts. XDG-based, same path on all platforms."
+	}];
+	persistence = [{
+		format: "JSON/JSONC",
+		level: "official",
+		note: "Config files."
+	}, {
+		format: "SQLite",
+		level: "official",
+		note: "Session and message storage via Drizzle ORM."
+	}];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "CLAUDE.md",
+			scope: "project",
+			level: "official",
+			note: "Supported for Claude Code compatibility."
+		},
+		{
+			path: "~/.config/opencode/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		}
+	];
+	skills = [
+		{
+			path: ".opencode/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".claude/skills/",
+			scope: "project",
+			level: "official",
+			note: "Claude Code compatible."
+		},
+		{
+			path: ".agents/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: "~/.claude/skills/",
+			scope: "user",
+			level: "official",
+			note: "Claude Code compatible."
+		},
+		{
+			path: "~/.agents/skills/",
+			scope: "user",
+			level: "official"
+		}
+	];
+	commands = [];
+	hooks = [];
+	invocation = {
+		args: ["run", "{prompt}"],
+		jsonArgs: [
+			"run",
+			"--format",
+			"json",
+			"{prompt}"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official"
+	};
+	mcpConfigs = [{
+		path: "~/.config/opencode/opencode.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcp"],
+		dialect: "opencode"
+	}, {
+		path: "opencode.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcp"],
+		dialect: "opencode"
+	}];
+	agentsFile = "~/.config/opencode/AGENTS.md";
+	detection = {
+		envVars: [],
+		projectMarkers: [
+			".opencode",
+			"opencode.jsonc",
+			"opencode.json"
+		]
+	};
+};
+const MODEL_HEADERS = [
+	"provider",
+	"model",
+	"context",
+	"max-out",
+	"thinking",
+	"images"
+];
+function parseTokenCount(value) {
+	const match = /^(\d+(?:\.\d+)?)([KM])?$/.exec(value);
+	if (!match?.[1]) throw new Error(`Invalid Pi token count: ${JSON.stringify(value)}`);
+	const multiplier = match[2] === "M" ? 1e6 : match[2] === "K" ? 1e3 : 1;
+	return Number(match[1]) * multiplier;
+}
+function parseBoolean(value, column) {
+	if (value === "yes") return true;
+	if (value === "no") return false;
+	throw new Error(`Invalid Pi ${column} value: ${JSON.stringify(value)}`);
+}
+var Pi = class extends Harness {
+	id = "pi";
+	name = "Pi Coding Agent";
+	binaries = ["pi"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.pi/agent/settings.json",
+		scope: "user",
+		level: "official",
+		note: "Config dir overridable with PI_CODING_AGENT_DIR."
+	}, {
+		path: ".pi/settings.json",
+		scope: "project",
+		level: "official"
+	}];
+	sessions = [{
+		path: "~/.pi/agent/sessions/<dash-encoded-cwd>/<timestamp>_<session-id>.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Per-project session transcripts in JSONL format; session ids are UUIDv7. Overridable with PI_CODING_AGENT_SESSION_DIR or --session-dir."
+	}];
+	persistence = [{
+		format: "JSON",
+		level: "official",
+		note: "Settings, auth, trust, models, and keybindings files."
+	}, {
+		format: "JSONL",
+		level: "official",
+		note: "Session transcripts."
+	}];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Loaded from parent directories and cwd; CLAUDE.md accepted as an alternative, AGENTS.override.md takes precedence over both in a directory."
+		},
+		{
+			path: ".pi/SYSTEM.md",
+			scope: "project",
+			level: "official",
+			note: "Replaces the default system prompt; APPEND_SYSTEM.md appends instead."
+		},
+		{
+			path: "~/.pi/agent/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions."
+		},
+		{
+			path: "~/.pi/agent/SYSTEM.md",
+			scope: "user",
+			level: "official",
+			note: "Global system prompt replacement; APPEND_SYSTEM.md appends instead."
+		}
+	];
+	skills = [{
+		path: ".pi/skills/",
+		scope: "project",
+		level: "official"
+	}, {
+		path: "~/.pi/agent/skills/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level skills."
+	}];
+	commands = [{
+		path: ".pi/prompts/",
+		scope: "project",
+		level: "official",
+		note: "Prompt templates invoked as slash commands."
+	}, {
+		path: "~/.pi/agent/prompts/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level prompt templates."
+	}];
+	hooks = [];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		noToolsArgs: [
+			"-p",
+			"--no-tools",
+			"{prompt}"
+		],
+		noToolsJsonArgs: [
+			"-p",
+			"--no-tools",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Add --mode json for structured event output."
+	};
+	modelListing = {
+		args: ["--list-models"],
+		searchArgs: ["--list-models", "{search}"],
+		level: "official",
+		note: "Lists models with configured provider authentication; accepts an optional fuzzy search."
+	};
+	agentsFile = "~/.pi/agent/AGENTS.md";
+	detection = {
+		envVars: [
+			"PI_CODING_AGENT",
+			"PI_SESSION_ID",
+			"PI_SESSION_FILE"
+		],
+		projectMarkers: [".pi"]
+	};
+	parseModelListingOutput(stdout) {
+		const lines = stripVTControlCharacters(stdout).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+		const first = lines[0];
+		if (!first) throw new Error("Unexpected empty Pi model-list output");
+		if (first.startsWith("No models available.") || first.startsWith("No models matching ")) return [];
+		const headers = first.split(/\s{2,}/);
+		if (headers.length !== MODEL_HEADERS.length || headers.some((value, i) => value !== MODEL_HEADERS[i])) throw new Error(`Unexpected Pi model-list header: ${JSON.stringify(first)}`);
+		return lines.slice(1).map((line) => {
+			const columns = line.split(/\s{2,}/);
+			const [provider, id, context, maxOutput, thinking, images] = columns;
+			if (columns.length !== MODEL_HEADERS.length || !provider || !id || !context || !maxOutput || !thinking || !images) throw new Error(`Unexpected Pi model-list row: ${JSON.stringify(line)}`);
+			return {
+				provider,
+				id,
+				contextWindow: parseTokenCount(context),
+				maxOutputTokens: parseTokenCount(maxOutput),
+				thinking: parseBoolean(thinking, "thinking"),
+				images: parseBoolean(images, "images")
+			};
+		});
+	}
+};
+const harnesses = [
+	Antigravity,
+	Claude,
+	Codex,
+	Cursor,
+	Freebuff,
+	Gemini,
+	GitHubCopilot,
+	Grok,
+	MastraCode,
+	Omp,
+	OpenCode,
+	Pi
+];
+let registry;
+function getRegistry() {
+	if (!registry) {
+		registry = /* @__PURE__ */ new Map();
+		for (const HarnessClass of harnesses) {
+			const harness = new HarnessClass();
+			registry.set(harness.id, harness);
+		}
+	}
+	return registry;
+}
+function registerHarness(HarnessClass) {
+	const harness = new HarnessClass();
+	getRegistry().set(harness.id, harness);
+	return harness;
+}
+function getHarness(id) {
+	const harness = getRegistry().get(id);
+	if (!harness) throw new Error(`Unknown harness: ${id}`);
+	return harness;
+}
+function listHarnesses() {
+	return [...getRegistry().keys()];
+}
+function isHarnessId(id) {
+	return getRegistry().has(id);
+}
+function getAllHarnesses() {
+	return [...getRegistry().values()];
+}
+function detectHarnessFromEnv() {
+	for (const harness of getRegistry().values()) if (harness.detectEnv()) return harness;
+	return null;
+}
+function detectProjectHarnesses(cwd) {
+	return [...getRegistry().values()].filter((harness) => harness.detectProject(cwd));
+}
+function detectHarness(cwd) {
+	const fromEnv = detectHarnessFromEnv();
+	if (fromEnv) return fromEnv;
+	let match = null;
+	for (const harness of getRegistry().values()) if (harness.detectProject(cwd)) {
+		if (match) return null;
+		match = harness;
+	}
+	return match;
+}
+function resolveConfigs(harness, options) {
+	return harness.resolveCandidates(harness.mcpConfigs, options).map((entry) => ({
+		entry,
+		path: isAbsolute(entry.path) ? entry.path : join(options.projectRoot ?? process.cwd(), entry.path)
+	}));
+}
+function readIfExists$1(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function drill(root, key, create) {
+	let node = root;
+	for (const part of key) {
+		if (typeof node !== "object" || node === null) return void 0;
+		const record = node;
+		if (create && (typeof record[part] !== "object" || record[part] === null)) record[part] = {};
+		node = record[part];
+	}
+	return typeof node === "object" && node !== null ? node : void 0;
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function asStringRecord(value) {
+	if (!isObjectRecord(value) || Array.isArray(value)) return void 0;
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function asStringArray(value) {
+	if (!Array.isArray(value)) return void 0;
+	return value.filter((item) => typeof item === "string");
+}
+function compact(source) {
+	return Object.fromEntries(Object.entries(source).filter(([, value]) => value !== void 0));
+}
+function stringField(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+function booleanField(record, key) {
+	const value = record[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function normalizeAntigravity(name, raw) {
+	const url = stringField(raw, "serverUrl");
+	return compact({
+		name,
+		transport: url ? "sse" : "stdio",
+		command: stringField(raw, "command"),
+		args: asStringArray(raw.args),
+		env: asStringRecord(raw.env),
+		url
+	});
+}
+function normalizeOpenCode(name, raw) {
+	const command = asStringArray(raw.command) ?? [];
+	const url = stringField(raw, "url");
+	return compact({
+		name,
+		transport: raw.type === "remote" || url ? "http" : "stdio",
+		command: command[0],
+		args: command.length > 1 ? command.slice(1) : void 0,
+		env: asStringRecord(raw.environment),
+		url,
+		headers: asStringRecord(raw.headers),
+		enabled: booleanField(raw, "enabled")
+	});
+}
+function standardUrl(raw) {
+	return stringField(raw, "httpUrl") ?? stringField(raw, "url");
+}
+function standardTransport(declared, url) {
+	if (declared === "sse") return "sse";
+	if (declared === "http" || url) return "http";
+	return "stdio";
+}
+function normalizeStandard(name, raw) {
+	const url = standardUrl(raw);
+	return compact({
+		name,
+		transport: standardTransport(stringField(raw, "type"), url),
+		command: stringField(raw, "command"),
+		args: asStringArray(raw.args),
+		env: asStringRecord(raw.env),
+		url,
+		headers: asStringRecord(raw.headers),
+		enabled: booleanField(raw, "enabled")
+	});
+}
+function normalizeEntry(name, raw, dialect) {
+	if (dialect === "antigravity") return normalizeAntigravity(name, raw);
+	if (dialect === "opencode") return normalizeOpenCode(name, raw);
+	return normalizeStandard(name, raw);
+}
+function denormalizeAntigravity(server) {
+	if (server.url) return { serverUrl: server.url };
+	return compact({
+		command: server.command,
+		args: server.args?.length ? server.args : void 0,
+		env: server.env
+	});
+}
+function denormalizeOpenCode(server) {
+	if (server.url) return compact({
+		type: "remote",
+		url: server.url,
+		headers: server.headers,
+		enabled: server.enabled
+	});
+	return compact({
+		type: "local",
+		command: [server.command ?? "", ...server.args ?? []],
+		environment: server.env,
+		enabled: server.enabled
+	});
+}
+function denormalizeStandard(server) {
+	return compact({
+		type: server.transport,
+		command: server.command,
+		args: server.args?.length ? server.args : void 0,
+		env: server.env,
+		url: server.url,
+		headers: server.headers,
+		enabled: server.enabled
+	});
+}
+function denormalizeEntry(server, dialect) {
+	if (dialect === "antigravity") return denormalizeAntigravity(server);
+	if (dialect === "opencode") return denormalizeOpenCode(server);
+	return denormalizeStandard(server);
+}
+function listingBase(entry, path) {
+	return compact({
+		path,
+		scope: entry.scope,
+		format: entry.format,
+		level: entry.level,
+		note: entry.note,
+		exists: false,
+		servers: []
+	});
+}
+function configServerMap(raw, entry) {
+	const parsed = entry.format === "toml" ? parse(raw) : JSON.parse(raw);
+	return drill(isObjectRecord(parsed) ? parsed : {}, entry.key) ?? {};
+}
+function normalizeServerMap(map, dialect) {
+	const servers = [];
+	for (const [name, rawEntry] of Object.entries(map)) if (isObjectRecord(rawEntry)) servers.push(normalizeEntry(name, rawEntry, dialect));
+	return servers;
+}
+function listMcpConfig(entry, path) {
+	const base = listingBase(entry, path);
+	try {
+		const raw = readIfExists$1(path);
+		if (raw === null) return base;
+		const servers = normalizeServerMap(configServerMap(raw, entry), entry.dialect);
+		return {
+			...base,
+			exists: true,
+			servers
+		};
+	} catch (error) {
+		return {
+			...base,
+			exists: true,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function listMcpServers(harness, options = {}) {
+	return resolveConfigs(harness, options).map(({ entry, path }) => listMcpConfig(entry, path));
+}
+function writableConfig(harness, scope, options) {
+	const config = resolveConfigs(harness, options).find(({ entry }) => entry.scope === scope);
+	if (!config) throw new Error(`Harness ${harness.id} has no ${scope}-scope MCP config`);
+	return config;
+}
+function writeAtomically(path, content) {
+	mkdirSync(dirname(path), { recursive: true });
+	const temp = join(dirname(path), `.${Date.now()}-${process.pid}.mcp.tmp`);
+	writeFileSync(temp, content);
+	renameSync(temp, path);
+}
+function escapeRegExp(value) {
+	return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function tomlValue(value) {
+	return JSON.stringify(value);
+}
+function tomlKeyPart(name) {
+	return /^[A-Za-z0-9_-]+$/.test(name) ? name : JSON.stringify(name);
+}
+function tomlSections(key, server) {
+	const head = [...key, server.name].map(tomlKeyPart).join(".");
+	const lines = [`[${head}]`];
+	if (server.command) lines.push(`command = ${tomlValue(server.command)}`);
+	if (server.args?.length) lines.push(`args = [${server.args.map(tomlValue).join(", ")}]`);
+	if (server.url) lines.push(`url = ${tomlValue(server.url)}`);
+	if (server.enabled !== void 0) lines.push(`enabled = ${server.enabled}`);
+	for (const [subKey, record] of [["env", server.env], ["headers", server.headers]]) {
+		if (!record) continue;
+		lines.push("", `[${head}.${subKey}]`);
+		for (const [k, v] of Object.entries(record)) lines.push(`${tomlKeyPart(k)} = ${tomlValue(v)}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+function stripTomlServer(raw, key, name) {
+	const prefix = escapeRegExp(key.map(tomlKeyPart).join("."));
+	const namePart = `(?:${escapeRegExp(tomlKeyPart(name))}|${escapeRegExp(JSON.stringify(name))})`;
+	const sectionRe = new RegExp(`^\\s*\\[${prefix}\\.${namePart}(\\.[^\\]]+)?\\]`);
+	const bareTableRe = new RegExp(`^\\s*\\[${prefix}\\]\\s*(#.*)?$`);
+	const anyHeaderRe = /^\s*\[/;
+	const inlineRe = new RegExp(`^\\s*${namePart}\\s*=`);
+	const kept = [];
+	let inTargetSection = false;
+	let inBareTable = false;
+	for (const line of raw.split("\n")) {
+		if (anyHeaderRe.test(line)) {
+			inTargetSection = sectionRe.test(line);
+			inBareTable = bareTableRe.test(line);
+		} else if (inBareTable && inlineRe.test(line)) continue;
+		if (inTargetSection) continue;
+		kept.push(line);
+	}
+	return kept.join("\n");
+}
+function serverMapFromToml(raw, key) {
+	return drill(parse(raw), key) ?? {};
+}
+function assertTomlEdit(beforeMap, after, key, name, shouldExist) {
+	let afterMap;
+	try {
+		afterMap = serverMapFromToml(after, key);
+	} catch (error) {
+		throw new Error(`TOML edit produced an unparsable file, aborting: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (Object.hasOwn(afterMap, name) !== shouldExist) throw new Error(`TOML edit did not leave server ${name} ${shouldExist ? "present" : "absent"}, aborting`);
+	for (const other of /* @__PURE__ */ new Set([...Object.keys(beforeMap), ...Object.keys(afterMap)])) {
+		if (other === name) continue;
+		if (JSON.stringify(beforeMap[other]) !== JSON.stringify(afterMap[other])) throw new Error(`TOML edit touched servers other than ${name}, aborting`);
+	}
+}
+function addTomlServer(path, key, server) {
+	const before = readIfExists$1(path) ?? "";
+	const beforeMap = serverMapFromToml(before, key);
+	const replaced = Object.hasOwn(beforeMap, server.name);
+	const body = (replaced ? stripTomlServer(before, key, server.name) : before).replace(/\s+$/, "");
+	const after = body ? `${body}\n\n${tomlSections(key, server)}` : tomlSections(key, server);
+	assertTomlEdit(beforeMap, after, key, server.name, true);
+	writeAtomically(path, after);
+	return replaced;
+}
+function removeTomlServer(path, key, name) {
+	const before = readIfExists$1(path);
+	if (before === null) return false;
+	const beforeMap = serverMapFromToml(before, key);
+	if (!Object.hasOwn(beforeMap, name)) return false;
+	const after = stripTomlServer(before, key, name);
+	assertTomlEdit(beforeMap, after, key, name, false);
+	writeAtomically(path, after);
+	return true;
+}
+function addMcpServer(harness, server, scope = "user", options = {}) {
+	const { entry, path } = writableConfig(harness, scope, options);
+	if (entry.format === "toml") return {
+		path,
+		replaced: addTomlServer(path, entry.key, server)
+	};
+	const root = JSON.parse(readIfExists$1(path) ?? "{}");
+	const map = drill(root, entry.key, "create");
+	if (!map) throw new Error(`Config at ${path} has a non-object at ${entry.key.join(".")}`);
+	const replaced = Object.hasOwn(map, server.name);
+	map[server.name] = denormalizeEntry(server, entry.dialect);
+	writeAtomically(path, `${JSON.stringify(root, null, 2)}\n`);
+	return {
+		path,
+		replaced
+	};
+}
+function removeMcpServer(harness, name, scope = "user", options = {}) {
+	const { entry, path } = writableConfig(harness, scope, options);
+	if (entry.format === "toml") return {
+		path,
+		removed: removeTomlServer(path, entry.key, name)
+	};
+	const raw = readIfExists$1(path);
+	if (raw === null) return {
+		path,
+		removed: false
+	};
+	const root = JSON.parse(raw);
+	const map = drill(root, entry.key);
+	if (!map || !Object.hasOwn(map, name)) return {
+		path,
+		removed: false
+	};
+	delete map[name];
+	writeAtomically(path, `${JSON.stringify(root, null, 2)}\n`);
+	return {
+		path,
+		removed: true
+	};
+}
+function trailingJsoncComma(text, index) {
+	const significant = text.slice(index + 1).replaceAll(/\/\/[^\n]*|\/\*[\s\S]*?\*\/|\s+/g, "");
+	return significant.startsWith("}") || significant.startsWith("]");
+}
+function scanJsoncCode(context) {
+	const { character, next } = context;
+	if (character === "\"") return {
+		state: "string",
+		output: character,
+		advance: 0
+	};
+	if (character === "/" && next === "/") return {
+		state: "line-comment",
+		output: "",
+		advance: 1
+	};
+	if (character === "/" && next === "*") return {
+		state: "block-comment",
+		output: "",
+		advance: 1
+	};
+	if (character === "," && trailingJsoncComma(context.text, context.index)) return {
+		state: "code",
+		output: "",
+		advance: 0
+	};
+	return {
+		state: "code",
+		output: character,
+		advance: 0
+	};
+}
+function scanJsoncString({ character }) {
+	if (character === "\\") return {
+		state: "escape",
+		output: character,
+		advance: 0
+	};
+	if (character === "\"") return {
+		state: "code",
+		output: character,
+		advance: 0
+	};
+	return {
+		state: "string",
+		output: character,
+		advance: 0
+	};
+}
+function scanJsoncEscape({ character }) {
+	return {
+		state: "string",
+		output: character,
+		advance: 0
+	};
+}
+function scanJsoncLineComment({ character }) {
+	if (character === "\n") return {
+		state: "code",
+		output: character,
+		advance: 0
+	};
+	return {
+		state: "line-comment",
+		output: "",
+		advance: 0
+	};
+}
+function scanJsoncBlockComment({ character, next }) {
+	if (character === "*" && next === "/") return {
+		state: "code",
+		output: "",
+		advance: 1
+	};
+	return {
+		state: "block-comment",
+		output: "",
+		advance: 0
+	};
+}
+const JSONC_SCANNERS = {
+	code: scanJsoncCode,
+	string: scanJsoncString,
+	escape: scanJsoncEscape,
+	"line-comment": scanJsoncLineComment,
+	"block-comment": scanJsoncBlockComment
+};
+function parseJsonc(text) {
+	let out = "";
+	let state = "code";
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		const step = JSONC_SCANNERS[state]({
+			text,
+			index,
+			character,
+			next: text[index + 1]
+		});
+		out += step.output;
+		state = step.state;
+		index += step.advance;
+	}
+	return JSON.parse(out);
+}
+function masterMcpPath(options = {}) {
+	return join(agntnConfigDir(options), "mcp.jsonc");
+}
+function canonical(server) {
+	return JSON.stringify(Object.fromEntries(Object.entries(server).sort(([a], [b]) => a.localeCompare(b))));
+}
+function expandHome(value, home) {
+	return value.replace(/^~(?=\/|$)/, home).replaceAll("${HOME}", home);
+}
+function expandServerHome(server, home) {
+	return compact({
+		...server,
+		command: server.command === void 0 ? void 0 : expandHome(server.command, home),
+		args: server.args?.map((arg) => expandHome(arg, home)),
+		env: server.env ? Object.fromEntries(Object.entries(server.env).map(([k, v]) => [k, expandHome(v, home)])) : void 0
+	});
+}
+function requiredMasterServerMap(root, path) {
+	const map = drill(root, ["mcpServers"]);
+	if (!map) throw new Error(`Master MCP list at ${path} has no mcpServers object`);
+	return map;
+}
+function normalizeMasterServers(map, home) {
+	const servers = [];
+	for (const [name, rawEntry] of Object.entries(map)) if (isObjectRecord(rawEntry)) servers.push(expandServerHome(normalizeEntry(name, rawEntry, "standard"), home));
+	return servers;
+}
+function masterExcludes(value, path) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`Master MCP list at ${path} has an invalid excludes: expected an array of harness ids`);
+	return value;
+}
+function readMasterMcpServers(options = {}) {
+	const path = masterMcpPath(options);
+	const raw = readIfExists$1(path);
+	if (raw === null) throw new Error(`No master MCP list at ${path}`);
+	const parsed = parseJsonc(raw);
+	const root = isObjectRecord(parsed) ? parsed : {};
+	return {
+		path,
+		servers: normalizeMasterServers(requiredMasterServerMap(root, path), options.homeDir ?? homedir()),
+		excludes: masterExcludes(root.excludes, path)
+	};
+}
+function optionalPath(path) {
+	return path === void 0 ? {} : { path };
+}
+function existingServers(listing) {
+	return new Map((listing?.servers ?? []).map((server) => [server.name, canonical(server)]));
+}
+function withdrawMasterServersFromExcludedHarness(harness, existing, masterNames, initialPath, options) {
+	const results = [];
+	let path = initialPath;
+	for (const name of existing.keys()) {
+		if (!masterNames.has(name)) continue;
+		const removed = removeMcpServer(harness, name, "user", options);
+		if (removed.removed) {
+			path = removed.path;
+			results.push({
+				name,
+				action: "removed"
+			});
+		}
+	}
+	return {
+		id: harness.id,
+		...optionalPath(path),
+		excluded: true,
+		results
+	};
+}
+function syncIncludedHarness(harness, master, existing, masterNames, initialPath, options) {
+	const results = [];
+	let path = initialPath;
+	for (const server of master.servers) {
+		if (existing.get(server.name) === canonical(server)) {
+			results.push({
+				name: server.name,
+				action: "unchanged"
+			});
+			continue;
+		}
+		const written = addMcpServer(harness, server, "user", options);
+		path = written.path;
+		results.push({
+			name: server.name,
+			action: written.replaced ? "replaced" : "added"
+		});
+	}
+	for (const name of existing.keys()) {
+		if (masterNames.has(name)) continue;
+		const removed = removeMcpServer(harness, name, "user", options);
+		if (removed.removed) {
+			path = removed.path;
+			results.push({
+				name,
+				action: "removed"
+			});
+		}
+	}
+	return {
+		id: harness.id,
+		...optionalPath(path),
+		results
+	};
+}
+function syncMcpTarget(harness, master, masterNames, options) {
+	if (!harness.mcpConfigs.some((candidate) => candidate.scope === "user")) return {
+		id: harness.id,
+		skipped: "no user-scope MCP config",
+		results: []
+	};
+	const listing = listMcpServers(harness, options).find((item) => item.scope === "user");
+	if (listing?.error) return {
+		id: harness.id,
+		path: listing.path,
+		skipped: `existing config is unreadable: ${listing.error}`,
+		results: []
+	};
+	const existing = existingServers(listing);
+	if (master.excludes.includes(harness.id)) return withdrawMasterServersFromExcludedHarness(harness, existing, masterNames, listing?.path, options);
+	return syncIncludedHarness(harness, master, existing, masterNames, listing?.path, options);
+}
+function syncMcpServers(harnesses, options = {}) {
+	const master = readMasterMcpServers(options);
+	const masterNames = new Set(master.servers.map((server) => server.name));
+	return {
+		source: master.path,
+		servers: master.servers.map((server) => server.name),
+		targets: harnesses.map((harness) => syncMcpTarget(harness, master, masterNames, options))
+	};
+}
+function readIfExists(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function agentsConfigRecord(raw, configPath) {
+	const parsed = parseJsonc(raw);
+	if (typeof parsed !== "object" || parsed === null) throw new Error(`Agents config at ${configPath} is not an object`);
+	return parsed;
+}
+function agentsSource(value, defaultSource, options) {
+	if (typeof value !== "string") return defaultSource;
+	const expanded = resolvePathTemplate(value, options);
+	return isAbsolute(expanded) ? expanded : join(agntnConfigDir(options), expanded);
+}
+function agentsExcludes(value, configPath) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`Agents config at ${configPath} has an invalid excludes: expected an array of harness ids`);
+	return value;
+}
+function companionPath(value, configPath) {
+	const normalized = normalize(value);
+	if (normalized === "." || normalized === ".." || normalized.startsWith(`..${sep}`) || isAbsolute(normalized)) throw new Error(`Agents config at ${configPath} has an unsafe companion path: ${JSON.stringify(normalized)}`);
+	return normalized.endsWith(sep) ? normalized.slice(0, -sep.length) : normalized;
+}
+function comparablePath(path) {
+	return resolve(path).toLowerCase();
+}
+function agentsCompanions(value, configPath) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`Agents config at ${configPath} has invalid companions: expected an array of relative paths`);
+	const companions = value.map((path) => companionPath(path, configPath));
+	const comparable = companions.map(comparablePath);
+	if (new Set(comparable).size !== comparable.length) throw new Error(`Agents config at ${configPath} has duplicate companion paths`);
+	return companions;
+}
+function readAgentsConfig(options = {}) {
+	const configPath = join(agntnConfigDir(options), "agents.jsonc");
+	const defaults = {
+		source: join(agntnConfigDir(options), "AGENTS.md"),
+		companions: [],
+		excludes: []
+	};
+	const raw = readIfExists(configPath);
+	if (raw === null) return defaults;
+	const record = agentsConfigRecord(raw, configPath);
+	return {
+		source: agentsSource(record.source, defaults.source, options),
+		companions: agentsCompanions(record.companions, configPath),
+		excludes: agentsExcludes(record.excludes, configPath),
+		configPath
+	};
+}
+function inspectRegularFile(path, source) {
+	const content = readIfExists(path) ?? "";
+	const sourceContent = readIfExists(source) ?? "";
+	if (content.trim() === "" || content === sourceContent) return { kind: "identical-file" };
+	return { kind: "diverged-file" };
+}
+function inspectTarget(path, source) {
+	let stats;
+	try {
+		stats = lstatSync(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+	if (stats.isSymbolicLink()) {
+		const target = readlinkSync(path);
+		return (isAbsolute(target) ? target : resolve(dirname(path), target)) === source ? { kind: "correct-link" } : { kind: "wrong-link" };
+	}
+	return inspectRegularFile(path, source);
+}
+function relink(path, source) {
+	mkdirSync(dirname(path), { recursive: true });
+	const temp = join(dirname(path), `.${Date.now()}-${process.pid}.agents.tmp`);
+	symlinkSync(source, temp);
+	renameSync(temp, path);
+}
+const CHECK_ACTION = {
+	missing: "linked",
+	"correct-link": "unchanged",
+	"wrong-link": "relinked",
+	"identical-file": "relinked",
+	"diverged-file": "adopted"
+};
+function applyFileTarget(id, path, source, state, options) {
+	if (state.kind === "diverged-file") {
+		const backupDir = join(agntnConfigDir(options), "diverged");
+		mkdirSync(backupDir, { recursive: true });
+		const backup = join(backupDir, `${id}-${basename(path)}-${Date.now()}.md`);
+		renameSync(path, backup);
+		relink(path, source);
+		return {
+			path,
+			action: "adopted",
+			detail: backup
+		};
+	}
+	if (state.kind === "wrong-link") unlinkSync(path);
+	if (state.kind === "wrong-link" || state.kind === "identical-file") {
+		relink(path, source);
+		return {
+			path,
+			action: "relinked"
+		};
+	}
+	relink(path, source);
+	return {
+		path,
+		action: "linked"
+	};
+}
+function syncFileTarget(id, path, source, check, options) {
+	const state = inspectTarget(path, source);
+	if (state.kind === "correct-link") return {
+		path,
+		action: "unchanged"
+	};
+	if (check) return {
+		path,
+		action: CHECK_ACTION[state.kind],
+		detail: "check mode: not applied"
+	};
+	return applyFileTarget(id, path, source, state, options);
+}
+function syncTarget(harness, config, check, options) {
+	if (config.excludes.includes(harness.id)) return {
+		id: harness.id,
+		action: "skipped",
+		detail: "excluded by the agents config"
+	};
+	if (!harness.agentsFile) return {
+		id: harness.id,
+		action: "skipped",
+		detail: "no stable user-scope instructions file"
+	};
+	const path = resolvePathTemplate(harness.agentsFile, options);
+	const target = syncFileTarget(harness.id, path, config.source, check, options);
+	if (config.companions.length === 0) return {
+		id: harness.id,
+		...target
+	};
+	const companions = config.companions.map((relativePath) => {
+		const source = resolve(dirname(config.source), relativePath);
+		const companionPath = resolve(dirname(path), relativePath);
+		return {
+			source,
+			...syncFileTarget(harness.id, companionPath, source, check, options)
+		};
+	});
+	return {
+		id: harness.id,
+		...target,
+		companions
+	};
+}
+function preflightCompanions(harnesses, config, options) {
+	for (const relativePath of config.companions) {
+		const source = resolve(dirname(config.source), relativePath);
+		if (comparablePath(source) === comparablePath(config.source)) throw new Error(`Companion path resolves to the master agents file: ${relativePath}`);
+		if (readIfExists(source) === null) throw new Error(`No companion agents file at ${source}`);
+	}
+	for (const harness of harnesses) {
+		if (config.excludes.includes(harness.id) || !harness.agentsFile) continue;
+		const path = resolvePathTemplate(harness.agentsFile, options);
+		const collision = config.companions.find((relativePath) => comparablePath(resolve(dirname(path), relativePath)) === comparablePath(path));
+		if (collision !== void 0) throw new Error(`Companion path collides with ${harness.id} instructions: ${collision}`);
+	}
+}
+function syncAgentsFiles(harnesses, check = false, options = {}) {
+	const config = readAgentsConfig(options);
+	if (readIfExists(config.source) === null) throw new Error(`No master agents file at ${config.source}`);
+	preflightCompanions(harnesses, config, options);
+	return {
+		source: config.source,
+		check,
+		targets: harnesses.map((harness) => syncTarget(harness, config, check, options))
+	};
+}
+export { Harness, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers };
+
+//# sourceMappingURL=agents-sync.mjs.map