@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-D4_mJk03.js

@@ -0,0 +1,2338 @@
+#!/usr/bin/env node
+import { F as getCliVersion } from "./index.js";
+import { t as HARNESS_LIMITS } from "./chunk-0x7UKC1U.js";
+import { createRequire } from "node:module";
+import { constants } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { promisify } from "node:util";
+import { Readable, Writable } from "node:stream";
+import { access, chmod, copyFile, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { RequestError, client, methods, ndJsonStream } from "@agentclientprotocol/sdk";
+// src/lib/local-harness/backends/claude/observations.ts
+const object$2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+const number = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+const string$1 = (value) => typeof value === "string" ? value : void 0;
+const counters = [
+	"inputTokens",
+	"outputTokens",
+	"cacheReadInputTokens",
+	"cacheCreationInputTokens"
+];
+function reportedUsage$1(current, previous) {
+	const unknown = {
+		costUsd: null,
+		completeness: "partial",
+		scope: "claude_sdk_query"
+	};
+	if (!string$1(current.session_id) || !number(current.total_cost_usd) || current.subtype !== "success" && current.total_cost_usd === 0) return unknown;
+	if (previous && (previous.session_id !== current.session_id || previous.uuid === current.uuid || !number(previous.total_cost_usd) || current.total_cost_usd < previous.total_cost_usd)) return unknown;
+	let complete = true;
+	const models = [];
+	const nowModels = object$2(current.modelUsage);
+	const oldModels = object$2(previous?.modelUsage);
+	for (const [model, raw] of Object.entries(nowModels).slice(0, 100)) {
+		const now = object$2(raw);
+		const before = object$2(oldModels[model]);
+		const entry = {
+			model: model.slice(0, 200),
+			pricingBasis: now.costBasis === "list" || now.costBasis === "managed" ? now.costBasis : "unknown"
+		};
+		if (string$1(now.provider)) entry.provider = String(now.provider).slice(0, 100);
+		if (string$1(now.canonicalModel)) entry.canonicalModel = String(now.canonicalModel).slice(0, 200);
+		for (const field of [...counters, "costUSD"]) {
+			const amount = now[field];
+			const baseline = model in oldModels ? before[field] : 0;
+			if (number(amount) && number(baseline) && amount >= baseline && (field === "costUSD" || Number.isInteger(amount) && Number.isInteger(baseline))) entry[field === "costUSD" ? "costUsd" : field] = amount - baseline;
+			else complete = false;
+		}
+		models.push(entry);
+	}
+	if (Object.keys(nowModels).length > 100 || Object.keys(oldModels).some((model) => !(model in nowModels))) complete = false;
+	return {
+		costUsd: current.total_cost_usd - (number(previous?.total_cost_usd) ? previous.total_cost_usd : 0),
+		completeness: complete ? "complete" : "partial",
+		scope: "claude_sdk_query",
+		models
+	};
+}
+function createObserver$1(emit, servers) {
+	const tools = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		observe(raw) {
+			const message = object$2(raw);
+			const common = {
+				nativeId: string$1(message.uuid),
+				nativeSessionId: string$1(message.session_id),
+				nativeTurnId: string$1(message.user_message_uuid),
+				parentId: string$1(message.parent_tool_use_id)
+			};
+			emit({
+				...common,
+				kind: "native",
+				native: raw,
+				...message.type === "stream_event" ? { fragment: true } : {}
+			});
+			if (typeof message.uuid === "string") {
+				if (seen.has(message.uuid)) return;
+				seen.add(message.uuid);
+			}
+			const body = object$2(message.message);
+			const blocks = Array.isArray(body.content) ? body.content : [];
+			if (message.type === "assistant" || message.type === "user") {
+				emit({
+					...common,
+					kind: "message",
+					message: {
+						role: message.type,
+						content: body.content
+					}
+				});
+				for (const rawBlock of blocks) {
+					const block = object$2(rawBlock);
+					if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+						const prior = tools.get(block.id);
+						const server = [...servers].sort((a, b) => b.length - a.length).find((name) => String(block.name).startsWith(`mcp__${name}__`));
+						const tool = {
+							...prior,
+							id: block.id,
+							name: block.name,
+							nativeName: block.name,
+							input: block.input,
+							status: prior?.status === "failed" ? "failed" : "running",
+							startedAt: prior?.startedAt ?? Date.now(),
+							...server ? {
+								mcpServer: server,
+								mcpTool: block.name.slice(`mcp__${server}__`.length)
+							} : {}
+						};
+						tools.set(block.id, tool);
+						emit({
+							...common,
+							kind: "tool",
+							tool: { ...tool }
+						});
+					}
+					if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+						const prior = tools.get(block.tool_use_id);
+						const structured = blocks.filter((value) => object$2(value).type === "tool_result").length === 1 ? message.tool_use_result : void 0;
+						const failed = prior?.status === "failed" || block.is_error === true;
+						const detached = object$2(structured).detachedToolCall === true;
+						const tool = {
+							...prior,
+							id: block.tool_use_id,
+							output: structured === void 0 ? block.content : {
+								content: block.content,
+								structured
+							},
+							status: failed ? "failed" : detached ? "running" : "succeeded",
+							...!detached || failed ? { endedAt: Date.now() } : {},
+							...block.is_error === true ? { error: block.content } : {}
+						};
+						tools.set(block.tool_use_id, tool);
+						emit({
+							...common,
+							kind: "tool",
+							tool: { ...tool }
+						});
+					}
+				}
+			}
+			if (message.type === "stream_event") {
+				const delta = object$2(object$2(message.event).delta);
+				if (delta.type === "text_delta") emit({
+					...common,
+					kind: "message",
+					message: {
+						role: "assistant",
+						content: delta.text,
+						delta: true
+					}
+				});
+			}
+			if (message.type === "system" && message.subtype === "permission_denied" && typeof message.tool_use_id === "string" && typeof message.tool_name === "string") emit({
+				...common,
+				kind: "permission",
+				permission: {
+					id: message.tool_use_id,
+					capability: message.tool_name,
+					decision: "deny",
+					source: "claude_sdk_advisory"
+				}
+			});
+			if (message.type === "result") {
+				for (const rawDenial of Array.isArray(message.permission_denials) ? message.permission_denials : []) {
+					const denial = object$2(rawDenial);
+					if (typeof denial.tool_use_id === "string" && typeof denial.tool_name === "string") emit({
+						...common,
+						kind: "permission",
+						permission: {
+							id: denial.tool_use_id,
+							capability: denial.tool_name,
+							decision: "deny",
+							source: "claude_sdk_result"
+						}
+					});
+				}
+				for (const [model, rawUsage] of Object.entries(object$2(message.modelUsage))) {
+					const usage = object$2(rawUsage);
+					emit({
+						...common,
+						kind: "usage",
+						usage: {
+							scope: "session",
+							cumulative: true,
+							epoch: string$1(message.session_id) ?? "unknown",
+							model,
+							modelBasis: "reported",
+							overlapGroup: "claude_sdk_query",
+							...Object.fromEntries(counters.filter((key) => number(usage[key])).map((key) => [key, usage[key]])),
+							...number(usage.costUSD) ? {
+								amount: usage.costUSD,
+								unit: "USD"
+							} : {}
+						}
+					});
+				}
+			}
+		},
+		finish() {
+			for (const tool of tools.values()) if (tool.status === "running" || tool.status === "pending") emit({
+				kind: "tool",
+				tool: {
+					...tool,
+					status: "unknown"
+				}
+			});
+		}
+	};
+}
+// src/lib/local-harness/process.ts
+const exec$3 = promisify(execFile);
+async function liveGroups() {
+	const listing = await exec$3("/bin/ps", ["-axo", "pgid=,stat="], {
+		timeout: 1e3,
+		maxBuffer: 1048576
+	});
+	return new Set(listing.stdout.split("\n").flatMap((line) => {
+		const [group, state] = line.trim().split(/\s+/);
+		return group && state && !state.startsWith("Z") ? [Number(group)] : [];
+	}));
+}
+async function signalGroup(pid, signal) {
+	try {
+		process.kill(-pid, signal);
+		return true;
+	} catch (error) {
+		if (error.code === "ESRCH") return false;
+		if (error.code === "EPERM" && !(await liveGroups()).has(pid)) return false;
+		throw new Error("Harness process cleanup failed.", { cause: error });
+	}
+}
+function createSupervisor() {
+	const children = /* @__PURE__ */ new Set();
+	let stopping;
+	return {
+		spawn(options) {
+			if (stopping) throw new Error("Harness supervisor is closed.");
+			const child = spawn(options.command, options.args, {
+				cwd: options.cwd,
+				env: options.env,
+				detached: true,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			children.add(child);
+			let outputBytes = 0;
+			child.stdout?.on("data", (chunk) => {
+				outputBytes += chunk.length;
+				if (outputBytes > 16777216) child.stdout?.destroy(/* @__PURE__ */ new Error("Harness output limit exceeded."));
+			});
+			child.stderr?.resume();
+			return child;
+		},
+		stop() {
+			stopping ??= (async () => {
+				const pids = [...children].flatMap((child) => child.pid ? [child.pid] : []);
+				const active = [];
+				for (const pid of pids) if (await signalGroup(pid, "SIGTERM")) active.push(pid);
+				if (!active.length) return;
+				await setTimeout$1(250);
+				for (const pid of active) await signalGroup(pid, "SIGKILL");
+				for (let attempt = 0; attempt < 20; attempt += 1) {
+					const groups = await liveGroups();
+					if (!active.some((pid) => groups.has(pid))) return;
+					await setTimeout$1(50);
+				}
+				throw new Error("Harness descendants did not stop before cleanup deadline.");
+			})();
+			return stopping;
+		}
+	};
+}
+// src/lib/local-harness/compatibility.ts
+/** Exact implementation tuples; platform acceptance evidence is recorded separately from protocol support. */
+const HARNESS_COMPATIBILITY = {
+	claudeNative: {
+		harness: "2.1.314",
+		sdk: "0.3.308",
+		protocol: "claude-agent-sdk",
+		profile: "controlled-mcp"
+	},
+	codexNative: {
+		harness: "0.154.0",
+		protocol: "app-server",
+		profile: "controlled-mcp"
+	},
+	claudeAcp: {
+		harness: "2.1.314",
+		adapter: "0.99.1",
+		sdk: "0.3.312",
+		protocol: "1",
+		profile: "controlled-mcp"
+	}
+};
+// src/lib/local-harness/backends/claude/index.ts
+const CLAUDE_SDK_VERSION = HARNESS_COMPATIBILITY.claudeNative.sdk;
+const CLAUDE_RUNTIME_VERSION = HARNESS_COMPATIBILITY.claudeNative.harness;
+const exec$2 = promisify(execFile);
+const coverage$1 = {
+	tools: { state: "available" },
+	messages: { state: "available" },
+	native: { state: "available" },
+	usage: {
+		state: "available",
+		reason: "SDK query pipeline estimates; excludes helpers outside that pipeline."
+	},
+	timing: {
+		state: "partial",
+		reason: "Tool timestamps are local observations; SDK reports aggregate durations."
+	},
+	lineage: {
+		state: "disabled",
+		reason: "Built-in subagent tools are disabled in controlled-mcp."
+	},
+	reasoning: {
+		state: "partial",
+		reason: "Only summaries emitted by the SDK are captured."
+	}
+};
+function validate$1(config) {
+	if (process.platform !== "darwin" && process.platform !== "linux") throw new Error("Claude controlled harness requires macOS or Linux.");
+	if (config.harness !== "claude" || config.backend !== "native" || config.profile !== "controlled-mcp") throw new Error("This backend supports Claude native controlled-mcp only.");
+	if (!Number.isInteger(config.maxTurns) || config.maxTurns < 1 || !Number.isFinite(config.timeoutMs) || config.timeoutMs < 1) throw new Error("Claude requires positive turn and timeout limits.");
+	const names = /* @__PURE__ */ new Set();
+	for (const server of config.mcpServers) {
+		if (!/^[A-Za-z0-9_-]{1,64}$/.test(server.name) || names.has(server.name)) throw new Error("Invalid or duplicate MCP server name.");
+		const url = new URL(server.url);
+		if (url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname))) throw new Error("MCP requires HTTPS or loopback HTTP without URL credentials.");
+		names.add(server.name);
+	}
+}
+function provenance$1(config, version) {
+	return {
+		harness: "claude",
+		backend: "native",
+		harnessVersion: version,
+		sdkVersion: CLAUDE_SDK_VERSION,
+		protocolVersion: "claude-agent-sdk",
+		profile: config.profile,
+		coverage: coverage$1,
+		configuration: {
+			builtInTools: false,
+			settingSources: [],
+			strictMcpConfig: true,
+			permissionMode: "dontAsk",
+			mcpServers: config.mcpServers.map((server) => server.name),
+			requestedModel: config.model ?? null
+		}
+	};
+}
+const ENVIRONMENT_ALLOWLIST = [
+	"PATH",
+	"HOME",
+	"USER",
+	"LOGNAME",
+	"SHELL",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"TERM",
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"CLAUDE_CODE_OAUTH_TOKEN",
+	"ANTHROPIC_BASE_URL",
+	"CLAUDE_CONFIG_DIR",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"ALL_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"all_proxy",
+	"no_proxy",
+	"SSL_CERT_FILE",
+	"SSL_CERT_DIR",
+	"NODE_EXTRA_CA_CERTS"
+];
+function controlledEnvironment$1() {
+	return {
+		...Object.fromEntries(ENVIRONMENT_ALLOWLIST.flatMap((key) => process.env[key] === void 0 ? [] : [[key, process.env[key]]])),
+		CLAUDE_AGENT_SDK_CLIENT_APP: "runtype-cli-local-harness",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+	};
+}
+function options(config, cwd, supervisor, abortController) {
+	return {
+		pathToClaudeCodeExecutable: config.executable ?? "claude",
+		systemPrompt: {
+			type: "preset",
+			preset: "claude_code"
+		},
+		tools: [],
+		strictMcpConfig: true,
+		mcpServers: Object.fromEntries(config.mcpServers.map(({ name, url, headers }) => [name, {
+			type: "http",
+			url,
+			...headers ? { headers } : {}
+		}])),
+		allowedTools: config.mcpServers.map(({ name }) => `mcp__${name}`),
+		permissionMode: "dontAsk",
+		allowDangerouslySkipPermissions: false,
+		settingSources: [],
+		includePartialMessages: true,
+		promptSuggestions: false,
+		cwd,
+		maxTurns: config.maxTurns,
+		...config.model ? { model: config.model } : {},
+		env: controlledEnvironment$1(),
+		abortController,
+		spawnClaudeCodeProcess: supervisor.spawn,
+		stderr: () => {}
+	};
+}
+async function bounded(work, signal, deadlineAt) {
+	signal.throwIfAborted();
+	let timer;
+	let abort;
+	try {
+		return await Promise.race([work, new Promise((_, reject) => {
+			abort = () => reject(/* @__PURE__ */ new Error("Claude operation cancelled."));
+			signal.addEventListener("abort", abort, { once: true });
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Claude operation deadline exceeded.")), Math.max(0, deadlineAt - Date.now()));
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+		if (abort) signal.removeEventListener("abort", abort);
+	}
+}
+function createClaudeBackend(dependencies = {}) {
+	const loadSdk = dependencies.loadSdk ?? (() => import("@anthropic-ai/claude-agent-sdk"));
+	const authStatus = dependencies.authStatus ?? (async (executable, context) => {
+		let stdout;
+		let failed = false;
+		try {
+			stdout = (await exec$2(executable, [
+				"--setting-sources",
+				"",
+				"auth",
+				"status",
+				"--json"
+			], {
+				cwd: context.cwd,
+				env: controlledEnvironment$1(),
+				signal: context.signal,
+				timeout: Math.max(1, Math.min(5e3, context.deadlineAt - Date.now())),
+				maxBuffer: 16384
+			})).stdout;
+		} catch (error) {
+			const failure = object$2(error);
+			if (failure.code !== 1 || typeof failure.stdout !== "string") throw error;
+			stdout = failure.stdout;
+			failed = true;
+		}
+		const status = object$2(JSON.parse(stdout));
+		if (failed && status.loggedIn !== false) throw new Error("Claude auth status failed.");
+		return {
+			loggedIn: status.loggedIn,
+			apiProvider: status.apiProvider
+		};
+	});
+	const version = dependencies.version ?? (async (executable) => {
+		try {
+			return (await exec$2(executable, ["--version"], {
+				timeout: 5e3,
+				maxBuffer: 8192,
+				env: controlledEnvironment$1()
+			})).stdout.match(/^(\d+\.\d+\.\d+)/)?.[1] ?? "unknown";
+		} catch {
+			throw new Error("Claude executable is unavailable or failed version discovery.");
+		}
+	});
+	async function check(config) {
+		validate$1(config);
+		const actual = await version(config.executable ?? "claude");
+		if (actual !== CLAUDE_RUNTIME_VERSION) throw new Error(`Unsupported Claude version. This backend requires ${CLAUDE_RUNTIME_VERSION}.`);
+		return actual;
+	}
+	return {
+		async doctor(config) {
+			let actual = "unknown";
+			let cwd;
+			let run;
+			const supervisor = createSupervisor();
+			const controller = new AbortController();
+			let releaseInput;
+			try {
+				actual = await check(config);
+				cwd = await mkdtemp(join(tmpdir(), "runtype-claude-doctor-"));
+				const sdk = await loadSdk();
+				const input = { [Symbol.asyncIterator]() {
+					return { async next() {
+						await new Promise((resolve) => {
+							releaseInput = resolve;
+						});
+						return {
+							done: true,
+							value: void 0
+						};
+					} };
+				} };
+				run = sdk.query({
+					prompt: input,
+					options: options(config, cwd, supervisor, controller)
+				});
+				const deadline = Date.now() + Math.min(config.timeoutMs, 15e3);
+				const [account] = await bounded(Promise.all([
+					run.accountInfo(),
+					run.mcpServerStatus(),
+					run.initializationResult()
+				]), controller.signal, deadline);
+				let authentication = account.apiProvider && account.apiProvider !== "firstParty" ? "unsupported" : account.tokenSource && account.tokenSource !== "none" || account.apiKeySource && account.apiKeySource !== "none" ? "ready" : "unknown";
+				if (authentication === "unknown") try {
+					const status = object$2(await bounded(authStatus(config.executable ?? "claude", {
+						cwd,
+						signal: controller.signal,
+						deadlineAt: deadline
+					}), controller.signal, deadline));
+					authentication = status.apiProvider !== void 0 && typeof status.apiProvider !== "string" ? "unknown" : typeof status.apiProvider === "string" && status.apiProvider !== "firstParty" ? "unsupported" : status.loggedIn === false ? "absent" : status.loggedIn === true && (status.apiProvider === "firstParty" || account.apiProvider === "firstParty") ? "ready" : "unknown";
+				} catch {
+					authentication = "unknown";
+				}
+				let connected = config.mcpServers.length === 0;
+				while (!connected && Date.now() < deadline) {
+					const servers = await bounded(run.mcpServerStatus(), controller.signal, deadline);
+					connected = config.mcpServers.every((server) => servers.some((status) => status.name === server.name && status.status === "connected"));
+					if (connected || servers.some((server) => server.status === "failed" || server.status === "needs-auth")) break;
+					await setTimeout$1(100);
+				}
+				return {
+					ready: authentication === "ready" && connected,
+					authentication,
+					provenance: provenance$1(config, actual),
+					diagnostics: [authentication === "ready" ? "Credentials are present; expiry and live authorization are not verified without a provider request." : authentication === "absent" ? "Sign in with Claude or configure an Anthropic API key." : authentication === "unsupported" ? "This backend requires first-party Anthropic authentication; third-party providers are unsupported." : "Credential status could not be verified. Run Claude auth status to inspect local authentication.", ...connected ? [] : ["One or more configured MCP servers are not connected."]]
+				};
+			} catch {
+				return {
+					ready: false,
+					authentication: "unknown",
+					provenance: provenance$1(config, actual),
+					diagnostics: [`Claude initialization failed. This backend requires Claude ${CLAUDE_RUNTIME_VERSION}; verify authentication and MCP configuration.`]
+				};
+			} finally {
+				releaseInput?.();
+				controller.abort();
+				run?.close();
+				await supervisor.stop();
+				if (cwd) await rm(cwd, {
+					recursive: true,
+					force: true
+				});
+			}
+		},
+		async start(config, context) {
+			context.signal.throwIfAborted();
+			await bounded(check(config), context.signal, context.deadlineAt);
+			context.signal.throwIfAborted();
+			const cwd = await mkdtemp(join(tmpdir(), "runtype-claude-session-"));
+			let sdk;
+			try {
+				sdk = await bounded(loadSdk(), context.signal, context.deadlineAt);
+			} catch (error) {
+				await rm(cwd, {
+					recursive: true,
+					force: true
+				});
+				throw error;
+			}
+			let previous;
+			let nativeSessionId;
+			let blocked = false;
+			let closed = false;
+			let cleanupFailed = false;
+			let activeController;
+			let activeRun;
+			let activeCleanup;
+			const session = {
+				id: context.sessionId,
+				async prompt(input) {
+					if (blocked || closed || activeController) throw new Error("Claude session cannot accept another turn; start a new context.");
+					input.signal.throwIfAborted();
+					const controller = new AbortController();
+					activeController = controller;
+					const supervisor = createSupervisor();
+					const observer = createObserver$1(input.emit, config.mcpServers.map((server) => server.name));
+					let result;
+					let status = "failed";
+					let cleanupDone;
+					activeCleanup = new Promise((resolve) => {
+						cleanupDone = resolve;
+					});
+					const cancel = () => controller.abort();
+					input.signal.addEventListener("abort", cancel, { once: true });
+					try {
+						const deadline = Math.min(input.deadlineAt, Date.now() + config.timeoutMs);
+						if (deadline <= Date.now()) throw new Error("Claude operation deadline exceeded.");
+						input.emit({
+							kind: "message",
+							message: {
+								role: "user",
+								content: input.prompt
+							}
+						});
+						activeRun = sdk.query({
+							prompt: input.prompt,
+							options: {
+								...options(config, cwd, supervisor, controller),
+								...nativeSessionId ? { resume: nativeSessionId } : {}
+							}
+						});
+						const consume = async () => {
+							for await (const message of activeRun) {
+								observer.observe(message);
+								if (message.type === "result") result = object$2(message);
+							}
+						};
+						await bounded(consume(), controller.signal, deadline);
+						if (result?.subtype === "success" && result.is_error !== true && typeof result.result === "string") status = "completed";
+						else blocked = true;
+					} catch {
+						status = input.signal.aborted || controller.signal.aborted ? "cancelled" : "failed";
+						blocked = true;
+					} finally {
+						controller.abort();
+						input.signal.removeEventListener("abort", cancel);
+						try {
+							activeRun?.close();
+							await supervisor.stop();
+						} catch {
+							status = "failed";
+							blocked = true;
+							cleanupFailed = true;
+							input.emit({
+								kind: "lifecycle",
+								lifecycle: {
+									state: "cleanup_failed",
+									reason: "Claude process cleanup failed."
+								}
+							});
+						}
+						observer.finish();
+						activeRun = void 0;
+						activeController = void 0;
+						cleanupDone?.();
+					}
+					const usage = result ? reportedUsage$1(result, previous) : void 0;
+					if (result) previous = result;
+					if (typeof result?.session_id === "string") nativeSessionId = result.session_id;
+					return {
+						text: status === "completed" && typeof result?.result === "string" ? result.result : "",
+						status,
+						nativeSessionId,
+						nativeTurnId: typeof result?.user_message_uuid === "string" ? result.user_message_uuid : void 0,
+						...usage ? { reportedUsage: usage } : {},
+						coverage: status === "completed" ? coverage$1 : {
+							...coverage$1,
+							tools: {
+								state: "partial",
+								reason: "Turn failed or was cancelled; completed evidence is retained."
+							}
+						}
+					};
+				},
+				async cancel() {
+					blocked = true;
+					activeController?.abort();
+					await activeCleanup;
+				},
+				async close() {
+					closed = true;
+					await session.cancel();
+					if (cleanupFailed) throw new Error("Claude cleanup failed; session files were retained.");
+					await rm(cwd, {
+						recursive: true,
+						force: true
+					});
+				}
+			};
+			return session;
+		}
+	};
+}
+// src/lib/local-harness/backends/codex/failures.ts
+const object$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+const causes = {
+	model_not_found: "The requested model is unavailable for this Codex account. Choose an account-supported model or omit --model.",
+	unauthorized: "Codex authentication was rejected. Sign in again and retry.",
+	invalid_api_key: "Codex authentication was rejected. Sign in again and retry.",
+	usageLimitExceeded: "The Codex account usage limit was reached.",
+	rateLimitExceeded: "Codex was rate limited. Retry after the account limit resets.",
+	rate_limit_exceeded: "Codex was rate limited. Retry after the account limit resets.",
+	contextWindowExceeded: "The Codex context window was exceeded. Start a new session.",
+	context_length_exceeded: "The Codex context window was exceeded. Start a new session.",
+	sessionBudgetExceeded: "The Codex session budget was exceeded.",
+	serverOverloaded: "The Codex provider is overloaded. Retry later.",
+	internalServerError: "The Codex provider returned an internal error. Retry later.",
+	sandboxError: "Codex could not establish its sandbox. Check the local installation.",
+	cyberPolicy: "The Codex provider blocked the turn under its policy.",
+	misalignmentPolicyViolation: "The Codex provider blocked the turn under its policy.",
+	badRequest: "The Codex provider rejected the request. Check the model and configuration."
+};
+var CodexCapabilityError = class extends Error {
+	constructor() {
+		super("Codex controlled MCP requires isolated Code Mode with built-in tools excluded. Install the matching codex-code-mode-host beside Codex and remove overrides that disable code_mode_host, code_mode_only, or the functions/clock exclusions.");
+	}
+};
+var CodexNativeError = class extends Error {
+	failure;
+	constructor(value) {
+		const failure = nativeFailure(value);
+		super(failure?.text ?? "Codex App Server request failed.");
+		this.failure = failure;
+	}
+};
+function codeModeUnavailable(value) {
+	return typeof value === "string" && value.length <= 16384 && /Code Mode is unavailable|code-mode host (?:is disabled|unavailable|failed)|failed to (?:start|spawn|initialize).*code.mode.host/i.test(value);
+}
+function nativeFailure(value) {
+	if (value instanceof CodexNativeError) return value.failure;
+	if (value instanceof CodexCapabilityError) return {
+		reason: "code_mode_unavailable",
+		text: value.message
+	};
+	const error = object$1(value);
+	const message = typeof error.message === "string" ? error.message : "";
+	if (codeModeUnavailable(message)) return {
+		reason: "code_mode_unavailable",
+		text: new CodexCapabilityError().message
+	};
+	let provider = error;
+	if (message.length <= 16384) try {
+		provider = object$1(JSON.parse(message));
+	} catch {
+		provider = error;
+	}
+	const code = object$1(provider.error).code ?? provider.code ?? error.codexErrorInfo;
+	if (typeof code === "string" && Object.hasOwn(causes, code)) return {
+		reason: code,
+		text: `Codex turn failed (${code}). ${causes[code]}`
+	};
+	const info = object$1(error.codexErrorInfo);
+	for (const name of [
+		"httpConnectionFailed",
+		"responseStreamConnectionFailed",
+		"responseStreamDisconnected",
+		"responseTooManyFailedAttempts"
+	]) {
+		const status = object$1(info[name]).httpStatusCode;
+		if (Number.isInteger(status) && Number(status) >= 100 && Number(status) <= 599) return {
+			reason: name,
+			text: `Codex turn failed (${name}, HTTP ${status}). Check account access and provider connectivity.`
+		};
+	}
+}
+// src/lib/local-harness/backends/codex/config.ts
+const codeModeFeatures = {
+	code_mode: {
+		enabled: true,
+		excluded_tool_namespaces: ["functions", "clock"]
+	},
+	code_mode_only: true,
+	code_mode_host: {
+		enabled: true,
+		disable_in_process_fallback: true
+	}
+};
+function verifyCodeModeFeatures(config) {
+	const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+	const features = record(record(config).features);
+	const mode = record(features.code_mode);
+	const host = record(features.code_mode_host);
+	const excluded = mode.excluded_tool_namespaces;
+	if (mode.enabled !== true || features.code_mode_only !== true || host.enabled !== true || host.disable_in_process_fallback !== true || !Array.isArray(excluded) || !["functions", "clock"].every((name) => excluded.includes(name))) throw new CodexCapabilityError();
+}
+function controlledEnvironment(source = process.env) {
+	return Object.fromEntries([
+		"PATH",
+		"OPENAI_API_KEY",
+		"CODEX_API_KEY",
+		"SSL_CERT_FILE",
+		"SSL_CERT_DIR",
+		"NODE_EXTRA_CA_CERTS",
+		"SystemRoot",
+		"LANG",
+		"LC_ALL",
+		"HTTP_PROXY",
+		"HTTPS_PROXY",
+		"ALL_PROXY",
+		"NO_PROXY",
+		"http_proxy",
+		"https_proxy",
+		"all_proxy",
+		"no_proxy"
+	].filter((key) => typeof source[key] === "string").map((key) => [key, source[key]]));
+}
+function controlledConfig(config) {
+	return [
+		"approval_policy = \"never\"",
+		"sandbox_mode = \"read-only\"",
+		"web_search = \"disabled\"",
+		"project_doc_max_bytes = 0",
+		"check_for_update_on_startup = false",
+		"suppress_unstable_features_warning = true",
+		"mcp_oauth_credentials_store = \"file\"",
+		"cli_auth_credentials_store = \"file\"",
+		"service_tier = \"default\"",
+		"[analytics]",
+		"enabled = false",
+		"[features]",
+		...[
+			"shell_tool",
+			"unified_exec",
+			"shell_snapshot",
+			"apps",
+			"plugins",
+			"remote_plugin",
+			"multi_agent",
+			"multi_agent_v2",
+			"browser_use",
+			"browser_use_external",
+			"computer_use",
+			"image_generation",
+			"view_image",
+			"in_app_browser",
+			"in_app_chat",
+			"in_app_local_automation",
+			"in_app_updates",
+			"request_permissions_tool",
+			"goals",
+			"hooks",
+			"memories",
+			"skill_search",
+			"skill_mcp_dependency_install",
+			"workspace_dependencies",
+			"tool_suggest",
+			"sleep_tool"
+		].map((name) => `${name} = false`),
+		...Object.entries(codeModeFeatures).map(([name, value]) => `${name} = ${typeof value === "boolean" ? JSON.stringify(value) : `{ ${Object.entries(value).map(([key, field]) => `${key} = ${JSON.stringify(field)}`).join(", ")} }`}`),
+		"skip_host_skill_discovery = true",
+		"[tools.update_plan]",
+		"enabled = false",
+		"[tools.experimental_request_user_input]",
+		"enabled = false",
+		"[skills]",
+		"include_instructions = false",
+		"[skills.bundled]",
+		"enabled = false",
+		...config.mcpServers.flatMap(({ name, url, headers }) => [
+			`[mcp_servers.${JSON.stringify(name)}]`,
+			`url = ${JSON.stringify(url)}`,
+			"required = true",
+			"startup_timeout_sec = 20",
+			"tool_timeout_sec = 60",
+			...headers ? [`http_headers = { ${Object.entries(headers).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`] : []
+		]),
+		""
+	].join("\n");
+}
+async function createEnvironment(config) {
+	const root = await mkdtemp(join(tmpdir(), "runtype-app-server-"));
+	const home = join(root, "home");
+	const harnessHome = join(home, ".codex");
+	const cwd = join(root, "work");
+	const cleanup = () => rm(root, {
+		recursive: true,
+		force: true
+	});
+	try {
+		await mkdir(harnessHome, {
+			recursive: true,
+			mode: 448
+		});
+		await mkdir(cwd, { mode: 448 });
+		for (const name of ["auth.json", ".credentials.json"]) try {
+			const target = join(harnessHome, name);
+			await copyFile(join(process.env.CODEX_HOME || join(homedir(), ".codex"), name), target);
+			await chmod(target, 384);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await writeFile(join(harnessHome, "config.toml"), controlledConfig(config), { mode: 384 });
+		return {
+			root,
+			cwd,
+			cleanup,
+			env: {
+				...controlledEnvironment(),
+				HOME: home,
+				CODEX_HOME: harnessHome,
+				XDG_CONFIG_HOME: join(home, ".config"),
+				XDG_DATA_HOME: join(home, ".local/share"),
+				XDG_CACHE_HOME: join(home, ".cache"),
+				XDG_STATE_HOME: join(home, ".local/state")
+			}
+		};
+	} catch (error) {
+		await cleanup();
+		throw error;
+	}
+}
+// src/lib/local-harness/backends/codex/rpc.ts
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function deniedResponse(method) {
+	if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") return { decision: "cancel" };
+	if (method === "item/permissions/requestApproval") return {
+		permissions: {},
+		scope: "turn"
+	};
+	if (method === "mcpServer/elicitation/request") return { action: "decline" };
+	if (method === "item/tool/requestUserInput") return { answers: {} };
+	if (method === "item/tool/call") return {
+		contentItems: [],
+		success: false
+	};
+}
+function startRpc(command, cwd, env) {
+	const supervisor = createSupervisor();
+	const child = supervisor.spawn({
+		command,
+		args: [
+			"app-server",
+			"--strict-config",
+			"--stdio"
+		],
+		cwd,
+		env,
+		signal: new AbortController().signal
+	});
+	const pending = /* @__PURE__ */ new Map();
+	let sequence = 0;
+	let buffer = "";
+	let ended;
+	let listener = () => {};
+	let failure = () => {};
+	const fail = (error) => {
+		if (ended) return;
+		ended = error;
+		for (const entry of pending.values()) {
+			entry.dispose();
+			entry.reject(error);
+		}
+		pending.clear();
+		failure(error);
+	};
+	const send = (value) => {
+		if (ended) throw ended;
+		child.stdin.write(`${JSON.stringify(value)}\n`);
+	};
+	child.stdout.setEncoding("utf8");
+	child.stdout.on("data", (chunk) => {
+		buffer += chunk;
+		if (Buffer.byteLength(buffer) > 1048576) {
+			fail(/* @__PURE__ */ new Error("Codex protocol frame limit exceeded."));
+			supervisor.stop().catch(() => {});
+			return;
+		}
+		let offset;
+		while ((offset = buffer.indexOf("\n")) >= 0) {
+			const line = buffer.slice(0, offset);
+			buffer = buffer.slice(offset + 1);
+			if (!line.trim()) continue;
+			try {
+				let decoded;
+				try {
+					decoded = JSON.parse(line);
+				} catch {
+					throw new Error("Codex emitted invalid JSON.");
+				}
+				const message = object(decoded);
+				listener(message);
+				if (typeof message.method === "string") {
+					if (message.id !== void 0) {
+						const result = deniedResponse(message.method);
+						send(result === void 0 ? {
+							id: message.id,
+							error: {
+								code: -32601,
+								message: "Interactive operation is unavailable."
+							}
+						} : {
+							id: message.id,
+							result
+						});
+					}
+				} else if (typeof message.id === "number") {
+					const entry = pending.get(message.id);
+					if (!entry) continue;
+					pending.delete(message.id);
+					entry.dispose();
+					if (message.error) entry.reject(new CodexNativeError(message.error));
+					else entry.resolve(object(message.result));
+				}
+			} catch (error) {
+				fail(error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid Codex protocol message."));
+				supervisor.stop().catch(() => {});
+			}
+		}
+	});
+	child.stdout.on("error", () => fail(/* @__PURE__ */ new Error("Codex output stream failed.")));
+	child.stdin.on("error", () => fail(/* @__PURE__ */ new Error("Codex input stream failed.")));
+	child.on("error", () => fail(/* @__PURE__ */ new Error("Codex process could not start.")));
+	child.on("exit", () => fail(/* @__PURE__ */ new Error("Codex App Server exited.")));
+	return {
+		observe(next, onFailure) {
+			listener = next;
+			failure = onFailure;
+			if (ended) failure(ended);
+		},
+		notify(method) {
+			send({ method });
+		},
+		request(method, params, signal, deadlineAt) {
+			if (ended) return Promise.reject(ended);
+			if (signal.aborted || Date.now() >= deadlineAt) return Promise.reject(/* @__PURE__ */ new Error("Codex request cancelled or deadline exceeded."));
+			const id = ++sequence;
+			return new Promise((resolve, reject) => {
+				const abort = () => {
+					pending.delete(id);
+					dispose();
+					reject(/* @__PURE__ */ new Error("Codex request cancelled or deadline exceeded."));
+				};
+				const timer = setTimeout(abort, Math.max(1, deadlineAt - Date.now()));
+				const dispose = () => {
+					clearTimeout(timer);
+					signal.removeEventListener("abort", abort);
+				};
+				pending.set(id, {
+					resolve,
+					reject,
+					dispose
+				});
+				signal.addEventListener("abort", abort, { once: true });
+				try {
+					send({
+						id,
+						method,
+						params
+					});
+				} catch (error) {
+					pending.delete(id);
+					dispose();
+					reject(error);
+				}
+			});
+		},
+		async close() {
+			failure = () => {};
+			fail(/* @__PURE__ */ new Error("Codex session closed."));
+			await supervisor.stop();
+		}
+	};
+}
+// src/lib/local-harness/backends/codex/observations.ts
+const PRICING_PROVENANCE = {
+	source: "https://developers.openai.com/api/docs/pricing",
+	checkedAt: "2026-10-30",
+	basis: "requested-model standard API list estimate; not subscription charges"
+};
+const rates = {
+	"gpt-5.4": {
+		input: 2.5,
+		cached: .25,
+		output: 15
+	},
+	"gpt-5.4-mini": {
+		input: .75,
+		cached: .075,
+		output: 4.5
+	},
+	"gpt-5.2": {
+		input: 1.75,
+		cached: .175,
+		output: 14
+	},
+	"gpt-6.1-sol": {
+		input: 2,
+		cached: .1,
+		output: 10,
+		writes: true
+	}
+};
+const counter = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const string = (value) => typeof value === "string" ? value : void 0;
+const fields = [
+	"inputTokens",
+	"cachedInputTokens",
+	"cacheWriteInputTokens",
+	"outputTokens",
+	"reasoningOutputTokens"
+];
+function usageDelta(current, previous) {
+	const delta = {};
+	for (const field of fields) {
+		const value = current[field];
+		const before = previous ? previous[field] : 0;
+		if (field === "cacheWriteInputTokens" && value === void 0 && (!previous || before === void 0)) continue;
+		if (!counter(value) || !counter(before) || value < before) return void 0;
+		delta[field] = value - before;
+	}
+	if (Number(delta.cachedInputTokens) > Number(delta.inputTokens) || Number(delta.reasoningOutputTokens) > Number(delta.outputTokens)) return void 0;
+	return delta;
+}
+function reportedUsage(current, previous, model, complete, modelChanged = false) {
+	const result = {
+		costUsd: null,
+		completeness: "partial",
+		scope: "codex_app_server_turn_requested_model"
+	};
+	const delta = current && usageDelta(current, previous);
+	if (!delta) return result;
+	const entry = {
+		model: model.slice(0, 200),
+		provider: "openai",
+		pricingBasis: "unknown",
+		costUsd: null,
+		inputTokens: Number(delta.inputTokens) - Number(delta.cachedInputTokens),
+		outputTokens: Number(delta.outputTokens),
+		cacheReadInputTokens: Number(delta.cachedInputTokens),
+		...counter(delta.cacheWriteInputTokens) ? { cacheCreationInputTokens: delta.cacheWriteInputTokens } : {}
+	};
+	result.models = [entry];
+	const rate = rates[model];
+	if (!rate || modelChanged || !counter(current?.inputTokens) || current.inputTokens > 272e3 || rate.writes && delta.cacheWriteInputTokens === void 0 || delta.cacheWriteInputTokens !== void 0 && delta.cacheWriteInputTokens !== 0) return result;
+	const amount = (entry.inputTokens * rate.input + entry.cacheReadInputTokens * rate.cached + entry.outputTokens * rate.output) / 1e6;
+	if (!Number.isFinite(amount) || !complete && amount === 0) return result;
+	result.costUsd = entry.costUsd = amount;
+	entry.pricingBasis = "list";
+	result.completeness = complete ? "complete" : "partial";
+	return result;
+}
+function createObserver(emit, threadId, model, servers) {
+	const tools = /* @__PURE__ */ new Map();
+	const messages = /* @__PURE__ */ new Map();
+	let usage;
+	let usageUpdates = 0;
+	let usageInvalid = false;
+	let lastUsage = "";
+	let modelChanged = false;
+	let turnId;
+	let terminal;
+	let failure;
+	return {
+		observe(raw) {
+			const params = object(raw.params);
+			const item = object(params.item);
+			const nativeTurnId = string(params.turnId) ?? string(object(params.turn).id);
+			const common = {
+				nativeId: string(item.id) ?? string(params.itemId),
+				nativeSessionId: string(params.threadId) ?? threadId,
+				nativeTurnId
+			};
+			emit({
+				...common,
+				kind: "native",
+				native: raw,
+				...typeof raw.method === "string" && /delta$/i.test(raw.method) ? { fragment: true } : {}
+			});
+			if (params.threadId !== void 0 && params.threadId !== threadId) throw new Error("Codex emitted a foreign thread event.");
+			if (nativeTurnId) {
+				if (turnId && nativeTurnId !== turnId) throw new Error("Codex emitted a foreign turn event.");
+				turnId = nativeTurnId;
+			}
+			if (raw.method === "model/rerouted" || raw.method === "thread/model/changed") modelChanged = true;
+			if (raw.method === "warning" && codeModeUnavailable(params.message)) throw new CodexCapabilityError();
+			if (raw.method === "error" && params.willRetry !== true) failure = nativeFailure(params.error);
+			if (raw.id !== void 0 && typeof raw.method === "string") emit({
+				...common,
+				kind: "permission",
+				permission: {
+					id: String(raw.id),
+					capability: raw.method,
+					decision: "deny",
+					source: "codex_app_server"
+				}
+			});
+			if (raw.method === "turn/completed") {
+				terminal = string(object(params.turn).status) ?? "unknown";
+				failure = terminal === "completed" ? void 0 : nativeFailure(object(params.turn).error) ?? failure;
+			}
+			if ((raw.method === "item/started" || raw.method === "item/completed") && typeof item.id === "string") {
+				if ([
+					"commandExecution",
+					"fileChange",
+					"webSearch",
+					"imageGeneration",
+					"collabAgentToolCall"
+				].includes(String(item.type))) throw new Error("Codex attempted a disabled built-in operation.");
+				if (item.type === "agentMessage" && raw.method === "item/completed" && typeof item.text === "string") {
+					if (messages.get(item.id) !== item.text) emit({
+						...common,
+						kind: "message",
+						message: {
+							role: "assistant",
+							content: item.text
+						}
+					});
+					messages.set(item.id, item.text);
+				}
+				if (item.type === "mcpToolCall") {
+					const previous = tools.get(item.id);
+					const server = string(item.server) ?? previous?.mcpServer;
+					const toolName = string(item.tool) ?? previous?.mcpTool;
+					if (!server || !servers.includes(server) || !toolName) throw new Error("Codex emitted an unconfigured MCP tool.");
+					const failed = previous?.status === "failed" || item.status === "failed" || !!item.error || object(item.result).isError === true;
+					const done = raw.method === "item/completed" && item.status === "completed";
+					const tool = {
+						...previous,
+						id: item.id,
+						name: `mcp__${server}__${toolName}`,
+						nativeName: toolName,
+						mcpServer: server,
+						mcpTool: toolName,
+						...item.arguments !== void 0 ? { input: item.arguments } : {},
+						...item.result !== void 0 && item.result !== null ? { output: item.result } : {},
+						...item.error ? { error: item.error } : {},
+						status: failed ? "failed" : done ? "succeeded" : previous?.status === "succeeded" ? "succeeded" : "running",
+						startedAt: previous?.startedAt ?? Date.now(),
+						...done || failed ? { endedAt: Date.now() } : {},
+						...counter(item.durationMs) ? { durationMs: item.durationMs } : {}
+					};
+					tools.set(item.id, tool);
+					emit({
+						...common,
+						kind: "tool",
+						tool: { ...tool }
+					});
+				}
+			}
+			if (raw.method === "item/agentMessage/delta" && typeof params.delta === "string") emit({
+				...common,
+				kind: "message",
+				message: {
+					role: "assistant",
+					content: params.delta,
+					delta: true
+				}
+			});
+			if (raw.method === "thread/tokenUsage/updated") {
+				const total = object(object(params.tokenUsage).total);
+				const serialized = JSON.stringify(fields.map((field) => total[field]));
+				if (serialized !== lastUsage) {
+					usageUpdates += 1;
+					lastUsage = serialized;
+				}
+				if (usage && !usageDelta(total, usage)) usageInvalid = true;
+				usage = total;
+				if (counter(total.inputTokens) && counter(total.cachedInputTokens) && total.cachedInputTokens <= total.inputTokens) emit({
+					...common,
+					kind: "usage",
+					usage: {
+						scope: "session",
+						cumulative: true,
+						epoch: threadId,
+						model,
+						modelBasis: "requested",
+						overlapGroup: "codex_thread_total",
+						inputTokens: total.inputTokens - total.cachedInputTokens,
+						cacheReadInputTokens: total.cachedInputTokens,
+						...counter(total.outputTokens) ? { outputTokens: total.outputTokens } : {},
+						...counter(total.reasoningOutputTokens) ? { reasoningTokens: total.reasoningOutputTokens } : {},
+						...counter(total.cacheWriteInputTokens) ? { cacheCreationInputTokens: total.cacheWriteInputTokens } : {}
+					}
+				});
+			}
+		},
+		state() {
+			return {
+				usage,
+				usageInvalid,
+				usageUpdates,
+				modelChanged,
+				turnId,
+				terminal,
+				failure,
+				text: [...messages.values()].join("\n")
+			};
+		},
+		finish() {
+			for (const tool of tools.values()) if (tool.status === "running" || tool.status === "pending") emit({
+				nativeSessionId: threadId,
+				nativeTurnId: turnId,
+				kind: "tool",
+				tool: {
+					...tool,
+					status: "unknown"
+				}
+			});
+		}
+	};
+}
+// src/lib/local-harness/backends/codex/index.ts
+const exec$1 = promisify(execFile);
+const supported = HARNESS_COMPATIBILITY.codexNative;
+const coverage = {
+	profile: {
+		state: "partial",
+		reason: "Isolated Code Mode exposes configured MCP tools only; read-only sandbox and denied interactive requests remain additional boundaries."
+	},
+	requestLimit: {
+		state: "partial",
+		reason: "Limits distinct cumulative usage updates; App Server does not expose authoritative per-request identifiers."
+	},
+	tools: { state: "available" },
+	messages: { state: "available" },
+	native: { state: "available" },
+	usage: {
+		state: "partial",
+		reason: "Thread token deltas; configured-model API list estimates only where cache and context-tier inputs are known."
+	},
+	timing: {
+		state: "partial",
+		reason: "Native MCP durations when present; otherwise local observations."
+	},
+	lineage: {
+		state: "disabled",
+		reason: "Subagents are disabled in controlled-mcp."
+	},
+	reasoning: {
+		state: "partial",
+		reason: "Only summaries exposed by App Server are retained."
+	}
+};
+function provenance(config, version) {
+	return {
+		harness: "codex",
+		backend: "native",
+		harnessVersion: version,
+		protocolVersion: supported.protocol,
+		profile: config.profile,
+		coverage,
+		configuration: {
+			approvalPolicy: "never",
+			sandbox: "read-only",
+			strictConfig: true,
+			userConfiguration: false,
+			executableTools: false,
+			webSearch: false,
+			subagents: false,
+			codeMode: "required-isolated-host",
+			excludedToolNamespaces: ["functions", "clock"],
+			nativeToolLimitations: ["Code Mode JavaScript has no filesystem, process, module-import or network APIs.", "Configured MCP servers retain their own server-side capabilities."],
+			mcpServers: config.mcpServers.map((server) => server.name),
+			requestedModel: config.model ?? null,
+			pricing: PRICING_PROVENANCE
+		}
+	};
+}
+function validate(config) {
+	if (config.harness !== "codex" || config.backend !== "native" || config.profile !== "controlled-mcp" || config.cwd) throw new Error("Codex native supports controlled-mcp with an isolated workspace only.");
+	if (process.platform === "win32") throw new Error("Codex native process supervision is not qualified on Windows.");
+}
+const INTERRUPTED_TURN_END_MS = 300;
+function createCodexBackend(dependencies = {}) {
+	const version = dependencies.version ?? (async (executable) => {
+		return (await exec$1(executable, ["--version"], {
+			env: controlledEnvironment(),
+			timeout: 5e3,
+			maxBuffer: 4096
+		})).stdout.trim().replace(/^codex-cli\s+/, "");
+	});
+	async function open(config, signal, deadlineAt) {
+		validate(config);
+		signal.throwIfAborted();
+		const executable = config.executable ?? "codex";
+		const actual = await version(executable);
+		if (actual !== supported.harness) throw new Error(`Codex ${supported.harness} is required; found ${actual}.`);
+		signal.throwIfAborted();
+		if (Date.now() >= deadlineAt) throw new Error("Codex startup deadline exceeded.");
+		const environment = await createEnvironment(config);
+		let rpc;
+		try {
+			rpc = (dependencies.rpc ?? startRpc)(executable, environment.cwd, environment.env);
+			let capabilityFailure;
+			rpc.observe?.((message) => {
+				if (message.method === "warning" && codeModeUnavailable(object(message.params).message)) capabilityFailure = new CodexCapabilityError();
+			}, () => {});
+			await rpc.request("initialize", { clientInfo: {
+				name: "runtype_local_harness",
+				version: "1.0.0"
+			} }, signal, deadlineAt);
+			rpc.notify("initialized");
+			verifyCodeModeFeatures((await rpc.request("config/read", {}, signal, deadlineAt)).config);
+			const account = await rpc.request("account/read", { refreshToken: false }, signal, deadlineAt);
+			const authentication = account.account || account.requiresOpenaiAuth === false ? "ready" : "absent";
+			const statuses = /* @__PURE__ */ new Map();
+			do {
+				let cursor;
+				const cursors = /* @__PURE__ */ new Set();
+				do {
+					const page = await rpc.request("mcpServerStatus/list", {
+						limit: 100,
+						detail: "toolsAndAuthOnly",
+						...cursor ? { cursor } : {}
+					}, signal, deadlineAt);
+					if (!Array.isArray(page.data)) throw new Error("Codex MCP discovery returned no catalog.");
+					for (const raw of page.data) {
+						const entry = object(raw);
+						if (typeof entry.name === "string") statuses.set(entry.name, entry);
+					}
+					const next = page.nextCursor;
+					if (next !== null && next !== void 0 && (typeof next !== "string" || cursors.has(next) || cursors.size >= 100)) throw new Error("Invalid Codex discovery pagination.");
+					cursor = typeof next === "string" ? next : void 0;
+					if (cursor) cursors.add(cursor);
+				} while (cursor);
+				if (config.mcpServers.every(({ name }) => {
+					const status = statuses.get(name);
+					return status?.tools && !Array.isArray(status.tools) && status.toolsError === null && (!status.runtimeStatus || status.runtimeStatus === "connected");
+				})) break;
+				await setTimeout$1(100, void 0, { signal });
+			} while (Date.now() < deadlineAt);
+			if (!config.mcpServers.every(({ name }) => {
+				const status = statuses.get(name);
+				return status?.tools && !Array.isArray(status.tools) && status.toolsError === null && (!status.runtimeStatus || status.runtimeStatus === "connected");
+			})) throw new Error("Codex MCP servers did not connect before the startup deadline.");
+			const initialized = authentication === "ready" ? await rpc.request("thread/start", {
+				...config.model ? { model: config.model } : {},
+				cwd: environment.cwd,
+				approvalPolicy: "never",
+				sandbox: "read-only",
+				ephemeral: true,
+				serviceTier: "default"
+			}, signal, deadlineAt) : void 0;
+			if (capabilityFailure) throw capabilityFailure;
+			if (initialized && (typeof object(initialized.thread).id !== "string" || typeof initialized.model !== "string" || initialized.approvalPolicy !== "never" || object(initialized.sandbox).type !== "readOnly")) throw new Error("Codex did not establish the controlled profile.");
+			return {
+				rpc,
+				environment,
+				authentication,
+				initialized,
+				provenance: provenance(config, actual)
+			};
+		} catch (error) {
+			await rpc?.close();
+			await environment.cleanup();
+			throw error;
+		}
+	}
+	return {
+		async doctor(config) {
+			let active;
+			let result;
+			try {
+				const timeout = Math.min(config.timeoutMs, 45e3);
+				active = await open(config, AbortSignal.timeout(timeout), Date.now() + timeout);
+				result = {
+					ready: active.authentication === "ready",
+					authentication: active.authentication,
+					provenance: active.provenance,
+					diagnostics: [
+						"MCP servers connected without a model turn.",
+						"Account presence checked without refreshing tokens; expiry is not verified.",
+						"No inference was requested; model entitlement and actual MCP tool execution are not verified."
+					]
+				};
+			} catch (error) {
+				result = {
+					ready: false,
+					authentication: "unknown",
+					provenance: provenance(config, "unknown"),
+					diagnostics: [error instanceof CodexCapabilityError || error instanceof CodexNativeError && error.failure ? error.message : `Codex ${supported.harness} is required. Initialization failed; check the executable, authentication and MCP configuration.`]
+				};
+			}
+			if (active) try {
+				await active.rpc.close();
+				await active.environment.cleanup();
+			} catch {
+				throw new Error("Codex cleanup failed. Inspect the local harness processes before retrying.");
+			}
+			return result;
+		},
+		async start(config, context) {
+			const active = await open(config, context.signal, context.deadlineAt);
+			const { rpc, environment } = active;
+			let closed = false;
+			let invalid = false;
+			let busy = false;
+			let cancelActive;
+			let activeTurn;
+			let previousUsage;
+			let modelChanged = false;
+			let closing;
+			const close = () => closing ??= (async () => {
+				closed = true;
+				cancelActive?.();
+				await rpc.close();
+				await environment.cleanup();
+			})();
+			let threadId;
+			let model;
+			try {
+				if (active.authentication !== "ready") throw new Error("Codex authentication is unavailable.");
+				const initialized = active.initialized;
+				const thread = object(initialized.thread);
+				if (typeof thread.id !== "string" || typeof initialized.model !== "string" || initialized.approvalPolicy !== "never" || object(initialized.sandbox).type !== "readOnly") throw new Error("Codex did not establish the controlled profile.");
+				threadId = thread.id;
+				model = initialized.model;
+			} catch (error) {
+				await close();
+				throw error;
+			}
+			return {
+				id: context.sessionId,
+				async prompt(input) {
+					if (closed || invalid) throw new Error("Cannot continue a closed or failed Codex context.");
+					if (busy) throw new Error("Concurrent Codex turns are not allowed.");
+					busy = true;
+					let turnReported = () => {};
+					activeTurn = new Promise((resolve) => turnReported = resolve);
+					const observer = createObserver(input.emit, threadId, model, config.mcpServers.map((server) => server.name));
+					const deadlineAt = Math.min(input.deadlineAt, Date.now() + config.timeoutMs);
+					const controller = new AbortController();
+					const abort = () => controller.abort();
+					input.signal.addEventListener("abort", abort, { once: true });
+					if (input.signal.aborted) abort();
+					const timer = setTimeout(abort, Math.max(0, deadlineAt - Date.now()));
+					let settle;
+					let rejectTerminal;
+					const terminal = new Promise((resolve, reject) => {
+						settle = resolve;
+						rejectTerminal = reject;
+					});
+					terminal.catch(() => {});
+					let markEnded = () => {};
+					const ended = new Promise((resolve) => markEnded = resolve);
+					cancelActive = abort;
+					const cancelled = () => rejectTerminal?.(/* @__PURE__ */ new Error("Codex turn cancelled or deadline exceeded."));
+					controller.signal.addEventListener("abort", cancelled, { once: true });
+					rpc.observe((message) => {
+						observer.observe(message);
+						const state = observer.state();
+						if (state.usageUpdates > config.maxTurns) throw new Error("Codex observed usage-update limit exceeded.");
+						if (state.terminal) {
+							settle?.();
+							markEnded();
+						}
+					}, (error) => rejectTerminal?.(error));
+					let status = "failed";
+					let failureReason = "native_turn_incomplete";
+					let failureText;
+					try {
+						await rpc.request("turn/start", {
+							threadId,
+							input: [{
+								type: "text",
+								text: input.prompt
+							}]
+						}, controller.signal, deadlineAt);
+						if (controller.signal.aborted) throw new Error("Codex turn cancelled.");
+						await terminal;
+						const state = observer.state();
+						status = state.terminal === "completed" ? "completed" : state.terminal === "interrupted" ? "cancelled" : "failed";
+						if (status !== "completed") invalid = true;
+						if (state.failure) {
+							failureReason = state.failure.reason;
+							failureText = state.failure.text;
+						}
+					} catch (error) {
+						const cause = nativeFailure(error);
+						failureReason = controller.signal.aborted ? "cancelled_or_deadline" : cause?.reason ?? "protocol_or_process_failure";
+						failureText = controller.signal.aborted ? void 0 : cause?.text;
+						status = controller.signal.aborted ? "cancelled" : "failed";
+						invalid = true;
+						const turnId = observer.state().turnId;
+						if (turnId) {
+							await rpc.request("turn/interrupt", {
+								threadId,
+								turnId
+							}, new AbortController().signal, Date.now() + 500).catch(() => {});
+							await Promise.race([ended, setTimeout$1(INTERRUPTED_TURN_END_MS, void 0, { ref: false })]);
+						}
+					} finally {
+						turnReported();
+						clearTimeout(timer);
+						input.signal.removeEventListener("abort", abort);
+						controller.signal.removeEventListener("abort", cancelled);
+						cancelActive = void 0;
+						try {
+							if (invalid) await close();
+						} finally {
+							rpc.observe(() => {}, () => {});
+							observer.finish();
+							if (status !== "completed") input.emit({
+								kind: "lifecycle",
+								nativeSessionId: threadId,
+								nativeTurnId: observer.state().turnId,
+								lifecycle: {
+									state: status,
+									reason: failureReason
+								}
+							});
+							busy = false;
+						}
+					}
+					const state = observer.state();
+					modelChanged ||= state.modelChanged;
+					const usage = reportedUsage(state.usageInvalid ? void 0 : state.usage, previousUsage, model, status === "completed", modelChanged);
+					if (state.usage) previousUsage = state.usage;
+					return {
+						nativeSessionId: threadId,
+						nativeTurnId: state.turnId,
+						text: [state.text, status === "completed" ? "" : failureText ?? "Codex turn did not complete."].filter(Boolean).join("\n\n"),
+						status,
+						reportedUsage: usage,
+						coverage: status === "completed" ? coverage : {
+							...coverage,
+							native: {
+								state: "partial",
+								reason: "Turn ended before complete native evidence was observed."
+							},
+							messages: {
+								state: "partial",
+								reason: "Turn ended before complete messages were observed."
+							},
+							tools: {
+								state: "partial",
+								reason: "Turn ended before all tool outcomes were observed."
+							},
+							usage: {
+								state: "partial",
+								reason: "Turn ended before complete usage was observed."
+							}
+						}
+					};
+				},
+				async cancel() {
+					cancelActive?.();
+					await activeTurn;
+				},
+				close
+			};
+		}
+	};
+}
+// src/lib/local-harness/backends/acp/protocol.ts
+async function deadline(work, signal, until) {
+	signal.throwIfAborted();
+	let timer;
+	let abort;
+	try {
+		return await Promise.race([work, new Promise((_, reject) => {
+			abort = () => reject(/* @__PURE__ */ new Error("ACP operation cancelled."));
+			signal.addEventListener("abort", abort, { once: true });
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("ACP operation deadline exceeded.")), Math.max(0, until - Date.now()));
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+		if (abort) signal.removeEventListener("abort", abort);
+	}
+}
+function stdioStream(stdin, stdout) {
+	return ndJsonStream(Writable.toWeb(stdin), Readable.toWeb(stdout), { maxMessageBytes: 2097152 });
+}
+/** Capture before typed decoding so unknown extensions survive the SDK boundary. */
+function createAcpClient(stream, observe, permission) {
+	const pending = /* @__PURE__ */ new Map();
+	const writer = stream.writable.getWriter();
+	const tapped = {
+		writable: new WritableStream({
+			async write(message) {
+				if ("method" in message && "id" in message) {
+					const params = message.params;
+					if (typeof params?.sessionId === "string") {
+						if (pending.size >= 32) throw new Error("Too many concurrent ACP requests.");
+						pending.set(String(message.id), {
+							method: message.method,
+							sessionId: params.sessionId
+						});
+					}
+				}
+				await writer.write(message);
+			},
+			async close() {
+				pending.clear();
+				await writer.close();
+			},
+			async abort(reason) {
+				pending.clear();
+				await writer.abort(reason);
+			}
+		}),
+		readable: stream.readable.pipeThrough(new TransformStream({ transform(message, controller) {
+			observe(message);
+			if (!("method" in message) && "id" in message) {
+				const request = pending.get(String(message.id));
+				pending.delete(String(message.id));
+				if (request) observe({
+					jsonrpc: "2.0",
+					method: "_runtype/acp_response",
+					params: {
+						sessionId: request.sessionId,
+						requestMethod: request.method,
+						response: message
+					}
+				});
+			}
+			controller.enqueue(message);
+		} }))
+	};
+	return client({ name: "runtype-local-harness" }).onNotification("*", () => {}).onNotification(methods.client.session.update, () => {}).onRequest(methods.client.session.requestPermission, ({ params }) => {
+		permission({
+			kind: "permission",
+			nativeSessionId: params.sessionId,
+			permission: {
+				id: params.toolCall.toolCallId,
+				capability: params.toolCall.name ?? params.toolCall.title ?? "unknown",
+				decision: "deny",
+				source: "acp_client_policy"
+			}
+		});
+		const deny = params.options.find((option) => option.kind === "reject_once");
+		return { outcome: deny ? {
+			outcome: "selected",
+			optionId: deny.optionId
+		} : { outcome: "cancelled" } };
+	}).onRequest("*", () => {
+		throw RequestError.methodNotFound("unsupported_client_capability");
+	}).connect(tapped);
+}
+// src/lib/local-harness/backends/acp/observations.ts
+const status = (value) => value === "completed" ? "succeeded" : value === "failed" ? "failed" : value === "in_progress" ? "running" : value === "pending" ? "pending" : "unknown";
+/** ACP context occupancy and cumulative cost remain separate from native billing observations. */
+function createAcpObserver(sessionId, emit, servers, rawClaude) {
+	const tools = /* @__PURE__ */ new Map();
+	let text = "";
+	let textBytes = 0;
+	let answerTruncated = false;
+	let result;
+	let dropped = false;
+	let rawSeen = false;
+	let bytes = 0;
+	let events = 0;
+	const canonical = (event, native) => {
+		if (!event.tool) {
+			emit(event);
+			return;
+		}
+		const prior = tools.get(event.tool.id);
+		const incoming = Object.fromEntries(Object.entries(event.tool).filter(([, value]) => value != null));
+		if (prior?.native && !native) {
+			delete incoming.input;
+			delete incoming.output;
+			delete incoming.name;
+			delete incoming.nativeName;
+		}
+		const merged = {
+			...prior?.value,
+			...incoming,
+			id: event.tool.id,
+			status: event.tool.status
+		};
+		if (prior?.value.status === "failed") merged.status = "failed";
+		else if (prior?.value.status === "succeeded" && [
+			"unknown",
+			"pending",
+			"running"
+		].includes(merged.status)) merged.status = "succeeded";
+		tools.set(merged.id, {
+			value: merged,
+			native: native || prior?.native === true
+		});
+		emit({
+			...event,
+			tool: merged
+		});
+	};
+	const native = createObserver$1((event) => {
+		if (event.kind !== "native" && event.kind !== "message") canonical(event, true);
+	}, servers);
+	return {
+		observe(message) {
+			if (!("method" in message)) return;
+			const params = object$2(message.params);
+			if (params.sessionId !== sessionId) return;
+			const update = object$2(params.update);
+			if (!("id" in message)) {
+				if (message.method === "session/update" && update.sessionUpdate === "agent_message_chunk") {
+					const content = object$2(update.content);
+					if (content.type === "text" && typeof content.text === "string") {
+						const remaining = answerTruncated ? 0 : HARNESS_LIMITS.maxControlReplyBytes - textBytes;
+						const chunk = Buffer.from(content.text);
+						let end = Math.min(remaining, chunk.length);
+						while (end > 0 && end < chunk.length && (chunk[end] & 192) === 128) end -= 1;
+						text += chunk.subarray(0, end).toString("utf8");
+						textBytes += end;
+						answerTruncated ||= end < chunk.length;
+					}
+				}
+				if (message.method === "_claude/sdkMessage" && rawClaude) {
+					rawSeen = true;
+					const sdk = object$2(params.message);
+					if (sdk.type === "result") {
+						const { type, subtype, session_id, uuid, user_message_uuid, is_error, total_cost_usd, modelUsage } = sdk;
+						result = {
+							type,
+							subtype,
+							session_id,
+							uuid,
+							user_message_uuid,
+							is_error,
+							total_cost_usd,
+							modelUsage
+						};
+					}
+				}
+			}
+			const size = Buffer.byteLength(JSON.stringify(message));
+			bytes += size;
+			events += 1;
+			if (size > HARNESS_LIMITS.maxEventBytes || bytes > HARNESS_LIMITS.maxTurnBytes || events > 1e3) {
+				dropped = true;
+				return;
+			}
+			emit({
+				kind: "native",
+				nativeSessionId: sessionId,
+				native: {
+					protocol: "acp",
+					method: message.method,
+					params
+				},
+				...message.method === "session/update" && typeof update.sessionUpdate === "string" && update.sessionUpdate.endsWith("_chunk") || message.method === "_claude/sdkMessage" && object$2(params.message).type === "stream_event" ? { fragment: true } : {}
+			});
+			if ("id" in message) return;
+			if (message.method === "_claude/sdkMessage" && rawClaude) {
+				native.observe(params.message);
+				return;
+			}
+			if (message.method !== "session/update") return;
+			const common = { nativeSessionId: sessionId };
+			if (update.sessionUpdate === "agent_message_chunk") {
+				const content = object$2(update.content);
+				if (content.type === "text" && typeof content.text === "string") emit({
+					...common,
+					kind: "message",
+					message: {
+						role: "assistant",
+						content: content.text,
+						delta: true
+					}
+				});
+			}
+			if ((update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") && typeof update.toolCallId === "string") {
+				const prior = tools.get(update.toolCallId)?.value;
+				const name = typeof update.name === "string" ? update.name : void 0;
+				const server = name && [...servers].sort((a, b) => b.length - a.length).find((entry) => name.startsWith(`mcp__${entry}__`));
+				canonical({
+					...common,
+					kind: "tool",
+					tool: {
+						id: update.toolCallId,
+						status: update.status == null ? prior?.status ?? "unknown" : status(update.status),
+						...name ? {
+							name,
+							nativeName: name
+						} : {},
+						...typeof update.title === "string" ? { title: update.title } : {},
+						...server ? {
+							mcpServer: server,
+							mcpTool: name.slice(`mcp__${server}__`.length)
+						} : {},
+						...update.rawInput == null ? {} : { input: update.rawInput },
+						...update.rawOutput == null ? {} : { output: update.rawOutput },
+						...!prior ? { startedAt: Date.now() } : {},
+						...["completed", "failed"].includes(String(update.status)) ? { endedAt: Date.now() } : {}
+					}
+				}, false);
+			}
+			if (update.sessionUpdate === "usage_update") {
+				if (typeof update.used === "number" && Number.isFinite(update.used) && update.used >= 0) emit({
+					...common,
+					kind: "usage",
+					usage: {
+						scope: "context",
+						cumulative: false,
+						epoch: sessionId,
+						amount: update.used,
+						unit: "context_tokens"
+					}
+				});
+				const cost = object$2(update.cost);
+				if (!rawClaude && typeof cost.amount === "number" && Number.isFinite(cost.amount) && cost.amount >= 0 && typeof cost.currency === "string") emit({
+					...common,
+					kind: "usage",
+					usage: {
+						scope: "session",
+						cumulative: true,
+						epoch: sessionId,
+						amount: cost.amount,
+						unit: cost.currency
+					}
+				});
+			}
+		},
+		finish() {
+			native.finish();
+			for (const { value } of tools.values()) if (value.status === "running" || value.status === "pending") canonical({
+				kind: "tool",
+				tool: {
+					...value,
+					status: "unknown"
+				}
+			}, false);
+			return {
+				text,
+				result,
+				coverage: {
+					...rawClaude && !rawSeen ? { native: {
+						state: "unavailable",
+						reason: "Negotiated raw SDK extension emitted no evidence."
+					} } : {},
+					...dropped ? {
+						native: {
+							state: "truncated",
+							reason: "ACP capture exceeded the bounded event or turn limit."
+						},
+						tools: {
+							state: "partial",
+							reason: "ACP telemetry exceeded its capture limit."
+						},
+						messages: {
+							state: "partial",
+							reason: "ACP telemetry exceeded its capture limit."
+						}
+					} : {},
+					...answerTruncated ? { controlProjection: {
+						state: "truncated",
+						reason: "Assistant answer exceeded the separate control response limit."
+					} } : {}
+				}
+			};
+		}
+	};
+}
+// src/lib/local-harness/backends/acp/qualification.ts
+const tuple = HARNESS_COMPATIBILITY.claudeAcp;
+const exec = promisify(execFile);
+const ACP_COVERAGE = {
+	tools: { state: "available" },
+	messages: { state: "available" },
+	native: { state: "available" },
+	usage: {
+		state: "partial",
+		reason: "SDK aggregate estimates; adapter helper requests are not individually exposed. ACP context occupancy is separate."
+	},
+	timing: {
+		state: "partial",
+		reason: "Local observation times, not native tool execution timestamps."
+	},
+	lineage: {
+		state: "disabled",
+		reason: "Built-in tools and subagents are disabled in controlled-mcp."
+	},
+	reasoning: {
+		state: "partial",
+		reason: "Only reasoning exposed by the adapter is captured."
+	}
+};
+function acpProvenance(config) {
+	return {
+		harness: "claude",
+		backend: "acp",
+		harnessVersion: tuple.harness,
+		adapterVersion: tuple.adapter,
+		sdkVersion: tuple.sdk,
+		protocolVersion: tuple.protocol,
+		profile: config.profile,
+		coverage: ACP_COVERAGE,
+		configuration: {
+			builtInTools: false,
+			settingSources: [],
+			strictMcpConfig: true,
+			permissionRequests: "deny",
+			authentication: "environment_credentials_only",
+			rawSdkMessages: true,
+			mcpServers: config.mcpServers.map((entry) => entry.name),
+			requestedModel: config.model ?? null
+		}
+	};
+}
+function isolatedEnvironment(root, executable) {
+	return {
+		...controlledEnvironment$1(),
+		HOME: root,
+		CLAUDE_CONFIG_DIR: join(root, ".claude"),
+		CLAUDE_CODE_EXECUTABLE: executable,
+		CLAUDE_AGENT_ACP_PROTOCOL: "v1"
+	};
+}
+function environmentAuthentication() {
+	return [
+		"ANTHROPIC_API_KEY",
+		"ANTHROPIC_AUTH_TOKEN",
+		"CLAUDE_CODE_OAUTH_TOKEN"
+	].some((key) => Boolean(process.env[key]));
+}
+async function executablePath(value) {
+	const paths = isAbsolute(value) || value.includes("/") ? [resolve(value)] : (process.env.PATH ?? "").split(":").map((path) => join(path, value));
+	for (const path of paths) try {
+		await access(path, constants.X_OK);
+		return await realpath(path);
+	} catch {
+		continue;
+	}
+	throw new Error("Qualified ACP executable is unavailable.");
+}
+async function qualify(config, root) {
+	if (!["darwin", "linux"].includes(process.platform) || config.harness !== "claude" || config.backend !== "acp" || config.profile !== "controlled-mcp") throw new Error("ACP supports the qualified Claude controlled-mcp tuple on macOS or Linux only.");
+	if (!config.adapter) throw new Error("Select an explicit pinned ACP adapter with --adapter.");
+	if (!Number.isInteger(config.maxTurns) || config.maxTurns < 1 || !Number.isFinite(config.timeoutMs) || config.timeoutMs <= 0) throw new Error("ACP requires positive turn and timeout limits.");
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of config.mcpServers) {
+		const url = new URL(entry.url);
+		if (!/^[A-Za-z0-9_-]{1,64}$/.test(entry.name) || names.has(entry.name) || url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname))) throw new Error("ACP MCP servers require unique names and HTTPS or loopback HTTP URLs without credentials.");
+		names.add(entry.name);
+	}
+	const [adapter, executable] = await Promise.all([executablePath(config.adapter), executablePath(config.executable ?? "claude")]);
+	const packagePath = createRequire(join(dirname(adapter), "runtype-qualification.cjs")).resolve("@agentclientprotocol/claude-agent-acp/package.json");
+	const manifest = JSON.parse(await readFile(packagePath, "utf8"));
+	const adapterRequire = createRequire(packagePath);
+	const sdk = JSON.parse(await readFile(join(dirname(adapterRequire.resolve("@anthropic-ai/claude-agent-sdk")), "package.json"), "utf8"));
+	if (manifest.name !== "@agentclientprotocol/claude-agent-acp" || manifest.version !== tuple.adapter || sdk.version !== tuple.sdk) throw new Error(`ACP requires claude-agent-acp ${tuple.adapter} with Claude SDK ${tuple.sdk}.`);
+	const env = isolatedEnvironment(root, executable);
+	const [adapterVersion, harnessVersion] = await Promise.all([exec(adapter, ["--version"], {
+		env,
+		timeout: 5e3,
+		maxBuffer: 8192
+	}), exec(executable, ["--version"], {
+		env,
+		timeout: 5e3,
+		maxBuffer: 8192
+	})]);
+	if (adapterVersion.stdout.trim() !== tuple.adapter || harnessVersion.stdout.match(/^(\d+\.\d+\.\d+)/)?.[1] !== tuple.harness) throw new Error(`ACP requires adapter ${tuple.adapter} and Claude ${tuple.harness}.`);
+	return {
+		adapter,
+		executable,
+		env
+	};
+}
+// src/lib/local-harness/backends/acp/index.ts
+function sessionParameters(config, cwd) {
+	return {
+		cwd,
+		mcpServers: config.mcpServers.map(({ name, url, headers }) => ({
+			name,
+			type: "http",
+			url,
+			headers: Object.entries(headers ?? {}).map(([name, value]) => ({
+				name,
+				value
+			}))
+		})),
+		_meta: { claudeCode: {
+			emitRawSDKMessages: true,
+			options: {
+				tools: [],
+				settingSources: [],
+				strictMcpConfig: true,
+				allowedTools: config.mcpServers.map(({ name }) => `mcp__${name}`),
+				allowDangerouslySkipPermissions: false,
+				promptSuggestions: false,
+				settings: { apiKeyHelper: "" },
+				maxTurns: config.maxTurns,
+				...config.model ? { model: config.model } : {}
+			}
+		} }
+	};
+}
+async function discoverMcp(config, signal, until) {
+	await Promise.all(config.mcpServers.map(async (server) => {
+		const client = new Client({
+			name: "runtype-harness-doctor",
+			version: "1"
+		});
+		try {
+			const transport = new StreamableHTTPClientTransport(new URL(server.url), { requestInit: { headers: server.headers } });
+			await deadline(client.connect(transport), signal, until);
+			await deadline(client.listTools(), signal, until);
+		} finally {
+			await deadline(client.close(), new AbortController().signal, Date.now() + HARNESS_LIMITS.cancelGraceMs);
+		}
+	}));
+}
+async function launch(config, signal, until) {
+	const root = await mkdtemp(join(tmpdir(), "runtype-acp-"));
+	const supervisor = createSupervisor();
+	let connection;
+	let active;
+	let permission;
+	let authentication = "unknown";
+	const close = async () => {
+		connection?.close();
+		await supervisor.stop();
+		await rm(root, {
+			recursive: true,
+			force: true
+		});
+	};
+	try {
+		if (!environmentAuthentication()) throw new Error("ACP controlled profile requires an environment API key or OAuth token; local login files are unsupported.");
+		const qualified = await deadline(qualify(config, root), signal, until);
+		const child = supervisor.spawn({
+			command: qualified.adapter,
+			args: [],
+			cwd: root,
+			env: qualified.env
+		});
+		connection = createAcpClient(stdioStream(child.stdin, child.stdout), (message) => {
+			if ("method" in message && message.method === "_auth/status_update") {
+				const kind = object$2(object$2(message.params).authStatus).kind;
+				authentication = kind === "none" ? "absent" : [
+					"api_key",
+					"account",
+					"gateway"
+				].includes(String(kind)) ? "ready" : "unsupported";
+			}
+			active?.(message);
+		}, (event) => permission?.(event));
+		child.on("error", () => connection?.close(/* @__PURE__ */ new Error("ACP adapter process failed.")));
+		child.on("exit", () => connection?.close(/* @__PURE__ */ new Error("ACP adapter process exited.")));
+		const agent = connection.agent;
+		const init = await deadline(agent.request(methods.agent.initialize, {
+			protocolVersion: 1,
+			clientInfo: {
+				name: "runtype",
+				version: "1"
+			},
+			clientCapabilities: {
+				fs: {
+					readTextFile: false,
+					writeTextFile: false
+				},
+				terminal: false
+			}
+		}), signal, until);
+		if (init.protocolVersion !== 1 || init.agentInfo?.name !== "@agentclientprotocol/claude-agent-acp" || init.agentInfo.version !== HARNESS_COMPATIBILITY.claudeAcp.adapter || !init.agentCapabilities?.mcpCapabilities?.http || !init.agentCapabilities.sessionCapabilities?.resume || !init.agentCapabilities.sessionCapabilities.close) throw new Error("ACP adapter did not negotiate the qualified protocol and capabilities.");
+		const params = sessionParameters(config, root);
+		return {
+			agent,
+			sessionId: (await deadline(agent.request(methods.agent.session.new, params), signal, until)).sessionId,
+			params,
+			close,
+			authentication: () => authentication,
+			observe(next, onPermission) {
+				active = next;
+				permission = onPermission;
+			}
+		};
+	} catch (error) {
+		await close();
+		throw error;
+	}
+}
+function createAcpBackend() {
+	return {
+		async doctor(config) {
+			let current;
+			const controller = new AbortController();
+			try {
+				if (!environmentAuthentication()) return {
+					ready: false,
+					authentication: "unsupported",
+					provenance: acpProvenance(config),
+					diagnostics: ["The controlled ACP profile supports environment API keys and OAuth tokens; local login files are not loaded."]
+				};
+				const until = Date.now() + Math.min(config.timeoutMs, 15e3);
+				current = await launch(config, controller.signal, until);
+				await discoverMcp(config, controller.signal, until);
+				const authentication = current.authentication();
+				return {
+					ready: authentication === "ready",
+					authentication,
+					provenance: acpProvenance(config),
+					diagnostics: ["ACP initialized and configured MCP discovery connected without a model request. Credential expiry is not verified."]
+				};
+			} catch {
+				return {
+					ready: false,
+					authentication: "unknown",
+					provenance: acpProvenance(config),
+					diagnostics: [`ACP initialization failed. Requires adapter ${HARNESS_COMPATIBILITY.claudeAcp.adapter}, SDK ${HARNESS_COMPATIBILITY.claudeAcp.sdk}, Claude ${HARNESS_COMPATIBILITY.claudeAcp.harness}, and environment credentials.`]
+				};
+			} finally {
+				controller.abort();
+				await current?.close();
+			}
+		},
+		async start(config, context) {
+			context.signal.throwIfAborted();
+			const current = await launch(config, context.signal, context.deadlineAt);
+			let previous;
+			let resumeBeforePrompt = false;
+			let blocked = false;
+			let closed = false;
+			let cleanupFailed = false;
+			let active;
+			let abort;
+			const session = {
+				id: context.sessionId,
+				async prompt(input) {
+					if (closed || blocked || active) throw new Error("ACP session cannot accept another turn; start a new context.");
+					input.signal.throwIfAborted();
+					const observer = createAcpObserver(current.sessionId, input.emit, config.mcpServers.map((entry) => entry.name), true);
+					let done;
+					active = new Promise((resolve) => {
+						done = resolve;
+					});
+					abort = new AbortController();
+					const cancel = () => abort?.abort();
+					input.signal.addEventListener("abort", cancel, { once: true });
+					const until = Math.min(input.deadlineAt, Date.now() + config.timeoutMs);
+					let status = "failed";
+					try {
+						if (resumeBeforePrompt) {
+							await deadline(current.agent.request(methods.agent.session.resume, {
+								...current.params,
+								sessionId: current.sessionId
+							}), abort.signal, until);
+							resumeBeforePrompt = false;
+						}
+						current.observe(observer.observe, input.emit);
+						const response = await deadline(current.agent.request(methods.agent.session.prompt, {
+							sessionId: current.sessionId,
+							prompt: [{
+								type: "text",
+								text: input.prompt
+							}]
+						}), abort.signal, until);
+						status = response.stopReason === "end_turn" ? "completed" : response.stopReason === "cancelled" ? "cancelled" : "failed";
+						if (status === "completed") resumeBeforePrompt = true;
+						else blocked = true;
+					} catch {
+						status = input.signal.aborted || abort.signal.aborted ? "cancelled" : "failed";
+						blocked = true;
+						try {
+							await deadline(current.agent.notify(methods.agent.session.cancel, { sessionId: current.sessionId }), new AbortController().signal, Date.now() + HARNESS_LIMITS.cancelGraceMs);
+						} catch {
+							blocked = true;
+						}
+						try {
+							await current.close();
+						} catch {
+							cleanupFailed = true;
+							status = "failed";
+							input.emit({
+								kind: "lifecycle",
+								lifecycle: {
+									state: "cleanup_failed",
+									reason: "ACP descendants did not stop cleanly."
+								}
+							});
+						}
+						closed = true;
+					} finally {
+						current.observe();
+						input.signal.removeEventListener("abort", cancel);
+						abort = void 0;
+						active = void 0;
+						done?.();
+					}
+					const captured = observer.finish();
+					if (captured.result?.is_error === true) {
+						status = "failed";
+						blocked = true;
+					}
+					const usage = captured.result ? reportedUsage$1(captured.result, previous) : void 0;
+					if (captured.result) previous = captured.result;
+					return {
+						nativeSessionId: current.sessionId,
+						nativeTurnId: typeof captured.result?.user_message_uuid === "string" ? captured.result.user_message_uuid : void 0,
+						text: captured.text,
+						status,
+						...usage ? { reportedUsage: usage } : {},
+						coverage: {
+							...ACP_COVERAGE,
+							...captured.coverage,
+							...status === "completed" ? {} : { tools: {
+								state: "partial",
+								reason: "Turn interrupted; partial tool evidence is retained."
+							} }
+						}
+					};
+				},
+				async cancel() {
+					blocked = true;
+					abort?.abort();
+					await active;
+				},
+				async close() {
+					if (cleanupFailed) throw new Error("ACP cleanup failed; isolated session files were retained.");
+					if (closed) return;
+					closed = true;
+					await session.cancel();
+					await current.close();
+				}
+			};
+			return session;
+		}
+	};
+}
+// src/lib/local-harness/backend.ts
+function createHarnessBackend(config) {
+	const backend = config.backend === "native" ? config.harness === "claude" ? createClaudeBackend() : createCodexBackend() : config.harness === "claude" ? createAcpBackend() : void 0;
+	if (!backend) throw new Error("This harness backend is not available in this build.");
+	return {
+		...backend,
+		async doctor(configuration) {
+			const result = await backend.doctor(configuration);
+			return {
+				...result,
+				provenance: {
+					...result.provenance,
+					cliVersion: getCliVersion()
+				}
+			};
+		}
+	};
+}
+export { createHarnessBackend };
+