@warlock.js/ai-cli 0.0.0-stage → 5.31.0

package/cjs/index.cjs

@@ -0,0 +1,4576 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _warlock_js_ai = require("@warlock.js/ai");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_child_process = require("node:child_process");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_string_decoder = require("node:string_decoder");
+
+//#region ../../packages/ai-cli/src/errors.ts
+/**
+* A CLI agent error. Extends the framework `ProviderError`, so agents,
+* fallbacks and observers treat it like any other provider failure; branch
+* on `error.type` for the specific reason.
+*
+* @example
+* try {
+*   await claude.run("hi");
+* } catch (error) {
+*   if (error instanceof CliError && error.type === "capability") {
+*     console.error(`Upgrade ${error.adapter}: missing ${error.flag} in ${error.version}`);
+*   }
+* }
+*/
+var CliError = class extends _warlock_js_ai.ProviderError {
+	constructor(message, options) {
+		super(message, options, options.type === "unsupported-option" || options.type === "prompt-transport" ? "PROVIDER_INVALID_REQUEST" : "PROVIDER_ERROR");
+		this.name = "CliError";
+		this.type = options.type;
+		this.adapter = options.adapter;
+		this.flag = options.flag;
+		this.version = options.version;
+		this.executable = options.executable;
+	}
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/model/cli-model.ts
+/** The text of one message; CLI models accept text only. */
+function messageText(message, adapter) {
+	if (typeof message.content === "string") return message.content;
+	return message.content.map((part) => {
+		if (part.type !== "text") throw new CliError(`${adapter}: CLI models accept text only; a "${part.type}" attachment cannot be passed to the CLI.`, {
+			type: "unsupported-option",
+			adapter
+		});
+		return part.text;
+	}).join("\n");
+}
+/**
+* Render an agent conversation into one CLI prompt. System messages become
+* a leading instruction block; a single user turn is passed as-is; a longer
+* history is rendered as a labelled transcript ending with the latest turn.
+*
+* @example
+* renderPrompt([{ role: "system", content: "Be brief." }, { role: "user", content: "Hi" }], "codex");
+* // "Be brief.\n\nHi"
+*/
+function renderPrompt(messages, adapter) {
+	const system = messages.filter((message) => message.role === "system").map((message) => messageText(message, adapter).trim()).filter((text) => text.length > 0);
+	const turns = messages.filter((message) => message.role !== "system");
+	const only = turns.length === 1 ? turns[0] : void 0;
+	const body = only !== void 0 && only.role === "user" ? messageText(only, adapter) : turns.map((message) => {
+		return `${message.role === "user" ? "User" : message.role === "assistant" ? "Assistant" : `Tool result${message.toolCallId ? ` (${message.toolCallId})` : ""}`}:\n${messageText(message, adapter)}`;
+	}).join("\n\n");
+	return [...system, body].filter((part) => part.length > 0).join("\n\n");
+}
+/** Map CLI usage to the framework `Usage` (zeros when the CLI reported none). */
+function toUsage(usage) {
+	if (usage === void 0) return {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	const mapped = {
+		input: usage.input,
+		output: usage.output,
+		total: usage.total
+	};
+	if (usage.cachedTokens !== void 0) mapped.cachedTokens = usage.cachedTokens;
+	if (usage.cacheWriteTokens !== void 0) mapped.cacheWriteTokens = usage.cacheWriteTokens;
+	if (usage.reasoningTokens !== void 0) mapped.reasoningTokens = usage.reasoningTokens;
+	return mapped;
+}
+function abortError(message) {
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+/**
+* A `ModelContract` backed by a CLI agent, so `ai.agent({ model })` — and
+* its budget, guardrail, observer and fallback middleware — can drive a
+* coding CLI.
+*
+* Each call is one fresh CLI session: the conversation is rendered into a
+* single prompt (see {@link renderPrompt}) and the session's final answer
+* becomes the response. The CLI runs its own tools; framework tools cannot
+* be handed to it this way (give the CLI MCP servers with `mcp` instead),
+* so a call carrying `tools` is refused. `stream()` yields the final answer
+* once the session ends — read `session.events` from `agent.run()` for live
+* progress.
+*
+* @example
+* const coder = cli.codex({ cwd: "/srv/repo" });
+* const reviewer = ai.agent({
+*   model: cliModel(coder, { name: "codex" }),
+*   middleware: [budget({ maxTokens: 200_000 })],
+* });
+* const { text } = await reviewer.execute("Review the last commit.");
+*/
+function cliModel(agent, config = {}) {
+	const { adapter } = agent;
+	const capabilities = { reasoning: adapter.effort === true };
+	const execute = async (messages, options = {}) => {
+		if (options.tools !== void 0 && options.tools.length > 0) throw new CliError(`${adapter.title}: a CLI model runs the CLI's own tools; pass framework tools to the CLI as MCP servers (\`mcp\`) instead of agent \`tools\`.`, {
+			type: "unsupported-option",
+			adapter: adapter.name
+		});
+		const { name: _name, pricing: _pricing, ...runDefaults } = config;
+		const effort = options.reasoning?.effort;
+		const result = await (await agent.run(renderPrompt(messages, adapter.name), {
+			...runDefaults,
+			signal: options.signal ?? runDefaults.signal,
+			effort: adapter.effort === true && effort !== void 0 ? effort : runDefaults.effort
+		})).done();
+		if (result.status === "cancelled") throw abortError(result.error ?? `${adapter.name} run was cancelled`);
+		if (result.status !== "completed") throw new CliError(`${adapter.title}: ${result.error ?? `run ${result.status}`}`, {
+			type: "run-failed",
+			adapter: adapter.name,
+			context: {
+				status: result.status,
+				exitCode: result.exitCode,
+				sessionRef: result.sessionRef
+			}
+		});
+		return result;
+	};
+	return {
+		name: config.name ?? config.model ?? agent.options.model ?? adapter.name,
+		provider: adapter.name,
+		capabilities,
+		pricing: config.pricing,
+		async complete(messages, options) {
+			const result = await execute(messages, options);
+			return {
+				content: result.text,
+				finishReason: "stop",
+				usage: toUsage(result.usage)
+			};
+		},
+		async *stream(messages, options) {
+			const result = await execute(messages, options);
+			if (result.text.length > 0) yield {
+				type: "delta",
+				content: result.text
+			};
+			yield {
+				type: "done",
+				finishReason: "stop",
+				usage: toUsage(result.usage)
+			};
+		}
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/spawn/process-tree.ts
+/**
+* Terminate a CLI and everything it started.
+*
+* Coding CLIs spawn shells, language servers and MCP servers, so signalling
+* the direct child alone would leave grandchildren running.
+*
+* - **POSIX** — the child was spawned `detached` (its own process group), so
+*   the whole group gets `SIGTERM`, then `SIGKILL` after `graceMs`.
+* - **Windows** — `taskkill /T /F` walks and kills the PID's tree (console
+*   programs ignore a polite close, so there is no grace step).
+*
+* Only the tree this package spawned is ever signalled: the child's own PID
+* (Windows) or its own process group (POSIX) — never a name, port or
+* pattern. The SIGKILL follows even when the leader exits on SIGTERM, so a
+* grandchild that ignores SIGTERM (and keeps the pipes open) is still
+* reaped; a process group id cannot be reused while any member is alive.
+* Call the returned function once the session's pipes have closed (the
+* whole tree is gone) to cancel that pending SIGKILL.
+*/
+function killProcessTree(child, platform, graceMs) {
+	const pid = child.pid;
+	if (pid === void 0) {
+		child.kill("SIGKILL");
+		return () => void 0;
+	}
+	if (platform === "win32") {
+		(0, node_child_process.spawn)("taskkill", [
+			"/pid",
+			String(pid),
+			"/T",
+			"/F"
+		], { windowsHide: true }).on("error", () => {
+			child.kill("SIGKILL");
+		});
+		return () => void 0;
+	}
+	const signalGroup = (signal) => {
+		try {
+			process.kill(-pid, signal);
+		} catch {
+			try {
+				child.kill(signal);
+			} catch {}
+		}
+	};
+	signalGroup("SIGTERM");
+	const timer = setTimeout(() => signalGroup("SIGKILL"), Math.max(0, graceMs));
+	timer.unref();
+	return () => clearTimeout(timer);
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/spawn/invocation.ts
+/**
+* Bytes `cmd.exe` cannot carry inside a double-quoted argument: a quote ends
+* the quoted span, `%` expands variables even inside quotes, and a newline
+* ends the command (the BatBadBut / CVE-2024-24576 class). An argument
+* holding one of them is refused rather than escaped.
+*/
+const CMD_UNSAFE = /["%\r\n\0]/;
+/** `cmd.exe` command-line limit (8191 characters), with headroom for the wrapper. */
+const CMD_LINE_LIMIT = 8e3;
+/** `CreateProcess` command-line limit (32767 characters), with headroom. */
+const WINDOWS_LINE_LIMIT = 32e3;
+/** Linux `MAX_ARG_STRLEN` (128 KiB per argument), with headroom. */
+const POSIX_ARGUMENT_LIMIT = 120 * 1024;
+/** Conservative total argv budget on POSIX (ARG_MAX is shared with the environment). */
+const POSIX_TOTAL_LIMIT = 512 * 1024;
+/**
+* Quote one argument for a `cmd.exe /s /c "..."` line, or return `null` when
+* it holds a byte cmd cannot quote safely. Inside double quotes `& | < > ^`
+* are literal; trailing backslashes are doubled so the target program's
+* argv parser does not read the closing quote as escaped.
+*/
+function quoteForCmd(argument) {
+	if (CMD_UNSAFE.test(argument)) return null;
+	return `"${argument}${/\\+$/.exec(argument)?.[0] ?? ""}"`;
+}
+/**
+* Build the invocation for a target and argv. A `cmd` target becomes
+* `cmd.exe /d /v:off /s /c ""batch" "arg" …"` — AutoRun disabled, delayed
+* expansion off (so `!` stays literal), each element quoted. Returns a
+* `refused` reason when an argument cannot be quoted safely.
+*/
+function buildInvocation(target, args, comspec) {
+	if (target.type === "direct") return {
+		file: target.file,
+		args: [...target.prefixArgs, ...args],
+		windowsVerbatimArguments: false
+	};
+	const quoted = [];
+	for (const element of [target.file, ...args]) {
+		const safe = quoteForCmd(element);
+		if (safe === null) return { refused: "an argument contains \", %, a newline or a NUL byte, which cmd.exe cannot carry safely" };
+		quoted.push(safe);
+	}
+	return {
+		file: comspec,
+		args: [
+			"/d",
+			"/v:off",
+			"/s",
+			"/c",
+			`"${quoted.join(" ")}"`
+		],
+		windowsVerbatimArguments: true
+	};
+}
+/**
+* Whether an invocation's argv fits the platform's limits. Windows counts
+* the whole command line (8191 for `cmd.exe`, 32767 for `CreateProcess`,
+* each argument quoted); POSIX limits a single argument to 128 KiB on Linux
+* and shares `ARG_MAX` with the environment.
+*/
+function fitsCommandLine(invocation, platform) {
+	if (platform === "win32") return [invocation.file, ...invocation.args].reduce((total, element) => total + element.length + 3, 0) <= (invocation.windowsVerbatimArguments ? CMD_LINE_LIMIT : WINDOWS_LINE_LIMIT);
+	let total = 0;
+	for (const element of [invocation.file, ...invocation.args]) {
+		const bytes = Buffer.byteLength(element, "utf8") + 1;
+		if (bytes > 122880) return false;
+		total += bytes;
+	}
+	return total <= POSIX_TOTAL_LIMIT;
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/probe/probe.ts
+/** How long a single `--help`/`--version` call may take. */
+const PROBE_TIMEOUT_MS = 3e4;
+/** Output cap per probe call; help screens are a few KiB. */
+const PROBE_OUTPUT_LIMIT = 1024 * 1024;
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Whether a help screen lists a flag or subcommand. Flags (`--json`, `-p`)
+* must appear as a whole token — `--json` does not match `--json-schema`;
+* a bare word (`exec`) is matched as a whole word.
+*
+* @example
+* helpLists("  -p, --print  Print response", "--print"); // true
+* helpLists("  --output-format <format>", "--output"); // false
+*/
+function helpLists(help, flag) {
+	const escaped = escapeRegExp(flag);
+	if (flag.startsWith("-")) return new RegExp(`(^|[\\s,\\[(|/"'\`])${escaped}(?=$|[\\s,=\\])|<\\[.:;"'\`])`, "m").test(help);
+	return new RegExp(`(^|[^\\w-])${escaped}(?=$|[^\\w-])`, "m").test(help);
+}
+/** The first version-looking token of `--version` output, else its first line. */
+function parseVersion(output) {
+	const match = /\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?/.exec(output);
+	if (match) return match[0];
+	const firstLine = output.trim().split(/\r?\n/)[0]?.trim();
+	return firstLine && firstLine.length > 0 ? firstLine : "unknown";
+}
+/** Flags a plan requires that the help screen does not list. */
+function missingFlags(help, required) {
+	return required.filter((flag) => !helpLists(help, flag));
+}
+/** Run a probe invocation and capture stdout + stderr (help is printed to either). */
+function capture(input) {
+	return new Promise((resolve) => {
+		const invocation = buildInvocation(input.target, input.args, input.comspec);
+		if ("refused" in invocation) {
+			resolve({
+				output: "",
+				exitCode: null,
+				error: new Error(invocation.refused)
+			});
+			return;
+		}
+		const child = (0, node_child_process.spawn)(invocation.file, invocation.args, {
+			cwd: input.cwd,
+			env: input.env,
+			shell: false,
+			windowsHide: true,
+			windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+			detached: input.platform !== "win32",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const chunks = [];
+		let size = 0;
+		let settled = false;
+		const collect = (chunk) => {
+			if (size < PROBE_OUTPUT_LIMIT) {
+				chunks.push(chunk);
+				size += chunk.length;
+			}
+		};
+		const timer = setTimeout(() => {
+			killProcessTree(child, input.platform, 0);
+		}, PROBE_TIMEOUT_MS);
+		const finish = (exitCode, error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({
+				output: Buffer.concat(chunks).toString("utf8"),
+				exitCode,
+				error
+			});
+		};
+		child.stdout?.on("data", collect);
+		child.stderr?.on("data", collect);
+		child.on("error", (error) => finish(null, error));
+		child.on("close", (code) => finish(code));
+	});
+}
+/**
+* Read the CLI's version and help screens. A help invocation that cannot
+* run at all (spawn error, no output) fails the probe; a non-zero exit with
+* output is accepted, because several CLIs exit 1 after printing help.
+*/
+async function probeCli(input) {
+	const { adapter } = input;
+	const versionRun = await capture({
+		...input,
+		args: adapter.probe.version
+	});
+	if (versionRun.error !== void 0) throw new CliError(`${adapter.title}: could not run "${input.target.executable} ${adapter.probe.version.join(" ")}": ${versionRun.error.message}`, {
+		type: "probe-failed",
+		adapter: adapter.name,
+		executable: input.target.executable,
+		cause: versionRun.error
+	});
+	const version = parseVersion(versionRun.output);
+	const helps = [];
+	for (const args of adapter.probe.help) {
+		const helpRun = await capture({
+			...input,
+			args
+		});
+		if (helpRun.error !== void 0 || helpRun.output.trim().length === 0) throw new CliError(`${adapter.title} ${version}: "${input.target.executable} ${args.join(" ")}" printed no help` + (helpRun.error ? ` (${helpRun.error.message})` : "") + "; the capability probe cannot verify the flags this adapter needs.", {
+			type: "probe-failed",
+			adapter: adapter.name,
+			version,
+			executable: input.target.executable,
+			cause: helpRun.error
+		});
+		helps.push(helpRun.output);
+	}
+	return {
+		executable: input.target.executable,
+		version,
+		help: helps.join("\n")
+	};
+}
+/** Throw a `capability` error naming the first required flag the help does not list. */
+function assertCapabilities(adapter, probe, required) {
+	const missing = missingFlags(probe.help, required);
+	const flag = missing[0];
+	if (flag === void 0) return;
+	const helpCommands = adapter.probe.help.map((args) => `${adapter.command} ${args.join(" ")}`).join(", ");
+	throw new CliError(`${adapter.title} ${probe.version} (${probe.executable}) does not support ${missing.join(", ")}: not listed in "${helpCommands}". This adapter was verified against ${adapter.title} ${adapter.verification.version}; install a compatible version or drop the option that needs ${flag}.`, {
+		type: "capability",
+		adapter: adapter.name,
+		flag,
+		version: probe.version,
+		executable: probe.executable
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/session/environment.ts
+/**
+* Variables a CLI needs to start at all: executable lookup, home and temp
+* directories, locale, TLS/proxy settings and the Windows system set.
+* Passed through even with `inheritEnv: false`.
+*/
+const MINIMAL_ENV = [
+	"PATH",
+	"PATHEXT",
+	"HOME",
+	"USERPROFILE",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"APPDATA",
+	"LOCALAPPDATA",
+	"SYSTEMROOT",
+	"SYSTEMDRIVE",
+	"WINDIR",
+	"COMSPEC",
+	"TEMP",
+	"TMP",
+	"TMPDIR",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"TERM",
+	"SHELL",
+	"USER",
+	"LOGNAME",
+	"XDG_RUNTIME_DIR",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"no_proxy",
+	"NODE_EXTRA_CA_CERTS",
+	"SSL_CERT_FILE",
+	"SSL_CERT_DIR"
+];
+/**
+* Build a CLI's environment. Precedence, lowest first: inherited variables
+* (minus the adapter's managed home variables), the adapter plan, the API
+* key, then the caller's `env`. Windows variable names compare
+* case-insensitively.
+*/
+function buildEnvironment(input) {
+	const normalize = (name) => input.platform === "win32" ? name.toUpperCase() : name;
+	const managed = new Set(input.managed.map(normalize));
+	const allowed = input.inherit === true ? void 0 : new Set([...MINIMAL_ENV, ...input.inherit === false ? [] : input.inherit].map(normalize));
+	const environment = {};
+	for (const [name, value] of Object.entries(input.source)) {
+		if (value === void 0 || managed.has(normalize(name))) continue;
+		if (allowed !== void 0 && !allowed.has(normalize(name))) continue;
+		environment[name] = value;
+	}
+	const assign = (name, value) => {
+		if (input.platform === "win32") {
+			for (const existing of Object.keys(environment)) if (existing.toUpperCase() === name.toUpperCase()) delete environment[existing];
+		}
+		environment[name] = value;
+	};
+	for (const [name, value] of Object.entries(input.plan ?? {})) assign(name, value);
+	if (input.apiKey !== void 0) assign(input.apiKey.name, input.apiKey.value);
+	for (const [name, value] of Object.entries(input.user ?? {})) assign(name, value);
+	return environment;
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/session/run-directory.ts
+/**
+* Create the run's private directory and resolve its config home.
+*
+* The run directory is `mkdtemp`'d under the OS temp dir with mode 0700, so
+* other local users cannot read the MCP config (and the tokens in it)
+* written there. A `"private"` home is a `home/` folder inside it.
+*/
+async function createRunDirectories(home, cwd) {
+	const runDir = await (0, node_fs_promises.mkdtemp)(node_path.default.join((0, node_os.tmpdir)(), "warlock-cli-"));
+	await (0, node_fs_promises.chmod)(runDir, 448);
+	const dispose = async () => {
+		await (0, node_fs_promises.rm)(runDir, {
+			recursive: true,
+			force: true
+		});
+	};
+	if (home === "inherit") return {
+		runDir,
+		homeIsPrivate: false,
+		dispose
+	};
+	if (home === "private") {
+		const privateHome = node_path.default.join(runDir, "home");
+		await (0, node_fs_promises.mkdir)(privateHome, { mode: 448 });
+		return {
+			runDir,
+			home: privateHome,
+			homeIsPrivate: true,
+			dispose
+		};
+	}
+	const ownedHome = node_path.default.resolve(cwd, home);
+	await (0, node_fs_promises.mkdir)(ownedHome, {
+		recursive: true,
+		mode: 448
+	});
+	return {
+		runDir,
+		home: ownedHome,
+		homeIsPrivate: false,
+		dispose
+	};
+}
+/**
+* Write launch files with owner-only permissions (0600; parent directories
+* 0700). Only paths inside the run directory or a private home are
+* accepted, so an adapter can never overwrite a file in a caller-owned
+* home or elsewhere on disk.
+*/
+async function writeLaunchFiles(files, directories) {
+	const roots = [directories.runDir];
+	for (const file of files) {
+		const target = node_path.default.resolve(file.path);
+		if (!roots.some((root) => {
+			const relative = node_path.default.relative(root, target);
+			return relative.length > 0 && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+		})) throw new Error(`Refusing to write ${target}: launch files must live inside the run directory.`);
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(target), {
+			recursive: true,
+			mode: 448
+		});
+		await (0, node_fs_promises.writeFile)(target, file.content, { mode: 384 });
+		await (0, node_fs_promises.chmod)(target, 384);
+	}
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/stream/event-log.ts
+/**
+* An append-only event log that any number of async iterators can read.
+* Each iterator starts at the first event and ends once the log is closed
+* and drained, so a late consumer still sees the whole session.
+*/
+var EventLog = class {
+	constructor() {
+		this.items = [];
+		this.closed = false;
+		this.waiters = [];
+	}
+	push(item) {
+		if (this.closed) return;
+		this.items.push(item);
+		this.wake();
+	}
+	close() {
+		this.closed = true;
+		this.wake();
+	}
+	get size() {
+		return this.items.length;
+	}
+	[Symbol.asyncIterator]() {
+		let index = 0;
+		return { next: async () => {
+			while (index >= this.items.length && !this.closed) await new Promise((resolve) => this.waiters.push(resolve));
+			if (index < this.items.length) {
+				const value = this.items[index];
+				index += 1;
+				return {
+					value,
+					done: false
+				};
+			}
+			return {
+				value: void 0,
+				done: true
+			};
+		} };
+	}
+	wake() {
+		const waiters = this.waiters;
+		this.waiters = [];
+		for (const waiter of waiters) waiter();
+	}
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/stream/line-splitter.ts
+/** Longest line kept in memory; a longer one is dropped (reported via `onOverflow`). */
+const MAX_LINE_BYTES = 32 * 1024 * 1024;
+/**
+* Split a byte stream into lines. Multi-byte UTF-8 characters split across
+* chunks are decoded correctly, `\r\n` and `\n` both end a line, and a final
+* line without a newline is flushed by `end()`.
+*
+* @example
+* const splitter = createLineSplitter((line) => console.log(line));
+* splitter.write(Buffer.from('{"a":1}\n{"b"'));
+* splitter.write(Buffer.from(":2}\n"));
+* splitter.end();
+*/
+function createLineSplitter(onLine, onOverflow = () => void 0) {
+	const decoder = new node_string_decoder.StringDecoder("utf8");
+	let pending = "";
+	let overflowed = false;
+	const consume = (text) => {
+		pending += text;
+		let newline = pending.indexOf("\n");
+		while (newline !== -1) {
+			const line = pending.slice(0, newline).replace(/\r$/, "");
+			pending = pending.slice(newline + 1);
+			if (overflowed) overflowed = false;
+			else onLine(line);
+			newline = pending.indexOf("\n");
+		}
+		if (pending.length > 33554432) {
+			pending = "";
+			if (!overflowed) {
+				overflowed = true;
+				onOverflow();
+			}
+		}
+	};
+	return {
+		write(chunk) {
+			consume(decoder.write(chunk));
+		},
+		end() {
+			consume(decoder.end());
+			if (pending.length > 0 && !overflowed) onLine(pending.replace(/\r$/, ""));
+			pending = "";
+		}
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/session/aggregate.ts
+function sum(a, b) {
+	return a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+}
+/** Add two usages field by field; optional fields stay absent unless either side has them. */
+function addUsage(left, right) {
+	if (left === void 0) return { ...right };
+	const merged = {
+		input: left.input + right.input,
+		output: left.output + right.output,
+		total: left.total + right.total
+	};
+	const cachedTokens = sum(left.cachedTokens, right.cachedTokens);
+	const cacheWriteTokens = sum(left.cacheWriteTokens, right.cacheWriteTokens);
+	const reasoningTokens = sum(left.reasoningTokens, right.reasoningTokens);
+	const costUSD = sum(left.costUSD, right.costUSD);
+	if (cachedTokens !== void 0) merged.cachedTokens = cachedTokens;
+	if (cacheWriteTokens !== void 0) merged.cacheWriteTokens = cacheWriteTokens;
+	if (reasoningTokens !== void 0) merged.reasoningTokens = reasoningTokens;
+	if (costUSD !== void 0) merged.costUSD = costUSD;
+	return merged;
+}
+/**
+* Folds parsed events into the pieces of a `CliResult`: the session ref,
+* usage, every complete message, and the final answer.
+*
+* Final-answer rule: the last `final: true` message (the vendor's own
+* result record) wins; otherwise the newest assistant text — a complete
+* message, or the deltas streamed since the last message or tool activity.
+*/
+var ResultAggregator = class {
+	constructor(resume) {
+		this.messages = [];
+		this.deltaBuffer = "";
+		this.sessionRef = resume;
+	}
+	add(event) {
+		switch (event.type) {
+			case "session.started":
+				if (event.sessionRef) this.sessionRef = event.sessionRef;
+				break;
+			case "message":
+				if (event.delta) {
+					this.deltaBuffer += event.text;
+					break;
+				}
+				if (event.final) {
+					this.finalText = event.text;
+					break;
+				}
+				this.messages.push(event.text);
+				this.lastCompleteText = event.text;
+				this.deltaBuffer = "";
+				break;
+			case "tool.call":
+			case "tool.result":
+				this.flushDeltas();
+				break;
+			case "usage":
+				this.usage = event.cumulative ? { ...event.usage } : addUsage(this.usage, event.usage);
+				break;
+			case "error":
+				if (event.fatal && this.fatalError === void 0) this.fatalError = event.message;
+				break;
+		}
+	}
+	/** Close the stream: deltas never followed by a complete message count as one. */
+	finish() {
+		this.flushDeltas();
+	}
+	get text() {
+		if (this.finalText !== void 0) return this.finalText;
+		return this.deltaBuffer.length > 0 ? this.deltaBuffer : this.lastCompleteText ?? "";
+	}
+	flushDeltas() {
+		if (this.deltaBuffer.trim().length > 0) {
+			this.messages.push(this.deltaBuffer);
+			this.lastCompleteText = this.deltaBuffer;
+		}
+		this.deltaBuffer = "";
+	}
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/session/session.ts
+/**
+* Spawn the CLI and expose it as a {@link CliSession}: stdout lines go
+* through the adapter's parser into a replayable event log, and the
+* process's end becomes the `session.ended` event and the `done()` result.
+*/
+function startSession(input) {
+	const startedAt = Date.now();
+	const log = new EventLog();
+	const aggregator = new ResultAggregator(input.resume);
+	const controller = new AbortController();
+	let stderr = "";
+	let timedOut = false;
+	let cancelled = false;
+	let closed = false;
+	let spawnError;
+	const emit = (events) => {
+		for (const event of events) {
+			aggregator.add(event);
+			log.push(event);
+		}
+	};
+	const parse = (step) => {
+		try {
+			emit(step());
+		} catch (error) {
+			emit([{
+				type: "error",
+				message: `stream parser failed: ${error instanceof Error ? error.message : String(error)}`
+			}]);
+		}
+	};
+	const child = (0, node_child_process.spawn)(input.invocation.file, input.invocation.args, {
+		cwd: input.cwd,
+		env: input.env,
+		shell: false,
+		windowsHide: true,
+		windowsVerbatimArguments: input.invocation.windowsVerbatimArguments,
+		detached: input.platform !== "win32",
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	let cancelPendingKill;
+	const kill = () => {
+		cancelPendingKill = killProcessTree(child, input.platform, input.killGraceMs);
+	};
+	const onAbort = () => {
+		if (closed || timedOut || cancelled) return;
+		cancelled = true;
+		kill();
+	};
+	input.signal?.addEventListener("abort", onAbort, { once: true });
+	controller.signal.addEventListener("abort", onAbort, { once: true });
+	if (input.signal?.aborted) onAbort();
+	const timer = input.timeoutMs !== void 0 && input.timeoutMs > 0 ? setTimeout(() => {
+		if (cancelled) return;
+		timedOut = true;
+		kill();
+	}, input.timeoutMs) : void 0;
+	const splitter = createLineSplitter((line) => parse(() => input.parser.line(line)), () => emit([{
+		type: "error",
+		message: "dropped an output line longer than 32 MiB"
+	}]));
+	child.stdout?.on("data", (chunk) => splitter.write(chunk));
+	child.stderr?.on("data", (chunk) => {
+		stderr = (stderr + chunk.toString("utf8")).slice(-65536);
+	});
+	child.stdin?.on("error", () => void 0);
+	child.stdin?.end(input.stdin ?? "");
+	const done = new Promise((resolve) => {
+		let settled = false;
+		const settle = async (exitCode, signal) => {
+			if (settled) return;
+			settled = true;
+			if (timer !== void 0) clearTimeout(timer);
+			input.signal?.removeEventListener("abort", onAbort);
+			controller.signal.removeEventListener("abort", onAbort);
+			splitter.end();
+			parse(() => input.parser.end());
+			aggregator.finish();
+			const lateRef = input.parser.sessionRef?.();
+			if (lateRef !== void 0 && lateRef.length > 0) aggregator.sessionRef = lateRef;
+			const status = cancelled ? "cancelled" : timedOut ? "timeout" : spawnError === void 0 && exitCode === 0 && aggregator.fatalError === void 0 ? "completed" : "failed";
+			let error;
+			if (status === "failed") {
+				error = aggregator.fatalError ?? (spawnError ? `could not start ${input.invocation.file}: ${spawnError.message}` : `${input.adapter} exited with ${signal ?? `code ${exitCode}`}` + (stderr.trim() ? `: ${stderr.trim().slice(-2e3)}` : ""));
+				if (aggregator.fatalError === void 0) emit([{
+					type: "error",
+					message: error,
+					fatal: true
+				}]);
+			} else if (status === "timeout") error = `${input.adapter} timed out after ${input.timeoutMs} ms`;
+			else if (status === "cancelled") error = `${input.adapter} run was cancelled`;
+			const durationMs = Date.now() - startedAt;
+			log.push({
+				type: "session.ended",
+				status,
+				exitCode,
+				signal,
+				sessionRef: aggregator.sessionRef,
+				durationMs
+			});
+			log.close();
+			try {
+				await input.cleanup();
+			} catch {}
+			resolve({
+				status,
+				text: aggregator.text,
+				messages: [...aggregator.messages],
+				usage: aggregator.usage,
+				sessionRef: aggregator.sessionRef,
+				exitCode,
+				signal,
+				error,
+				stderr,
+				durationMs
+			});
+		};
+		child.on("error", (error) => {
+			if (child.pid === void 0) {
+				closed = true;
+				spawnError = error;
+				settle(null, null);
+			}
+		});
+		child.on("close", (code, signal) => {
+			closed = true;
+			cancelPendingKill?.();
+			settle(code, signal);
+		});
+	});
+	return {
+		adapter: input.adapter,
+		pid: child.pid,
+		events: log,
+		done: () => done,
+		cancel: () => controller.abort()
+	};
+}
+/**
+* A session for a run whose signal was already aborted: nothing is spawned,
+* the stream is a single `session.ended`, and `done()` resolves `cancelled`.
+*/
+function cancelledSession(adapter, resume) {
+	const log = new EventLog();
+	const error = `${adapter} run was cancelled before it started`;
+	log.push({
+		type: "session.ended",
+		status: "cancelled",
+		exitCode: null,
+		signal: null,
+		sessionRef: resume,
+		durationMs: 0
+	});
+	log.close();
+	const result = {
+		status: "cancelled",
+		text: "",
+		messages: [],
+		sessionRef: resume,
+		exitCode: null,
+		signal: null,
+		error,
+		stderr: "",
+		durationMs: 0
+	};
+	return {
+		adapter,
+		pid: void 0,
+		events: log,
+		done: () => Promise.resolve(result),
+		cancel: () => void 0
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/spawn/resolve-command.ts
+/** Windows' default `PATHEXT` when the variable is unset. */
+const DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+/** Case-insensitive read on Windows (`Path` vs `PATH`), exact elsewhere. */
+function readEnv(env, name, platform) {
+	if (platform !== "win32") return env[name];
+	const wanted = name.toUpperCase();
+	for (const [key, value] of Object.entries(env)) if (key.toUpperCase() === wanted && value !== void 0) return value;
+}
+function pathApi(platform) {
+	return platform === "win32" ? node_path.default.win32 : node_path.default.posix;
+}
+/**
+* Find an executable the way the platform's shell would.
+*
+* POSIX walks `PATH`. Windows walks `PATH` trying each `PATHEXT` extension
+* (`claude` → `claude.cmd`), and also accepts a name that already carries
+* one of those extensions. A command containing a path separator is
+* checked directly instead of searched.
+*
+* @example
+* findExecutable("claude", { platform: "win32", env: { PATH: "C:\\npm", PATHEXT: ".EXE;.CMD" }, ... });
+* // → "C:\\npm\\claude.cmd"
+*/
+function findExecutable(command, lookup) {
+	const api = pathApi(lookup.platform);
+	const isWindows = lookup.platform === "win32";
+	const extensions = isWindows ? (readEnv(lookup.env, "PATHEXT", "win32") ?? DEFAULT_PATHEXT).split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0) : [];
+	const candidatesFor = (base) => {
+		if (!isWindows) return [base];
+		const hasKnownExtension = extensions.some((extension) => base.toUpperCase().endsWith(extension.toUpperCase()));
+		const withExtensions = extensions.map((extension) => base + extension.toLowerCase());
+		return hasKnownExtension ? [base, ...withExtensions] : withExtensions;
+	};
+	if ((isWindows ? /[\\/]/.test(command) : command.includes("/")) || api.isAbsolute(command)) return candidatesFor(api.resolve(command)).find((candidate) => lookup.isFile(candidate));
+	const directories = (readEnv(lookup.env, "PATH", lookup.platform) ?? "").split(isWindows ? ";" : ":").map((directory) => directory.trim().replace(/^"(.*)"$/, "$1")).filter((directory) => directory.length > 0);
+	for (const directory of directories) for (const candidate of candidatesFor(api.join(directory, command))) if (lookup.isFile(candidate)) return candidate;
+}
+/**
+* Read the target of an npm (`cmd-shim`) or pnpm `.cmd` shim.
+*
+* Both generators end the shim with a line that runs the target with `%*`;
+* the target is a quoted path relative to the shim's own directory
+* (`"%dp0%\node_modules\pkg\cli.js"` for npm, `"%~dp0\..\pkg\cli.js"` for
+* pnpm). A JavaScript target is run by Node; an `.exe`/`.com` target is run
+* directly. Anything else returns `undefined` and the caller falls back to
+* `cmd.exe`.
+*/
+function parseCmdShim(content, shimPath) {
+	const directory = node_path.default.win32.dirname(shimPath);
+	const line = content.split(/\r?\n/).filter((line) => line.includes("%*")).at(-1);
+	if (line === void 0) return;
+	const raw = [...line.matchAll(/"(%~?dp0%?[\\/][^"]+)"/gi)].map((match) => match[1] ?? "").filter((target) => !/[\\/]node(\.exe)?$/i.test(target)).at(-1);
+	if (raw === void 0) return;
+	const relative = raw.replace(/^%~?dp0%?[\\/]/i, "");
+	const target = node_path.default.win32.resolve(directory, relative);
+	if (/\.(c|m)?js$/i.test(target)) return {
+		type: "node",
+		script: target
+	};
+	if (/\.(exe|com)$/i.test(target)) return {
+		type: "native",
+		file: target
+	};
+}
+/**
+* Resolve a command to something `child_process.spawn` can start without a
+* shell. On Windows a `.cmd`/`.bat` npm shim is unwrapped to
+* `node <script>` (or its native `.exe`), so argv reaches the CLI intact
+* with no `cmd.exe` parsing in between; any other batch file falls back
+* to `cmd.exe`.
+*/
+function resolveSpawnTarget(command, lookup) {
+	const executable = findExecutable(command, lookup);
+	if (executable === void 0) return;
+	if (lookup.platform !== "win32" || !/\.(cmd|bat)$/i.test(executable)) return {
+		type: "direct",
+		file: executable,
+		prefixArgs: [],
+		executable
+	};
+	const shim = parseCmdShim(lookup.readFile(executable) ?? "", executable);
+	if (shim?.type === "node") {
+		const bundledNode = node_path.default.win32.join(node_path.default.win32.dirname(executable), "node.exe");
+		return {
+			type: "direct",
+			file: lookup.isFile(bundledNode) ? bundledNode : lookup.execPath,
+			prefixArgs: [shim.script],
+			executable
+		};
+	}
+	if (shim?.type === "native" && lookup.isFile(shim.file)) return {
+		type: "direct",
+		file: shim.file,
+		prefixArgs: [],
+		executable
+	};
+	return {
+		type: "cmd",
+		file: executable,
+		executable
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/cli-agent.ts
+function isRunnableFile(filePath, platform) {
+	try {
+		if (!(0, node_fs.statSync)(filePath).isFile()) return false;
+		if (platform !== "win32") (0, node_fs.accessSync)(filePath, node_fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** The current machine as a {@link CliHost}. */
+function currentHost() {
+	const platform = process.platform;
+	return {
+		platform,
+		env: process.env,
+		isFile: (filePath) => isRunnableFile(filePath, platform),
+		readFile: (filePath) => {
+			try {
+				return (0, node_fs.readFileSync)(filePath, "utf8");
+			} catch {
+				return;
+			}
+		},
+		execPath: process.execPath,
+		comspec: readEnv(process.env, "ComSpec", platform) ?? "cmd.exe"
+	};
+}
+function unsupported(adapter, message) {
+	return new CliError(`${adapter.title}: ${message}`, {
+		type: "unsupported-option",
+		adapter: adapter.name
+	});
+}
+/**
+* Create a CLI agent from an adapter. The vendor factories
+* (`cli.claudeCode(...)`, `cli.codex(...)`, …) call this with their
+* built-in adapter; call it directly with your own {@link CliAdapter}.
+*
+* @example
+* const agent = createCliAgent(myAdapter, { model: "fast", permission: "standard" });
+* const session = await agent.run("Summarize README.md", { cwd: "/srv/repo" });
+* console.log((await session.done()).text);
+*/
+function createCliAgent(adapter, options = {}, host = currentHost()) {
+	const probes = /* @__PURE__ */ new Map();
+	const command = options.command ?? adapter.command;
+	const resolveTarget = () => {
+		const target = resolveSpawnTarget(command, host);
+		if (target === void 0) throw new CliError(`${adapter.title}: could not find "${command}" on PATH. Install the CLI or pass its absolute path as \`command\`.`, {
+			type: "not-found",
+			adapter: adapter.name
+		});
+		return target;
+	};
+	const probeEnvironment = () => buildEnvironment({
+		source: host.env,
+		inherit: options.inheritEnv ?? true,
+		managed: [],
+		user: options.env,
+		platform: host.platform
+	});
+	const probeTarget = (target) => {
+		const cached = probes.get(target.executable);
+		if (cached !== void 0) return cached;
+		const pending = probeCli({
+			adapter,
+			target,
+			env: probeEnvironment(),
+			cwd: node_path.default.resolve(options.cwd ?? process.cwd()),
+			comspec: host.comspec,
+			platform: host.platform
+		});
+		probes.set(target.executable, pending);
+		pending.catch(() => probes.delete(target.executable));
+		return pending;
+	};
+	const run = async (prompt, runOptions = {}) => {
+		const merged = {
+			...options,
+			...runOptions,
+			env: {
+				...options.env,
+				...runOptions.env
+			},
+			args: [...options.args ?? [], ...runOptions.args ?? []],
+			mcp: runOptions.mcp ?? options.mcp
+		};
+		const permission = merged.permission ?? "standard";
+		if (permission !== "standard" && permission !== "bypass") throw unsupported(adapter, `unknown permission "${String(permission)}" (use "standard" or "bypass").`);
+		if (merged.effort !== void 0 && adapter.effort !== true) throw unsupported(adapter, "this CLI has no reasoning-effort control; drop `effort`.");
+		const mcp = merged.mcp !== void 0 && Object.keys(merged.mcp).length > 0 ? merged.mcp : void 0;
+		if (mcp !== void 0 && adapter.mcp !== true) throw unsupported(adapter, "this CLI cannot attach per-run MCP servers; drop `mcp`.");
+		if (merged.apiKey !== void 0 && adapter.apiKeyEnv.length === 0) throw unsupported(adapter, "this CLI reads no API key from the environment; drop `apiKey`.");
+		const home = options.home ?? "private";
+		if (home !== "inherit" && adapter.homeEnv.length === 0) throw unsupported(adapter, "this CLI cannot relocate its config home; use `home: \"inherit\"`.");
+		const cwd = node_path.default.resolve(merged.cwd ?? process.cwd());
+		const target = resolveTarget();
+		const probe = options.probe === false ? void 0 : await probeTarget(target);
+		if (merged.signal?.aborted) return cancelledSession(adapter.name, merged.resume);
+		const directories = await createRunDirectories(home, cwd);
+		try {
+			let chosen;
+			const reasons = [];
+			for (const transport of adapter.transports) {
+				const context = {
+					prompt,
+					transport,
+					cwd,
+					model: merged.model,
+					effort: merged.effort,
+					permission,
+					resume: merged.resume,
+					mcp,
+					apiKey: merged.apiKey,
+					home: directories.home,
+					homeIsPrivate: directories.homeIsPrivate,
+					runDir: directories.runDir,
+					platform: host.platform
+				};
+				const plan = adapter.plan(context);
+				if (probe !== void 0) assertCapabilities(adapter, probe, plan.requires);
+				const invocation = buildInvocation(target, [
+					...plan.args,
+					...merged.args ?? [],
+					...plan.tail ?? []
+				], host.comspec);
+				if ("refused" in invocation) {
+					reasons.push(`${transport}: ${invocation.refused}`);
+					continue;
+				}
+				if (!fitsCommandLine(invocation, host.platform)) {
+					reasons.push(`${transport}: the command line exceeds the platform limit`);
+					continue;
+				}
+				chosen = {
+					plan,
+					invocation,
+					context
+				};
+				break;
+			}
+			if (chosen === void 0) throw new CliError(`${adapter.title}: the prompt cannot be passed to "${target.executable}" (${reasons.join("; ")}).`, {
+				type: "prompt-transport",
+				adapter: adapter.name,
+				executable: target.executable
+			});
+			await writeLaunchFiles(chosen.plan.files ?? [], directories);
+			const apiKeyEnv = adapter.apiKeyEnv[0];
+			const env = buildEnvironment({
+				source: host.env,
+				inherit: options.inheritEnv ?? true,
+				managed: home === "inherit" ? [] : adapter.homeEnv,
+				plan: host.platform === "win32" ? chosen.plan.env : {
+					PWD: cwd,
+					...chosen.plan.env
+				},
+				user: merged.env,
+				apiKey: merged.apiKey !== void 0 && apiKeyEnv !== void 0 ? {
+					name: apiKeyEnv,
+					value: merged.apiKey
+				} : void 0,
+				platform: host.platform
+			});
+			return startSession({
+				adapter: adapter.name,
+				invocation: chosen.invocation,
+				cwd,
+				env,
+				stdin: chosen.plan.stdin,
+				parser: adapter.parser(chosen.context),
+				signal: merged.signal,
+				timeoutMs: merged.timeoutMs,
+				killGraceMs: options.killGraceMs ?? 2e3,
+				platform: host.platform,
+				resume: merged.resume,
+				cleanup: directories.dispose
+			});
+		} catch (error) {
+			await directories.dispose();
+			throw error;
+		}
+	};
+	const agent = {
+		adapter,
+		options,
+		run,
+		probe: () => probeTarget(resolveTarget()),
+		model: (config) => cliModel(agent, config)
+	};
+	return agent;
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/stream/json-lines.ts
+/** `value` as a JSON object, or `undefined`. */
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** `value` as an array, or an empty array. */
+function asArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+/** A string field, or `undefined`. */
+function stringField(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+/** A finite number field, or `undefined`. */
+function numberField(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** A nested object field, or `undefined`. */
+function recordField(record, key) {
+	return asRecord(record?.[key]);
+}
+/** Tool output as text: strings verbatim, text-block arrays joined, anything else as JSON. */
+function outputText(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0 || value === null) return "";
+	if (Array.isArray(value)) return value.map((item) => {
+		return stringField(asRecord(item), "text") ?? (typeof item === "string" ? item : JSON.stringify(item));
+	}).join("\n");
+	return JSON.stringify(value);
+}
+/** Parse one line as a JSON object; anything else (banners, blank lines) is `undefined`. */
+function parseJsonLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("{")) return;
+	try {
+		return asRecord(JSON.parse(trimmed));
+	} catch {
+		return;
+	}
+}
+/**
+* Build a parser for a JSONL/NDJSON stream. Non-JSON lines (progress
+* banners, warnings) are skipped; each JSON object goes to `onRecord`.
+* `onEnd` may flush buffered state when stdout closes.
+*
+* @example
+* const parser = jsonLinesParser((record) =>
+*   record.type === "text" ? [{ type: "message", text: String(record.text), delta: false }] : [],
+* );
+*/
+function jsonLinesParser(onRecord, onEnd = () => []) {
+	return {
+		line(line) {
+			const record = parseJsonLine(line);
+			return record === void 0 ? [] : onRecord(record);
+		},
+		end: onEnd
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/utils/toml.ts
+function isTable(value) {
+	return typeof value === "object" && !Array.isArray(value);
+}
+/** A bare key when possible, else a quoted one. */
+function tomlKey(key) {
+	return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+/** A TOML scalar or inline value. JSON string escapes are valid TOML basic-string escapes. */
+function inlineValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("TOML cannot encode a non-finite number");
+		return String(value);
+	}
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (Array.isArray(value)) return `[${value.map(inlineValue).join(", ")}]`;
+	return `{ ${Object.entries(value).filter((entry) => entry[1] !== void 0).map(([key, item]) => `${tomlKey(key)} = ${inlineValue(item)}`).join(", ")} }`;
+}
+/**
+* Serialize a table to TOML: scalars and arrays first, then each nested
+* table as a `[dotted.header]` section. Enough for the CLI config files
+* this package writes (Codex and Mistral Vibe MCP sections).
+*
+* @example
+* toToml({ mcp_servers: { docs: { command: "npx", args: ["-y", "docs-mcp"] } } });
+* // [mcp_servers.docs]
+* // command = "npx"
+* // args = ["-y", "docs-mcp"]
+*/
+function toToml(table, prefix = []) {
+	const lines = [];
+	const nested = [];
+	for (const [key, value] of Object.entries(table)) {
+		if (value === void 0) continue;
+		if (isTable(value)) {
+			nested.push([key, value]);
+			continue;
+		}
+		lines.push(`${tomlKey(key)} = ${inlineValue(value)}`);
+	}
+	const sections = [];
+	if (lines.length > 0) sections.push((prefix.length > 0 ? `[${prefix.map(tomlKey).join(".")}]\n` : "") + lines.join("\n"));
+	for (const [key, value] of nested) {
+		const section = toToml(value, [...prefix, key]);
+		if (section.length > 0) sections.push(section.trimEnd());
+	}
+	return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/shared.ts
+/**
+* The prompt as an argv value. A prompt starting with `-` would be read as a
+* flag by the CLI's argument parser, so it gets one leading space (harmless
+* to the model, and no parser treats it as an option).
+*/
+function argvPrompt(prompt) {
+	return prompt.startsWith("-") ? ` ${prompt}` : prompt;
+}
+/** The prompt written to `prompt.txt` in the run directory, for `transport: "file"`. */
+function promptFile(context) {
+	return {
+		path: node_path.default.join(context.runDir, "prompt.txt"),
+		content: context.prompt
+	};
+}
+/**
+* Fail closed when an option needs a file inside the CLI's config home but
+* the home is not private to this run (writing it into a caller-owned or
+* inherited home would leak tokens into it and race concurrent runs).
+*/
+function requirePrivateHome(context, adapter, option) {
+	if (context.home === void 0 || !context.homeIsPrivate) throw new CliError(`${adapter.title} reads ${option} only from its config home; use \`home: "private"\` (the default) for runs with ${option}.`, {
+		type: "unsupported-option",
+		adapter: adapter.name
+	});
+	return context.home;
+}
+/** A `.env` file body. Values are written verbatim; newlines are refused. */
+function dotenvFile(values) {
+	return Object.entries(values).map(([name, value]) => {
+		if (/[\r\n]/.test(value)) throw new Error(`${name} contains a newline and cannot be written to a .env file`);
+		return `${name}=${value}`;
+	}).join("\n").concat("\n");
+}
+/** The framework effort scale, lowest first. */
+const EFFORT_ORDER = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+/**
+* Map a framework effort to a vendor's levels, following the framework
+* rule: an exact level wins; otherwise the nearest higher level the vendor
+* has (so `minimal` becomes `low`); a level above the vendor's highest is
+* clamped to it.
+*
+* @example
+* mapEffort("xhigh", { low: "low", medium: "medium", high: "high" }); // "high"
+* mapEffort("minimal", { low: "low", medium: "medium", high: "high" }); // "low"
+*/
+function mapEffort(effort, levels) {
+	const exact = levels[effort];
+	if (exact !== void 0) return exact;
+	const requested = EFFORT_ORDER.indexOf(effort);
+	const supported = EFFORT_ORDER.filter((level) => levels[level] !== void 0);
+	const chosen = supported.find((level) => EFFORT_ORDER.indexOf(level) > requested) ?? supported.at(-1);
+	const value = chosen === void 0 ? void 0 : levels[chosen];
+	if (value === void 0) throw new Error("mapEffort needs at least one vendor level");
+	return value;
+}
+/**
+* The common `mcpServers` JSON shape (Claude Code, Cursor, Kimi, Droid,
+* Copilot, Amp, Qwen Code …): stdio servers as `command`/`args`/`env`,
+* remote servers as `url`/`headers`. `typeField` adds the `type` key the
+* vendor expects (`"stdio"`, `"http"`, `"sse"`), or a renamed remote
+* transport (`"streamable-http"`).
+*/
+function mcpServersJson(servers, options = {}) {
+	const rendered = {};
+	for (const [name, server] of Object.entries(servers)) {
+		if (server.type === "stdio") {
+			rendered[name] = {
+				...options.typeField ? { type: "stdio" } : {},
+				command: server.command,
+				args: server.args ?? [],
+				...server.env !== void 0 ? { env: server.env } : {},
+				...options.extra
+			};
+			continue;
+		}
+		const urlKey = server.type === "http" ? options.httpUrlKey ?? "url" : "url";
+		rendered[name] = {
+			...options.typeField ? { type: server.type === "http" ? options.httpType ?? "http" : "sse" } : {},
+			[urlKey]: server.url,
+			...server.headers !== void 0 ? { headers: server.headers } : {},
+			...options.extra
+		};
+	}
+	return rendered;
+}
+/** JSON for a config file, pretty-printed with a trailing newline. */
+function jsonFile(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** Build a `CliUsage`, computing `total` when the vendor omits it. */
+function usageOf(fields) {
+	const input = fields.input ?? 0;
+	const output = fields.output ?? 0;
+	const usage = {
+		input,
+		output,
+		total: fields.total ?? input + output
+	};
+	if (fields.cachedTokens !== void 0) usage.cachedTokens = fields.cachedTokens;
+	if (fields.cacheWriteTokens !== void 0) usage.cacheWriteTokens = fields.cacheWriteTokens;
+	if (fields.reasoningTokens !== void 0) usage.reasoningTokens = fields.reasoningTokens;
+	if (fields.costUSD !== void 0) usage.costUSD = fields.costUSD;
+	return usage;
+}
+/** An `unsupported-option` error for an adapter. */
+function unsupportedOption(adapter, message) {
+	return new CliError(`${adapter.title}: ${message}`, {
+		type: "unsupported-option",
+		adapter: adapter.name
+	});
+}
+/** Parse a JSON-encoded tool-arguments string; keeps the raw string when it is not JSON. */
+function parseArguments(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Usage in the Anthropic Messages shape (`input_tokens` excludes cache reads
+* and writes, which are reported separately). `input` is the sum of all
+* three, matching the framework rule that `input` includes cached tokens.
+*/
+function anthropicUsage(usage, costUSD) {
+	if (usage === void 0) return;
+	const read = (key) => {
+		const value = usage[key];
+		return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	};
+	const uncached = read("input_tokens") ?? 0;
+	const cacheRead = read("cache_read_input_tokens");
+	const cacheWrite = read("cache_creation_input_tokens");
+	const output = read("output_tokens") ?? 0;
+	return usageOf({
+		input: uncached + (cacheRead ?? 0) + (cacheWrite ?? 0),
+		output,
+		cachedTokens: cacheRead !== void 0 && cacheRead > 0 ? cacheRead : void 0,
+		cacheWriteTokens: cacheWrite !== void 0 && cacheWrite > 0 ? cacheWrite : void 0,
+		reasoningTokens: read("reasoning_tokens") || void 0,
+		costUSD
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/aider.ts
+/** Local analytics log the adapter asks Aider to write (exact token counts). */
+const ANALYTICS_LOG = "aider-analytics.jsonl";
+/**
+* Aider (`aider`, PyPI `aider-chat`).
+*
+* Verified against the official docs (`aider.chat/docs/scripting.html`,
+* `/docs/config/options.html`, `/docs/config/reasoning.html`) and the
+* source at tag v0.86.2 (`aider/main.py`, `aider/args.py`,
+* `aider/coders/base_coder.py`, `aider/analytics.py`); Aider needs Python
+* 3.10+, so no real `--help` was run, 2026-10-17. The capability probe
+* checks every flag against the installed `--help`.
+*
+* - Headless: `aider --message <text>` (or `--message-file`). Aider has **no
+*   machine-readable output**: the parser reads the plain-text stdout —
+*   startup banner (`Main model: …`), the reply, the usage line
+*   (`Tokens: 2.4k sent, 61 received. Cost: $0.0081 message, …`),
+*   `Applied edit to <path>` (reported as an `edit` tool call) and
+*   `Commit <hash> <message>`. Exact token counts and cost come from the
+*   local `--analytics-log` file (`message_send` events), read when the
+*   stream ends.
+* - Aider exits 0 even when the model call fails, so `litellm.*Error` lines
+*   and the "not able to authenticate you" notice are reported as fatal.
+* - Permissions: Aider applies edits without approval and, headless with
+*   `--yes-always`, never runs the shell commands it suggests; there is no
+*   stricter or looser mode, so `standard` and `bypass` behave the same.
+*   Auto-commits are turned off (`--no-auto-commits`); pass
+*   `args: ["--auto-commits"]` to keep them.
+* - No session ids (`resume` is refused) and no MCP. Chat and input
+*   history are written to the run directory, not the repository.
+* - Home: Aider uses `HOME`; provider keys use their own variables
+*   (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, …) via `env`. Always pass
+*   `model` — without one Aider may start an interactive OAuth flow.
+*/
+const aiderAdapter = {
+	name: "aider",
+	title: "Aider",
+	command: "aider",
+	apiKeyEnv: [],
+	homeEnv: ["HOME", "USERPROFILE"],
+	transports: ["argv", "file"],
+	effort: true,
+	mcp: false,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "0.86.2",
+		verifiedBy: "docs",
+		sources: [
+			"https://aider.chat/docs/scripting.html",
+			"https://aider.chat/docs/config/options.html",
+			"https://aider.chat/docs/config/reasoning.html",
+			"https://github.com/Aider-AI/aider/tree/v0.86.2"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		if (context.resume !== void 0) throw unsupportedOption(aiderAdapter, "Aider has no session ids, so `resume` is not supported.");
+		const args = [
+			"--yes-always",
+			"--no-pretty",
+			"--no-stream",
+			"--no-fancy-input",
+			"--no-auto-commits",
+			"--no-check-update",
+			"--no-show-release-notes",
+			"--no-analytics",
+			"--no-show-model-warnings",
+			"--no-gitignore",
+			"--analytics-log",
+			node_path.default.join(context.runDir, ANALYTICS_LOG),
+			"--chat-history-file",
+			node_path.default.join(context.runDir, "chat-history.md"),
+			"--input-history-file",
+			node_path.default.join(context.runDir, "input-history")
+		];
+		const requires = [
+			"--yes-always",
+			"--no-pretty",
+			"--no-stream",
+			"--no-auto-commits",
+			"--analytics-log",
+			"--chat-history-file",
+			"--input-history-file"
+		];
+		const files = [];
+		let tail;
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--reasoning-effort", mapEffort(context.effort, {
+				low: "low",
+				medium: "medium",
+				high: "high"
+			}));
+			requires.push("--reasoning-effort");
+		}
+		if (context.transport === "file") {
+			const prompt = promptFile(context);
+			files.push(prompt);
+			tail = ["--message-file", prompt.path];
+			requires.push("--message-file");
+		} else {
+			tail = ["--message", argvPrompt(context.prompt)];
+			requires.push("--message");
+		}
+		return {
+			args,
+			tail,
+			env: {
+				...context.home !== void 0 ? {
+					HOME: context.home,
+					USERPROFILE: context.home
+				} : {},
+				TERM: "dumb"
+			},
+			files,
+			requires
+		};
+	},
+	parser: createAiderParser
+};
+/** `2.4k` → 2400, `12k` → 12000, `61` → 61. */
+function parseAiderCount(value) {
+	if (value === void 0) return;
+	const match = /^([\d.]+)(k|M)?$/.exec(value.trim());
+	if (!match) return;
+	const number = Number(match[1]);
+	const scale = match[2] === "k" ? 1e3 : match[2] === "M" ? 1e6 : 1;
+	return Number.isFinite(number) ? Math.round(number * scale) : void 0;
+}
+const TOKENS_LINE = /^Tokens: ([\d.]+[kM]?) sent(?:, ([\d.]+[kM]?) cache write)?(?:, ([\d.]+[kM]?) cache hit)?, ([\d.]+[kM]?) received\.(?:\s+Cost: \$([\d.]+) message, \$([\d.]+) session\.)?/;
+const BANNER = [
+	/^Aider v\d/,
+	/^Main model: /,
+	/^Weak model: /,
+	/^Editor model: /,
+	/^Model: /,
+	/^Git repo: /,
+	/^Repo-map: /,
+	/^Added .+ to the chat\.$/,
+	/^Cost: \$[\d.]+ message, \$[\d.]+ session\.$/,
+	/^Use \/help /
+];
+/** Usage from the analytics log (`message_send` events), summed. */
+function analyticsUsage(context) {
+	if (context === void 0) return;
+	let content;
+	try {
+		content = (0, node_fs.readFileSync)(node_path.default.join(context.runDir, ANALYTICS_LOG), "utf8");
+	} catch {
+		return;
+	}
+	let input = 0;
+	let output = 0;
+	let cost;
+	let seen = false;
+	for (const line of content.split(/\r?\n/)) {
+		const record = parseJsonLine(line);
+		if (stringField(record, "event") !== "message_send") continue;
+		const properties = recordField(record, "properties");
+		seen = true;
+		input += numberField(properties, "prompt_tokens") ?? 0;
+		output += numberField(properties, "completion_tokens") ?? 0;
+		const messageCost = numberField(properties, "cost");
+		if (messageCost !== void 0) cost = (cost ?? 0) + messageCost;
+	}
+	return seen ? {
+		type: "usage",
+		cumulative: true,
+		usage: usageOf({
+			input,
+			output,
+			costUSD: cost
+		})
+	} : void 0;
+}
+/** Parser for Aider's plain-text stdout (plus its analytics log). */
+function createAiderParser(context) {
+	let started = false;
+	let body = [];
+	const flush = () => {
+		const text = body.join("\n").trim();
+		body = [];
+		return text.length > 0 ? [{
+			type: "message",
+			text,
+			delta: false
+		}] : [];
+	};
+	return {
+		line(line) {
+			const events = [];
+			const model = /^Main model: (\S+)/.exec(line);
+			if (!started && (model || line.trim().length > 0 && !BANNER.some((pattern) => pattern.test(line)))) {
+				started = true;
+				events.push({
+					type: "session.started",
+					model: model?.[1]
+				});
+			}
+			if (BANNER.some((pattern) => pattern.test(line))) return events;
+			const tokens = TOKENS_LINE.exec(line);
+			if (tokens) {
+				const cacheWrite = parseAiderCount(tokens[2]);
+				const cacheHit = parseAiderCount(tokens[3]);
+				const sent = parseAiderCount(tokens[1]) ?? 0;
+				events.push(...flush(), {
+					type: "usage",
+					cumulative: false,
+					usage: usageOf({
+						input: sent,
+						output: parseAiderCount(tokens[4]),
+						cachedTokens: cacheHit,
+						cacheWriteTokens: cacheWrite,
+						costUSD: tokens[5] !== void 0 ? Number(tokens[5]) : void 0
+					})
+				});
+				return events;
+			}
+			const applied = /^Applied edit to (.+)$/.exec(line);
+			if (applied) {
+				const file = applied[1] ?? "";
+				const id = `edit-${file}`;
+				events.push(...flush(), {
+					type: "tool.call",
+					id,
+					name: "edit",
+					input: { path: file }
+				}, {
+					type: "tool.result",
+					id,
+					output: line,
+					isError: false
+				});
+				return events;
+			}
+			const commit = /^Commit ([0-9a-f]{7,40}) (.*)$/.exec(line);
+			if (commit) {
+				const id = `commit-${commit[1] ?? ""}`;
+				events.push({
+					type: "tool.call",
+					id,
+					name: "commit",
+					input: {
+						hash: commit[1],
+						message: commit[2]
+					}
+				}, {
+					type: "tool.result",
+					id,
+					output: line,
+					isError: false
+				});
+				return events;
+			}
+			if (/^litellm\.\w+Error:/.test(line) || line.startsWith("The API provider is not able to authenticate you")) {
+				events.push({
+					type: "error",
+					message: line,
+					fatal: true
+				});
+				return events;
+			}
+			if (/^Retrying in [\d.]+ seconds/.test(line)) {
+				events.push({
+					type: "error",
+					message: line
+				});
+				return events;
+			}
+			body.push(line);
+			return events;
+		},
+		end() {
+			const events = flush();
+			const usage = analyticsUsage(context);
+			return usage !== void 0 ? [...events, usage] : events;
+		}
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/claude-stream.ts
+function inclusiveUsage(usage, costUSD) {
+	if (usage === void 0) return;
+	const cached = numberField(usage, "cache_read_input_tokens");
+	const written = numberField(usage, "cache_creation_input_tokens");
+	return usageOf({
+		input: numberField(usage, "input_tokens"),
+		output: numberField(usage, "output_tokens"),
+		total: numberField(usage, "total_tokens"),
+		cachedTokens: cached !== void 0 && cached > 0 ? cached : void 0,
+		cacheWriteTokens: written !== void 0 && written > 0 ? written : void 0,
+		costUSD
+	});
+}
+/**
+* Parser for the Claude Code `stream-json` format, which several CLIs
+* reproduce (Qwen Code, Grok Build's `streaming-messages-json`):
+*
+* - `{"type":"system","subtype":"init","session_id","model",…}`
+* - `{"type":"assistant","message":{"content":[text | tool_use | thinking]}}`
+* - `{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id","content","is_error"}]}}`
+* - `{"type":"stream_event","event":{"type":"content_block_delta","delta":{"type":"text_delta","text"}}}`
+*   (only with partial messages enabled)
+* - `{"type":"result","subtype","is_error","result","session_id","usage","total_cost_usd"}`
+*
+* Per-message `usage` is ignored (Claude Code repeats it on every content
+* block of a message); the `result` totals are reported as cumulative usage.
+* Sub-agent traffic (`parent_tool_use_id` set) is reported like the main
+* thread's, so its tool calls stay visible.
+*/
+function createClaudeStreamParser(options = {}) {
+	const style = options.usage ?? "anthropic";
+	const vendor = options.vendor ?? "The CLI";
+	return jsonLinesParser((record) => {
+		switch (stringField(record, "type")) {
+			case "system": {
+				const subtype = stringField(record, "subtype");
+				if (subtype?.startsWith("error") && stringField(record, "error") !== void 0) return [{
+					type: "error",
+					message: stringField(record, "error") ?? subtype,
+					raw: record
+				}];
+				return subtype === "init" || subtype === "session_start" ? [{
+					type: "session.started",
+					sessionRef: stringField(record, "session_id"),
+					model: stringField(record, "model"),
+					raw: record
+				}] : [];
+			}
+			case "assistant": {
+				const events = [];
+				for (const item of asArray(recordField(record, "message")?.content)) {
+					const block = asRecord(item);
+					const blockType = stringField(block, "type");
+					if (blockType === "text") {
+						const text = stringField(block, "text") ?? "";
+						if (text.length > 0) events.push({
+							type: "message",
+							text,
+							delta: false,
+							raw: record
+						});
+					} else if (blockType === "tool_use" || blockType === "server_tool_use") events.push({
+						type: "tool.call",
+						id: stringField(block, "id") ?? "",
+						name: stringField(block, "name") ?? "",
+						input: block?.input,
+						raw: record
+					});
+				}
+				return events;
+			}
+			case "user": {
+				const events = [];
+				for (const item of asArray(recordField(record, "message")?.content)) {
+					const block = asRecord(item);
+					if (stringField(block, "type") === "tool_result") events.push({
+						type: "tool.result",
+						id: stringField(block, "tool_use_id") ?? "",
+						output: outputText(block?.content),
+						isError: block?.is_error === true,
+						raw: record
+					});
+				}
+				return events;
+			}
+			case "stream_event": {
+				const event = recordField(record, "event");
+				const delta = recordField(event, "delta");
+				if (stringField(event, "type") === "content_block_delta" && stringField(delta, "type") === "text_delta") {
+					const text = stringField(delta, "text") ?? "";
+					return text.length > 0 ? [{
+						type: "message",
+						text,
+						delta: true,
+						raw: record
+					}] : [];
+				}
+				return [];
+			}
+			case "result": {
+				const events = [];
+				const cost = numberField(record, "total_cost_usd");
+				const usage = style === "anthropic" ? anthropicUsage(recordField(record, "usage"), cost) : inclusiveUsage(recordField(record, "usage"), cost);
+				if (usage !== void 0) events.push({
+					type: "usage",
+					usage,
+					cumulative: true,
+					raw: record
+				});
+				const result = stringField(record, "result");
+				if (record.is_error === true) {
+					const errors = asArray(record.errors).map((item) => typeof item === "string" ? item : stringField(asRecord(item), "message") ?? "").filter((item) => item.length > 0).join("; ");
+					const message = stringField(recordField(record, "error"), "message") || stringField(record, "error") || errors || result || `${vendor} run ended with ${stringField(record, "subtype") ?? "an error"}`;
+					events.push({
+						type: "error",
+						message,
+						fatal: true,
+						raw: record
+					});
+				} else if (result !== void 0 && result.length > 0) events.push({
+					type: "message",
+					text: result,
+					delta: false,
+					final: true,
+					raw: record
+				});
+				return events;
+			}
+			default: return [];
+		}
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/amp.ts
+/**
+* Amp (`amp`, npm `@ampcode/cli`; `@sourcegraph/amp` is a shim to it).
+*
+* Verified against the real `amp --help` of 0.0.1792254886-g14d018 and the
+* docs (`ampcode.com/docs/cli/{streaming-json,execute-mode,settings}`,
+* `/docs/tools`), 2026-10-17.
+*
+* - Headless: `amp -x <prompt> --stream-json` (with `-x` and no message,
+*   stdin is the prompt); resume is `amp threads continue <T-id> -x …`.
+*   Threads are kept unarchived (`--no-archive-after-execute`) so they can
+*   be continued.
+* - Stream: Claude Code-compatible (`system/init` with `session_id`
+*   `T-…`, `assistant` text/`tool_use`, `user` `tool_result`, `result`),
+*   no deltas and no cost.
+* - Model: Amp has no model flag; the mode (`-m low|medium|high|ultra`)
+*   picks model and effort, so `effort` maps to the mode and `model` is
+*   refused.
+* - Permissions: Amp's own rules (tools run without approval by default;
+*   anything that needs approval is rejected in execute mode). Bypass passes
+*   `--dangerously-allow-all`, which the CLI accepts but no longer lists in
+*   `--help`, so it is not part of the capability probe — a CLI that drops
+*   it rejects the run as an unknown option.
+* - MCP: `--mcp-config <file>` holding the server map itself (no
+*   `mcpServers` wrapper), written to the run directory.
+* - Home: Amp follows XDG (`$XDG_CONFIG_HOME/amp/settings.json`); auth
+*   `AMP_API_KEY`; update checks off with `AMP_SKIP_UPDATE_CHECK=1`.
+*/
+const ampAdapter = {
+	name: "amp",
+	title: "Amp",
+	command: "amp",
+	apiKeyEnv: ["AMP_API_KEY"],
+	homeEnv: [
+		"XDG_CONFIG_HOME",
+		"XDG_DATA_HOME",
+		"XDG_STATE_HOME",
+		"XDG_CACHE_HOME"
+	],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "0.0.1792254886-g14d018",
+		verifiedBy: "help",
+		sources: [
+			"https://ampcode.com/docs/cli/streaming-json",
+			"https://ampcode.com/docs/cli/execute-mode",
+			"https://ampcode.com/docs/cli/settings"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		if (context.model !== void 0) throw unsupportedOption(ampAdapter, "Amp has no model flag; its mode picks the model — use `effort` instead of `model`.");
+		const args = context.resume !== void 0 ? [
+			"threads",
+			"continue",
+			context.resume
+		] : [];
+		const requires = [
+			"--execute",
+			"--stream-json",
+			"--no-archive-after-execute"
+		];
+		const files = [];
+		if (context.resume !== void 0) requires.push("threads");
+		args.push("--stream-json", "--no-archive-after-execute");
+		if (context.effort !== void 0) {
+			args.push("--mode", mapEffort(context.effort, {
+				low: "low",
+				medium: "medium",
+				high: "high",
+				max: "ultra"
+			}));
+			requires.push("--mode");
+		}
+		if (context.permission === "bypass") args.push("--dangerously-allow-all");
+		if (context.mcp !== void 0) {
+			const file = node_path.default.join(context.runDir, "amp-mcp.json");
+			files.push({
+				path: file,
+				content: jsonFile(mcpServersJson(context.mcp))
+			});
+			args.push("--mcp-config", file);
+			requires.push("--mcp-config");
+		}
+		const env = { AMP_SKIP_UPDATE_CHECK: "1" };
+		if (context.home !== void 0) {
+			env.XDG_CONFIG_HOME = node_path.default.join(context.home, "config");
+			env.XDG_DATA_HOME = node_path.default.join(context.home, "data");
+			env.XDG_STATE_HOME = node_path.default.join(context.home, "state");
+			env.XDG_CACHE_HOME = node_path.default.join(context.home, "cache");
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? ["--execute", argvPrompt(context.prompt)] : ["--execute"],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env,
+			files,
+			requires
+		};
+	},
+	parser: () => createClaudeStreamParser({
+		usage: "anthropic",
+		vendor: "Amp"
+	})
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/antigravity.ts
+/**
+* Google Antigravity CLI (`agy`), installed by the
+* `antigravity.google/cli/install.sh` script (no npm package). Not Gemini
+* CLI, which it succeeds.
+*
+* Verified against the official docs only (the binary is distributed by a
+* curl installer, which was not run): `antigravity.google/docs/cli/headless`,
+* `/docs/cli/reference`, `/docs/mcp`, `/docs/permissions`, `/docs/settings`,
+* `/docs/install`, and the 1.4.0 release notes, 2026-10-17. The capability
+* probe checks every flag against the installed binary's `--help`.
+*
+* - Headless: `agy -p <prompt> --output-format stream-json`. For long
+*   prompts the adapter uses the documented stdin protocol instead:
+*   `--input-format stream-json` with one `{"event":"user","message":
+*   {"content":…}}` line, then stdin is closed.
+* - Stream: `{"event":X, X:{…}}` lines — `init` (with `conversation_id`),
+*   `step_update` (`agent_response` steps carry `text_delta` fragments;
+*   `tool` steps carry `tool_info{name,parameters,output,error}` with call
+*   and result together, correlated by `step_index`) and a final `result`
+*   (`status`, `response`, `error`, cumulative `usage`). No cost field.
+* - Permissions: headless soft-denies tools that need approval (the run
+*   continues and exits 0); bypass is `--dangerously-skip-permissions`.
+* - Home: no variable relocates `~/.gemini`, so a private/owned home sets
+*   `HOME` (and `USERPROFILE`). MCP goes to
+*   `$HOME/.gemini/config/mcp_config.json` (remote servers use `serverUrl`).
+* - Auth: `GEMINI_API_KEY` only works with `"modelProvider": "gemini"` in
+*   `$HOME/.gemini/antigravity-cli/settings.json`; the adapter writes that
+*   file when `apiKey` is set on a private home.
+*/
+const antigravityAdapter = {
+	name: "antigravity",
+	title: "Antigravity CLI",
+	command: "agy",
+	apiKeyEnv: ["GEMINI_API_KEY"],
+	homeEnv: ["HOME", "USERPROFILE"],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "1.4.0",
+		verifiedBy: "docs",
+		sources: [
+			"https://antigravity.google/docs/cli/headless",
+			"https://antigravity.google/docs/cli/reference",
+			"https://antigravity.google/docs/mcp",
+			"https://antigravity.google/docs/permissions",
+			"https://github.com/google-antigravity/antigravity-cli"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = ["--output-format", "stream-json"];
+		const requires = ["--output-format", "stream-json"];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--effort", mapEffort(context.effort, {
+				low: "low",
+				medium: "medium",
+				high: "high"
+			}));
+			requires.push("--effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--conversation", context.resume);
+			requires.push("--conversation");
+		}
+		if (context.permission === "bypass") {
+			args.push("--dangerously-skip-permissions");
+			requires.push("--dangerously-skip-permissions");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, antigravityAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, ".gemini", "config", "mcp_config.json"),
+				content: jsonFile({ mcpServers: antigravityMcp(context.mcp) })
+			});
+		}
+		if (context.apiKey !== void 0 && context.homeIsPrivate && context.home !== void 0) files.push({
+			path: node_path.default.join(context.home, ".gemini", "antigravity-cli", "settings.json"),
+			content: jsonFile({ modelProvider: "gemini" })
+		});
+		const env = context.home !== void 0 ? {
+			HOME: context.home,
+			USERPROFILE: context.home
+		} : {};
+		if (context.transport === "stdin") {
+			args.push("--input-format", "stream-json");
+			requires.push("--input-format");
+			return {
+				args,
+				stdin: `${JSON.stringify({
+					event: "user",
+					message: { content: context.prompt }
+				})}\n`,
+				env,
+				files,
+				requires
+			};
+		}
+		requires.push("-p");
+		return {
+			args,
+			tail: ["-p", argvPrompt(context.prompt)],
+			env,
+			files,
+			requires
+		};
+	},
+	parser: createAntigravityParser
+};
+function antigravityMcp(servers) {
+	const rendered = {};
+	for (const [name, server] of Object.entries(servers)) rendered[name] = server.type === "stdio" ? {
+		command: server.command,
+		args: server.args ?? [],
+		...server.env ? { env: server.env } : {}
+	} : {
+		serverUrl: server.url,
+		...server.headers ? { headers: server.headers } : {}
+	};
+	return rendered;
+}
+function stepUsage(usage) {
+	if (usage === void 0) return;
+	const cached = numberField(usage, "cache_read_tokens");
+	return usageOf({
+		input: numberField(usage, "input_tokens"),
+		output: numberField(usage, "output_tokens"),
+		total: numberField(usage, "total_tokens"),
+		cachedTokens: cached !== void 0 && cached > 0 ? cached : void 0,
+		reasoningTokens: numberField(usage, "thinking_tokens") || void 0
+	});
+}
+/** Parser for `agy -p … --output-format stream-json`. */
+function createAntigravityParser() {
+	return jsonLinesParser((record) => {
+		const event = stringField(record, "event");
+		if (event === "init") {
+			const init = recordField(record, "init");
+			return [{
+				type: "session.started",
+				sessionRef: stringField(record, "conversation_id"),
+				model: stringField(init, "model"),
+				raw: record
+			}];
+		}
+		if (event === "step_update") {
+			const step = recordField(record, "step_update");
+			const stepType = stringField(step, "step_type");
+			const events = [];
+			if (stepType === "agent_response") {
+				const text = stringField(step, "text_delta") ?? "";
+				if (text.length > 0) events.push({
+					type: "message",
+					text,
+					delta: true,
+					raw: record
+				});
+			}
+			if (stepType === "tool" && stringField(step, "state") === "DONE") {
+				const info = recordField(step, "tool_info");
+				const error = recordField(info, "error");
+				const id = `step-${numberField(step, "step_index") ?? 0}`;
+				events.push({
+					type: "tool.call",
+					id,
+					name: stringField(info, "name") ?? stringField(step, "tool_name") ?? "",
+					input: info?.parameters,
+					raw: record
+				}, {
+					type: "tool.result",
+					id,
+					output: error !== void 0 ? stringField(error, "message") ?? stringField(error, "type") ?? "tool failed" : stringField(info, "output") ?? "",
+					isError: error !== void 0,
+					raw: record
+				});
+			}
+			const usage = stepUsage(recordField(step, "usage"));
+			if (usage !== void 0) events.push({
+				type: "usage",
+				usage,
+				cumulative: false,
+				raw: record
+			});
+			return events;
+		}
+		if (event === "result") {
+			const result = recordField(record, "result");
+			const events = [];
+			const usage = stepUsage(recordField(result, "usage"));
+			if (usage !== void 0) events.push({
+				type: "usage",
+				usage,
+				cumulative: true,
+				raw: record
+			});
+			const status = stringField(result, "status");
+			if (status !== void 0 && status !== "SUCCESS") events.push({
+				type: "error",
+				message: stringField(result, "error") || `Antigravity run ended ${status}`,
+				fatal: true,
+				raw: record
+			});
+			else {
+				const response = stringField(result, "response") ?? "";
+				if (response.length > 0) events.push({
+					type: "message",
+					text: response,
+					delta: false,
+					final: true,
+					raw: record
+				});
+			}
+			return events;
+		}
+		return [];
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/claude-code.ts
+/**
+* Claude Code (`claude`, npm `@anthropic-ai/claude-code`).
+*
+* Verified against the real `claude --help` of 2.1.302, the event types of
+* `@anthropic-ai/claude-agent-sdk` 0.3.302 and the docs
+* (`code.claude.com/docs/en/{headless,cli-reference,mcp,env-vars,
+* permission-modes}`), 2026-10-17.
+*
+* - Headless: `claude -p --output-format stream-json --verbose
+*   --include-partial-messages <prompt>` (`--verbose` is required with
+*   stream-json in print mode); piped stdin is the prompt when no positional
+*   prompt is given.
+* - Stream: `system/init` (`session_id`), `stream_event` text deltas,
+*   `assistant` messages (text / `tool_use`), `user` messages with
+*   `tool_result`, and a final `result` (`result`, `usage`,
+*   `total_cost_usd`, `is_error`, `errors[]`).
+* - Permissions: print mode auto-denies anything that would prompt; bypass
+*   is `--dangerously-skip-permissions` (Claude Code refuses it as root
+*   outside a recognised sandbox).
+* - MCP: `--mcp-config <file>` with `{"mcpServers":…}`, written to the run
+*   directory.
+* - Home: `CLAUDE_CONFIG_DIR`; auth `ANTHROPIC_API_KEY` (or a home you
+*   logged in to); auto-update off with `DISABLE_AUTOUPDATER=1`.
+*/
+const claudeCodeAdapter = {
+	name: "claude-code",
+	title: "Claude Code",
+	command: "claude",
+	apiKeyEnv: ["ANTHROPIC_API_KEY"],
+	homeEnv: ["CLAUDE_CONFIG_DIR"],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "2.1.302",
+		verifiedBy: "help",
+		sources: [
+			"https://code.claude.com/docs/en/headless",
+			"https://code.claude.com/docs/en/cli-reference",
+			"https://code.claude.com/docs/en/mcp",
+			"https://code.claude.com/docs/en/env-vars"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"--print",
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			"--include-partial-messages"
+		];
+		const requires = [
+			"--print",
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			"--include-partial-messages"
+		];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--effort", mapEffort(context.effort, {
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				max: "max"
+			}));
+			requires.push("--effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--dangerously-skip-permissions");
+			requires.push("--dangerously-skip-permissions");
+		}
+		if (context.mcp !== void 0) {
+			const file = node_path.default.join(context.runDir, "mcp.json");
+			files.push({
+				path: file,
+				content: jsonFile({ mcpServers: mcpServersJson(context.mcp, { typeField: true }) })
+			});
+			args.push("--mcp-config", file);
+			requires.push("--mcp-config");
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? [argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env: {
+				...context.home !== void 0 ? { CLAUDE_CONFIG_DIR: context.home } : {},
+				DISABLE_AUTOUPDATER: "1"
+			},
+			files,
+			requires
+		};
+	},
+	parser: () => createClaudeStreamParser({
+		usage: "anthropic",
+		vendor: "Claude Code"
+	})
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/codex.ts
+/**
+* OpenAI Codex CLI (`codex`, npm `@openai/codex`).
+*
+* Verified against the real `codex exec --help` / `codex exec resume
+* --help` of 0.163.0, the source at tag `rust-v0.163.0` (`exec_events.rs`,
+* the JSONL event processor, `cli.rs`) and the docs (non-interactive mode,
+* config reference), 2026-10-17.
+*
+* - Headless: `codex exec --json --skip-git-repo-check <prompt>` (`-` reads
+*   the prompt from stdin); resume is `codex exec resume … <thread_id>
+*   <prompt>`.
+* - Stream: `thread.started` (`thread_id`), `item.started`/`item.completed`
+*   with `item.type` `agent_message`, `reasoning`, `command_execution`,
+*   `file_change`, `mcp_tool_call`, `web_search`, `error`; `turn.completed`
+*   with the thread's cumulative `usage` (`input_tokens` includes
+*   `cached_input_tokens`); `turn.failed` and `error` on failure. No text
+*   deltas and no cost field.
+* - Permissions: exec never asks (approval policy "never"); `standard` keeps
+*   Codex's default **read-only** sandbox — allow edits with
+*   `args: ["-c", "sandbox_mode=workspace-write"]`. Bypass is
+*   `--dangerously-bypass-approvals-and-sandbox`.
+* - Effort: `-c model_reasoning_effort=<level>`.
+* - MCP: no flag. With a private home the servers go into
+*   `$CODEX_HOME/config.toml` (0600). With a caller-owned or inherited home
+*   they are passed as `-c mcp_servers.<name>.…` overrides that carry only
+*   the command, args and URL; secret `env` values and headers travel in the
+*   process environment, named through `env_vars` / `env_http_headers`.
+* - Home `CODEX_HOME`; auth `CODEX_API_KEY`.
+*/
+const codexAdapter = {
+	name: "codex",
+	title: "Codex CLI",
+	command: "codex",
+	apiKeyEnv: ["CODEX_API_KEY"],
+	homeEnv: ["CODEX_HOME"],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["exec", "--help"], [
+			"exec",
+			"resume",
+			"--help"
+		]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "0.163.0",
+		verifiedBy: "help",
+		sources: [
+			"https://developers.openai.com/codex/noninteractive",
+			"https://developers.openai.com/codex/config-reference",
+			"https://github.com/openai/codex/blob/rust-v0.163.0/codex-rs/exec/src/exec_events.rs"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = ["exec"];
+		const requires = [
+			"exec",
+			"--json",
+			"--skip-git-repo-check"
+		];
+		const files = [];
+		const env = {};
+		if (context.resume !== void 0) {
+			args.push("resume");
+			requires.push("resume");
+		}
+		args.push("--json", "--skip-git-repo-check", "-c", "check_for_update_on_startup=false");
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			const effort = mapEffort(context.effort, {
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				max: "max"
+			});
+			args.push("-c", `model_reasoning_effort=${effort}`);
+			requires.push("--config");
+		}
+		if (context.permission === "bypass") {
+			args.push("--dangerously-bypass-approvals-and-sandbox");
+			requires.push("--dangerously-bypass-approvals-and-sandbox");
+		}
+		if (context.mcp !== void 0) if (context.home !== void 0 && context.homeIsPrivate) files.push({
+			path: node_path.default.join(context.home, "config.toml"),
+			content: toToml({ mcp_servers: codexMcpTable(context.mcp) })
+		});
+		else {
+			args.push(...codexMcpOverrides(context.mcp, env));
+			requires.push("--config");
+		}
+		if (context.home !== void 0) env.CODEX_HOME = context.home;
+		const prompt = context.transport === "argv" ? argvPrompt(context.prompt) : "-";
+		return {
+			args,
+			tail: context.resume !== void 0 ? [context.resume, prompt] : [prompt],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env,
+			files,
+			requires
+		};
+	},
+	parser: createCodexParser
+};
+/** `[mcp_servers.<name>]` tables for a private `config.toml`. */
+function codexMcpTable(servers) {
+	const table = {};
+	for (const [name, server] of Object.entries(servers)) {
+		if (server.type === "sse") throw unsupportedOption(codexAdapter, `MCP server "${name}" uses SSE; Codex supports stdio and streamable HTTP.`);
+		table[name] = server.type === "stdio" ? {
+			command: server.command,
+			args: server.args ?? [],
+			env: server.env
+		} : {
+			url: server.url,
+			http_headers: server.headers
+		};
+	}
+	return table;
+}
+/** A TOML string for a `-c key=value` override. */
+function tomlString(value) {
+	return JSON.stringify(value);
+}
+/**
+* `-c` overrides that carry no secret: env values and header values are put
+* in `env` (the Codex process environment) and only their names go to argv.
+*/
+function codexMcpOverrides(servers, env) {
+	const overrides = [];
+	const claim = (name, value) => {
+		if (env[name] !== void 0 && env[name] !== value) throw unsupportedOption(codexAdapter, `two MCP servers set ${name} to different values; with a shared home they share one environment.`);
+		env[name] = value;
+	};
+	for (const [name, server] of Object.entries(servers)) {
+		const prefix = `mcp_servers.${tomlKey(name)}`;
+		if (server.type === "sse") throw unsupportedOption(codexAdapter, `MCP server "${name}" uses SSE; Codex supports stdio and streamable HTTP.`);
+		if (server.type === "stdio") {
+			overrides.push("-c", `${prefix}.command=${tomlString(server.command)}`);
+			overrides.push("-c", `${prefix}.args=[${(server.args ?? []).map(tomlString).join(",")}]`);
+			const names = Object.keys(server.env ?? {});
+			for (const [key, value] of Object.entries(server.env ?? {})) claim(key, value);
+			if (names.length > 0) overrides.push("-c", `${prefix}.env_vars=[${names.map(tomlString).join(",")}]`);
+			continue;
+		}
+		overrides.push("-c", `${prefix}.url=${tomlString(server.url)}`);
+		const headers = Object.entries(server.headers ?? {});
+		if (headers.length > 0) {
+			const mapping = headers.map(([header, value], index) => {
+				const variable = `WARLOCK_MCP_${name.replace(/\W/g, "_").toUpperCase()}_HEADER_${index}`;
+				claim(variable, value);
+				return `${tomlString(header)}=${tomlString(variable)}`;
+			});
+			overrides.push("-c", `${prefix}.env_http_headers={${mapping.join(",")}}`);
+		}
+	}
+	return overrides;
+}
+const TOOL_ITEMS = new Set([
+	"command_execution",
+	"file_change",
+	"mcp_tool_call",
+	"web_search",
+	"collab_tool_call"
+]);
+function toolCall(item) {
+	switch (stringField(item, "type")) {
+		case "command_execution": return {
+			name: "shell",
+			input: { command: item.command }
+		};
+		case "file_change": return {
+			name: "apply_patch",
+			input: { changes: item.changes }
+		};
+		case "mcp_tool_call": return {
+			name: `${stringField(item, "server") ?? "mcp"}.${stringField(item, "tool") ?? "tool"}`,
+			input: item.arguments
+		};
+		case "web_search": return {
+			name: "web_search",
+			input: { query: item.query }
+		};
+		default: return {
+			name: stringField(item, "type") ?? "tool",
+			input: item
+		};
+	}
+}
+function toolResult(item) {
+	const status = stringField(item, "status");
+	const failed = status === "failed" || status === "declined";
+	switch (stringField(item, "type")) {
+		case "command_execution": {
+			const exitCode = numberField(item, "exit_code");
+			return {
+				output: stringField(item, "aggregated_output") ?? "",
+				isError: failed || exitCode !== void 0 && exitCode !== 0
+			};
+		}
+		case "mcp_tool_call": {
+			const error = stringField(recordField(item, "error"), "message");
+			return error !== void 0 ? {
+				output: error,
+				isError: true
+			} : {
+				output: outputText(recordField(item, "result")?.content),
+				isError: failed
+			};
+		}
+		default: return {
+			output: outputText(item.changes ?? item.result ?? ""),
+			isError: failed
+		};
+	}
+}
+/** Parser for `codex exec --json`. */
+function createCodexParser() {
+	const announced = /* @__PURE__ */ new Set();
+	return jsonLinesParser((record) => {
+		const type = stringField(record, "type");
+		const item = recordField(record, "item");
+		const itemType = stringField(item, "type");
+		const id = stringField(item, "id") ?? "";
+		if (type === "thread.started") return [{
+			type: "session.started",
+			sessionRef: stringField(record, "thread_id"),
+			raw: record
+		}];
+		if (type === "item.started" && item !== void 0 && itemType !== void 0 && TOOL_ITEMS.has(itemType)) {
+			announced.add(id);
+			return [{
+				type: "tool.call",
+				id,
+				...toolCall(item),
+				raw: record
+			}];
+		}
+		if (type === "item.completed" && item !== void 0) {
+			if (itemType === "agent_message") {
+				const text = stringField(item, "text") ?? "";
+				return text.length > 0 ? [{
+					type: "message",
+					text,
+					delta: false,
+					raw: record
+				}] : [];
+			}
+			if (itemType === "error") return [{
+				type: "error",
+				message: stringField(item, "message") ?? "error",
+				raw: record
+			}];
+			if (itemType !== void 0 && TOOL_ITEMS.has(itemType)) {
+				const events = [];
+				if (!announced.has(id)) events.push({
+					type: "tool.call",
+					id,
+					...toolCall(item),
+					raw: record
+				});
+				events.push({
+					type: "tool.result",
+					id,
+					...toolResult(item),
+					raw: record
+				});
+				return events;
+			}
+			return [];
+		}
+		if (type === "turn.completed") {
+			const usage = recordField(record, "usage");
+			if (usage === void 0) return [];
+			const cached = numberField(usage, "cached_input_tokens");
+			const written = numberField(usage, "cache_write_input_tokens");
+			return [{
+				type: "usage",
+				cumulative: true,
+				usage: usageOf({
+					input: numberField(usage, "input_tokens"),
+					output: numberField(usage, "output_tokens"),
+					cachedTokens: cached !== void 0 && cached > 0 ? cached : void 0,
+					cacheWriteTokens: written !== void 0 && written > 0 ? written : void 0,
+					reasoningTokens: numberField(usage, "reasoning_output_tokens") || void 0
+				}),
+				raw: record
+			}];
+		}
+		if (type === "turn.failed") return [{
+			type: "error",
+			message: stringField(recordField(record, "error"), "message") ?? "Codex turn failed",
+			fatal: true,
+			raw: record
+		}];
+		if (type === "error") return [{
+			type: "error",
+			message: stringField(record, "message") ?? "Codex error",
+			fatal: true,
+			raw: record
+		}];
+		return [];
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/copilot.ts
+/** Usage file (inside the run directory) Copilot writes on exit. */
+const USAGE_FILE = "copilot-usage.json";
+/**
+* GitHub Copilot CLI (`copilot`, npm `@github/copilot`).
+*
+* Verified against the real `copilot --help` of 1.0.98, the JSONL writer in
+* the shipped CLI, the event types of `@github/copilot-sdk` 1.0.22 and the
+* docs (`docs.github.com/copilot/how-tos/copilot-cli/…`, programmatic and
+* command references), 2026-10-17.
+*
+* - Headless: `copilot -p <prompt> --output-format json --stream on`
+*   (piped stdin is the prompt when `-p` is absent). Stream lines are
+*   session events `{type,data,id,timestamp}`: `assistant.message_delta`
+*   (`deltaContent`), `assistant.message` (`content`),
+*   `tool.execution_start` (`toolCallId`, `toolName`, `arguments`),
+*   `tool.execution_complete` (`success`, `result.content`,
+*   `error.message`), `session.error`, and a final CLI-built `result`
+*   (`sessionId`, `exitCode`, premium-request usage).
+* - Tokens are not in the stream; the adapter passes `--usage-output-file`
+*   and reads `modelMetrics.*.usage` from it when the stream ends. Billing
+*   is in premium requests, so no USD cost is reported.
+* - Permissions: unapproved tool requests are auto-denied in `-p` mode;
+*   bypass is `--allow-all` (tools, paths and URLs). `--no-ask-user` and
+*   `--no-auto-update` are always passed.
+* - MCP: `--additional-mcp-config @<file>` (`mcpServers`, `type`
+*   `local`/`http`/`sse`, `tools: ["*"]`), written to the run directory.
+* - Home `COPILOT_HOME`; auth `COPILOT_GITHUB_TOKEN`. Resume with
+*   `--session-id <id>`.
+*/
+const copilotAdapter = {
+	name: "copilot",
+	title: "Copilot CLI",
+	command: "copilot",
+	apiKeyEnv: ["COPILOT_GITHUB_TOKEN"],
+	homeEnv: ["COPILOT_HOME"],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "1.0.98",
+		verifiedBy: "help",
+		sources: [
+			"https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically",
+			"https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference",
+			"https://www.npmjs.com/package/@github/copilot"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"--output-format",
+			"json",
+			"--stream",
+			"on",
+			"--no-ask-user",
+			"--no-auto-update",
+			"--usage-output-file",
+			node_path.default.join(context.runDir, USAGE_FILE)
+		];
+		const requires = [
+			"--output-format",
+			"--stream",
+			"--no-ask-user",
+			"--no-auto-update",
+			"--usage-output-file"
+		];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--reasoning-effort", context.effort);
+			requires.push("--reasoning-effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--session-id", context.resume);
+			requires.push("--session-id");
+		}
+		if (context.permission === "bypass") {
+			args.push("--allow-all");
+			requires.push("--allow-all");
+		}
+		if (context.mcp !== void 0) {
+			const file = node_path.default.join(context.runDir, "copilot-mcp.json");
+			const servers = mcpServersJson(context.mcp, {
+				typeField: true,
+				extra: { tools: ["*"] }
+			});
+			for (const server of Object.values(servers)) if (server.type === "stdio") server.type = "local";
+			files.push({
+				path: file,
+				content: jsonFile({ mcpServers: servers })
+			});
+			args.push("--additional-mcp-config", `@${file}`);
+			requires.push("--additional-mcp-config");
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? ["-p", argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env: context.home !== void 0 ? { COPILOT_HOME: context.home } : void 0,
+			files,
+			requires: context.transport === "argv" ? [...requires, "-p"] : requires
+		};
+	},
+	parser: createCopilotParser
+};
+/** Token usage summed over `modelMetrics` of the usage file. */
+function usageFileEvent(context) {
+	if (context === void 0) return;
+	let report;
+	try {
+		report = parseJsonLine((0, node_fs.readFileSync)(node_path.default.join(context.runDir, USAGE_FILE), "utf8"));
+	} catch {
+		return;
+	}
+	const metrics = recordField(report, "modelMetrics");
+	if (metrics === void 0) return;
+	let input = 0;
+	let output = 0;
+	let cached = 0;
+	let written = 0;
+	let reasoning = 0;
+	for (const value of Object.values(metrics)) {
+		const usage = recordField(asRecord(value), "usage");
+		input += numberField(usage, "inputTokens") ?? 0;
+		output += numberField(usage, "outputTokens") ?? 0;
+		cached += numberField(usage, "cacheReadTokens") ?? 0;
+		written += numberField(usage, "cacheWriteTokens") ?? 0;
+		reasoning += numberField(usage, "reasoningTokens") ?? 0;
+	}
+	return {
+		type: "usage",
+		cumulative: true,
+		usage: usageOf({
+			input,
+			output,
+			cachedTokens: cached > 0 ? cached : void 0,
+			cacheWriteTokens: written > 0 ? written : void 0,
+			reasoningTokens: reasoning > 0 ? reasoning : void 0
+		}),
+		raw: report
+	};
+}
+/** Parser for `copilot -p … --output-format json` (plus its usage file). */
+function createCopilotParser(context) {
+	let started = false;
+	let sessionRef;
+	return {
+		...jsonLinesParser((record) => {
+			const events = [];
+			const type = stringField(record, "type");
+			const data = recordField(record, "data");
+			if (!started) {
+				started = true;
+				events.push({
+					type: "session.started",
+					sessionRef: stringField(data, "sessionId"),
+					raw: record
+				});
+			}
+			switch (type) {
+				case "assistant.message_delta": {
+					const text = stringField(data, "deltaContent") ?? "";
+					if (text.length > 0) events.push({
+						type: "message",
+						text,
+						delta: true,
+						raw: record
+					});
+					break;
+				}
+				case "assistant.message": {
+					const text = stringField(data, "content") ?? "";
+					if (text.length > 0) events.push({
+						type: "message",
+						text,
+						delta: false,
+						raw: record
+					});
+					break;
+				}
+				case "tool.execution_start":
+					events.push({
+						type: "tool.call",
+						id: stringField(data, "toolCallId") ?? "",
+						name: stringField(data, "toolName") ?? "",
+						input: data?.arguments,
+						raw: record
+					});
+					break;
+				case "tool.execution_complete": {
+					const success = data?.success === true;
+					events.push({
+						type: "tool.result",
+						id: stringField(data, "toolCallId") ?? "",
+						output: success ? outputText(recordField(data, "result")?.content) : stringField(recordField(data, "error"), "message") ?? "tool failed",
+						isError: !success,
+						raw: record
+					});
+					break;
+				}
+				case "session.error":
+					events.push({
+						type: "error",
+						message: stringField(data, "message") ?? "Copilot session error",
+						fatal: true,
+						raw: record
+					});
+					break;
+				case "result":
+					sessionRef = stringField(record, "sessionId") ?? sessionRef;
+					break;
+				case "error":
+					events.push({
+						type: "error",
+						message: stringField(record, "message") ?? "error",
+						raw: record
+					});
+					break;
+			}
+			return events;
+		}, () => {
+			const usage = usageFileEvent(context);
+			return usage !== void 0 ? [usage] : [];
+		}),
+		sessionRef: () => sessionRef
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/cursor.ts
+/**
+* Cursor CLI (`cursor-agent`, also installed as `agent`), installed by the
+* `cursor.com/install` script (no official npm package).
+*
+* Verified against the official docs (`cursor.com/docs/cli/{headless,mcp}`,
+* `/docs/cli/reference/{output-format,parameters,authentication,
+* permissions,configuration}`) and the option strings of the
+* 2026.10.16-e3cb207 release bundle (read, not executed), 2026-10-17. The
+* capability probe checks every flag against the installed `--help`.
+*
+* - Headless: `cursor-agent -p --output-format stream-json --trust <prompt>`;
+*   with no positional prompt, stdin is the prompt. `--trust` is passed
+*   because print mode exits in a directory that was never trusted — the
+*   run's `cwd` is the caller's explicit choice.
+* - Stream: `system/init` (`session_id`, `model`), `user` echo, `assistant`
+*   messages (`message.content[].text`), `tool_call` `started`/`completed`
+*   (`call_id`; the tool is the single key of `tool_call`, e.g.
+*   `readToolCall{args,result{success}}`), and a final `result` with
+*   `usage{inputTokens (net of cache), outputTokens, cacheReadTokens,
+*   cacheWriteTokens}`. Errors are not JSON: stderr and a non-zero exit.
+* - Permissions: headless default is the allowlist mode (unlisted actions are
+*   rejected, changes only proposed); bypass is `--force`.
+* - MCP: no flag; `$HOME/.cursor/mcp.json` (the path ignores
+*   `CURSOR_CONFIG_DIR`), plus `--approve-mcps` — needs a private home.
+* - Home: `HOME`/`USERPROFILE`, `CURSOR_CONFIG_DIR` and `CURSOR_DATA_DIR`
+*   are pointed into it. Auth: `CURSOR_API_KEY`.
+*/
+const cursorAdapter = {
+	name: "cursor",
+	title: "Cursor CLI",
+	command: "cursor-agent",
+	apiKeyEnv: ["CURSOR_API_KEY"],
+	homeEnv: [
+		"HOME",
+		"USERPROFILE",
+		"CURSOR_CONFIG_DIR",
+		"CURSOR_DATA_DIR"
+	],
+	transports: ["argv", "stdin"],
+	effort: false,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "2026.10.16-e3cb207",
+		verifiedBy: "docs",
+		sources: [
+			"https://cursor.com/docs/cli/headless",
+			"https://cursor.com/docs/cli/reference/output-format",
+			"https://cursor.com/docs/cli/reference/parameters",
+			"https://cursor.com/docs/cli/mcp"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"--print",
+			"--output-format",
+			"stream-json",
+			"--trust"
+		];
+		const requires = [
+			"--print",
+			"--output-format",
+			"stream-json",
+			"--trust"
+		];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--force");
+			requires.push("--force");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, cursorAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, ".cursor", "mcp.json"),
+				content: jsonFile({ mcpServers: mcpServersJson(context.mcp, { typeField: true }) })
+			});
+			args.push("--approve-mcps");
+			requires.push("--approve-mcps");
+		}
+		const env = context.home !== void 0 ? {
+			HOME: context.home,
+			USERPROFILE: context.home,
+			CURSOR_CONFIG_DIR: node_path.default.join(context.home, ".cursor"),
+			CURSOR_DATA_DIR: node_path.default.join(context.home, ".cursor")
+		} : {};
+		return {
+			args,
+			tail: context.transport === "argv" ? [argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env,
+			files,
+			requires
+		};
+	},
+	parser: createCursorParser
+};
+/** `readToolCall` → `read`; the documented `function{name}` fallback is used as-is. */
+function toolOf(toolCall) {
+	const fn = recordField(toolCall, "function");
+	if (fn !== void 0) return {
+		name: stringField(fn, "name") ?? "function",
+		body: fn
+	};
+	const key = Object.keys(toolCall ?? {})[0] ?? "tool";
+	return {
+		name: key.replace(/ToolCall$/, ""),
+		body: recordField(toolCall, key)
+	};
+}
+/** Parser for `cursor-agent -p --output-format stream-json`. */
+function createCursorParser() {
+	return jsonLinesParser((record) => {
+		switch (stringField(record, "type")) {
+			case "system": return stringField(record, "subtype") === "init" ? [{
+				type: "session.started",
+				sessionRef: stringField(record, "session_id"),
+				model: stringField(record, "model"),
+				raw: record
+			}] : [];
+			case "assistant": {
+				const text = asArray(recordField(record, "message")?.content).map((block) => stringField(asRecord(block), "text") ?? "").join("");
+				return text.length > 0 ? [{
+					type: "message",
+					text,
+					delta: false,
+					raw: record
+				}] : [];
+			}
+			case "tool_call": {
+				const id = stringField(record, "call_id") ?? "";
+				const { name, body } = toolOf(recordField(record, "tool_call"));
+				if (stringField(record, "subtype") === "started") return [{
+					type: "tool.call",
+					id,
+					name,
+					input: body?.args ?? parseArguments(body?.arguments),
+					raw: record
+				}];
+				if (stringField(record, "subtype") === "completed") {
+					const result = recordField(body, "result");
+					const success = recordField(result, "success");
+					const content = stringField(success, "content");
+					return [{
+						type: "tool.result",
+						id,
+						output: success !== void 0 ? content ?? outputText(success) : outputText(result),
+						isError: success === void 0,
+						raw: record
+					}];
+				}
+				return [];
+			}
+			case "result": {
+				const events = [];
+				const usage = recordField(record, "usage");
+				if (usage !== void 0) {
+					const cacheRead = numberField(usage, "cacheReadTokens") ?? 0;
+					const cacheWrite = numberField(usage, "cacheWriteTokens") ?? 0;
+					events.push({
+						type: "usage",
+						cumulative: true,
+						usage: usageOf({
+							input: (numberField(usage, "inputTokens") ?? 0) + cacheRead + cacheWrite,
+							output: numberField(usage, "outputTokens"),
+							cachedTokens: cacheRead > 0 ? cacheRead : void 0,
+							cacheWriteTokens: cacheWrite > 0 ? cacheWrite : void 0
+						}),
+						raw: record
+					});
+				}
+				if (record.is_error === true) events.push({
+					type: "error",
+					message: stringField(record, "result") || "Cursor CLI reported an error",
+					fatal: true,
+					raw: record
+				});
+				return events;
+			}
+			default: return [];
+		}
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/droid.ts
+/**
+* Factory Droid (`droid`, npm `droid` / `@factory/cli`).
+*
+* Verified against the real `droid exec --help` of 0.244.0, a real
+* `droid exec` run without credentials (init and error lines), the field
+* names in the shipped code and the docs (`docs.factory.ai/cli/droid-exec`,
+* `/cli/configuration/mcp`), 2026-10-17.
+*
+* - Headless: `droid exec -o stream-json <prompt>` (or `-f <file>`).
+* - Stream: `system/init` (`session_id`, `model`), whole `message` records
+*   (`role`, `text`), `tool_call` (`id`, `toolName`, `parameters`),
+*   `tool_result` (`id`, `isError`, `value` | `error.message`), a final
+*   `completion` (`finalText`, `usage` with Anthropic-style
+*   `input_tokens`/`cache_read_input_tokens`/`cache_creation_input_tokens`,
+*   read with Anthropic semantics) and `error` (`source`, `message`).
+*   Billing is in Factory credits; no USD cost is reported.
+* - Permissions: `standard` is Droid's default **read-only** autonomy; raise
+*   it with `args: ["--auto", "medium"]` (low | medium | high). Bypass is
+*   `--skip-permissions-unsafe`. Blocked actions end the run non-zero.
+* - MCP: `<home>/.factory/mcp.json` (`mcpServers`); the home is relocated
+*   with `FACTORY_HOME_OVERRIDE` (found in the shipped code and confirmed
+*   with `droid mcp list`), so per-run MCP needs a private home.
+* - Auth: `FACTORY_API_KEY`.
+*/
+const droidAdapter = {
+	name: "droid",
+	title: "Factory Droid",
+	command: "droid",
+	apiKeyEnv: ["FACTORY_API_KEY"],
+	homeEnv: ["FACTORY_HOME_OVERRIDE"],
+	transports: ["argv", "file"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["exec", "--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "0.244.0",
+		verifiedBy: "help",
+		sources: [
+			"https://docs.factory.ai/cli/droid-exec/overview",
+			"https://docs.factory.ai/cli/configuration/mcp",
+			"https://www.npmjs.com/package/droid"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"exec",
+			"--output-format",
+			"stream-json",
+			"--cwd",
+			context.cwd
+		];
+		const requires = [
+			"--output-format",
+			"stream-json",
+			"--cwd"
+		];
+		const files = [];
+		let tail;
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--reasoning-effort", context.effort);
+			requires.push("--reasoning-effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--session-id", context.resume);
+			requires.push("--session-id");
+		}
+		if (context.permission === "bypass") {
+			args.push("--skip-permissions-unsafe");
+			requires.push("--skip-permissions-unsafe");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, droidAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, ".factory", "mcp.json"),
+				content: jsonFile({ mcpServers: mcpServersJson(context.mcp, { typeField: true }) })
+			});
+		}
+		if (context.transport === "file") {
+			const prompt = promptFile(context);
+			files.push(prompt);
+			tail = ["--file", prompt.path];
+			requires.push("--file");
+		} else tail = [argvPrompt(context.prompt)];
+		return {
+			args,
+			tail,
+			env: {
+				...context.home !== void 0 ? { FACTORY_HOME_OVERRIDE: context.home } : {},
+				FACTORY_DROID_AUTO_UPDATE_ENABLED: "false"
+			},
+			files,
+			requires
+		};
+	},
+	parser: createDroidParser
+};
+/** Parser for `droid exec -o stream-json`. */
+function createDroidParser() {
+	return jsonLinesParser((record) => {
+		switch (stringField(record, "type")) {
+			case "system": return stringField(record, "subtype") === "init" ? [{
+				type: "session.started",
+				sessionRef: stringField(record, "session_id"),
+				model: stringField(record, "model"),
+				raw: record
+			}] : [];
+			case "message": {
+				const text = stringField(record, "text") ?? "";
+				return stringField(record, "role") === "assistant" && text.length > 0 ? [{
+					type: "message",
+					text,
+					delta: false,
+					raw: record
+				}] : [];
+			}
+			case "tool_call": return [{
+				type: "tool.call",
+				id: stringField(record, "id") ?? "",
+				name: stringField(record, "toolName") ?? stringField(record, "toolId") ?? "",
+				input: record.parameters,
+				raw: record
+			}];
+			case "tool_result": {
+				const error = recordField(record, "error");
+				const isError = record.isError === true || error !== void 0;
+				return [{
+					type: "tool.result",
+					id: stringField(record, "id") ?? "",
+					output: isError && error !== void 0 ? stringField(error, "message") ?? "" : outputText(record.value),
+					isError,
+					raw: record
+				}];
+			}
+			case "completion": {
+				const events = [];
+				const usage = anthropicUsage(recordField(record, "usage"));
+				if (usage !== void 0) {
+					const thinking = recordField(record, "usage")?.thinking_tokens;
+					if (typeof thinking === "number" && thinking > 0) usage.reasoningTokens = thinking;
+					events.push({
+						type: "usage",
+						usage,
+						cumulative: true,
+						raw: record
+					});
+				}
+				const text = stringField(record, "finalText") ?? "";
+				if (text.length > 0) events.push({
+					type: "message",
+					text,
+					delta: false,
+					final: true,
+					raw: record
+				});
+				return events;
+			}
+			case "error": return [{
+				type: "error",
+				message: stringField(record, "message") ?? "Droid reported an error",
+				fatal: true,
+				raw: record
+			}];
+			default: return [];
+		}
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/grok.ts
+/**
+* Grok Build (`grok`) — xAI's official coding-agent CLI, installed by the
+* `x.ai/cli/install.sh` script (no npm package).
+*
+* Verified against the docs and source only (the binary is distributed by
+* a curl installer, which was not run): the repo user guide
+* `crates/codegen/xai-grok-pager/docs/user-guide/{14-headless-mode,
+* 07-mcp-servers,05-configuration,22-permissions-and-safety}.md`, the clap
+* definitions in `xai-grok-pager/src/app/cli.rs` and the headless reducer
+* `headless/reducer/acp.rs`, at source version 1.0.45; latest stable 1.0.62
+* (2026-10-17). The capability probe checks every flag against the
+* installed binary's `--help` before the first run.
+*
+* - Headless: `grok -p <prompt>` or `--prompt-file <path>`; piped stdin is
+*   not read. `--output-format streaming-json` prints `type`-tagged lines:
+*   `text`, `thought`, `tool_call`, `tool_call_update`, `usage` (per model
+*   response, `input_tokens` uncached) and a final `end` (session id, totals,
+*   `total_cost_usd`); failures print `{"type":"error","message"}`.
+* - Permissions: headless mode answers every approval request with
+*   "cancelled" (auto-deny); bypass is `--always-approve`.
+* - MCP: no flag; `[mcp_servers.<name>]` in `$GROK_HOME/config.toml`.
+* - Auth: `XAI_API_KEY`. Update checks are disabled with
+*   `GROK_DISABLE_AUTOUPDATER=1`.
+*/
+const grokAdapter = {
+	name: "grok",
+	title: "Grok Build",
+	command: "grok",
+	apiKeyEnv: ["XAI_API_KEY"],
+	homeEnv: ["GROK_HOME"],
+	transports: ["argv", "file"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "1.0.62",
+		verifiedBy: "docs",
+		sources: [
+			"https://docs.x.ai/build/cli/headless-scripting",
+			"https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/14-headless-mode.md",
+			"https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/07-mcp-servers.md"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = ["--output-format", "streaming-json"];
+		const requires = ["--output-format", "streaming-json"];
+		const files = [];
+		let tail;
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--reasoning-effort", context.effort);
+			requires.push("--reasoning-effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--always-approve");
+			requires.push("--always-approve");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, grokAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, "config.toml"),
+				content: toToml({ mcp_servers: grokMcp(context.mcp) })
+			});
+		}
+		if (context.transport === "file") {
+			const prompt = promptFile(context);
+			files.push(prompt);
+			tail = ["--prompt-file", prompt.path];
+			requires.push("--prompt-file");
+		} else {
+			tail = ["-p", argvPrompt(context.prompt)];
+			requires.push("-p");
+		}
+		return {
+			args,
+			tail,
+			env: {
+				...context.home !== void 0 ? { GROK_HOME: context.home } : {},
+				GROK_DISABLE_AUTOUPDATER: "1"
+			},
+			files,
+			requires
+		};
+	},
+	parser: createGrokParser
+};
+function grokMcp(servers) {
+	const table = {};
+	for (const [name, server] of Object.entries(servers)) {
+		if (server.type === "sse") throw unsupportedOption(grokAdapter, `MCP server "${name}" uses SSE; Grok Build supports stdio and HTTP servers.`);
+		table[name] = server.type === "stdio" ? {
+			command: server.command,
+			args: server.args ?? [],
+			env: server.env
+		} : {
+			url: server.url,
+			headers: server.headers
+		};
+	}
+	return table;
+}
+/** Parser for `grok -p … --output-format streaming-json`. */
+function createGrokParser() {
+	let started = false;
+	let sessionRef;
+	return {
+		...jsonLinesParser((record) => {
+			const events = [];
+			if (!started) {
+				started = true;
+				events.push({ type: "session.started" });
+			}
+			switch (stringField(record, "type")) {
+				case "text": {
+					const text = stringField(record, "data") ?? "";
+					if (text.length > 0) events.push({
+						type: "message",
+						text,
+						delta: true,
+						raw: record
+					});
+					break;
+				}
+				case "tool_call":
+					events.push({
+						type: "tool.call",
+						id: stringField(record, "toolCallId") ?? "",
+						name: stringField(record, "toolName") ?? stringField(record, "title") ?? "",
+						input: record.rawInput,
+						raw: record
+					});
+					break;
+				case "tool_call_update": {
+					const status = stringField(record, "status");
+					if (status === "completed" || status === "failed") events.push({
+						type: "tool.result",
+						id: stringField(record, "toolCallId") ?? "",
+						output: outputText(record.rawOutput ?? record.content),
+						isError: status === "failed",
+						raw: record
+					});
+					break;
+				}
+				case "usage": {
+					const usage = anthropicUsage(recordField(record, "usage"));
+					if (usage !== void 0) events.push({
+						type: "usage",
+						usage,
+						cumulative: false,
+						raw: record
+					});
+					break;
+				}
+				case "end": {
+					sessionRef = stringField(record, "sessionId") ?? sessionRef;
+					const usage = anthropicUsage(recordField(record, "usage"), numberField(record, "total_cost_usd"));
+					if (usage !== void 0) events.push({
+						type: "usage",
+						usage,
+						cumulative: true,
+						raw: record
+					});
+					break;
+				}
+				case "error":
+					events.push({
+						type: "error",
+						message: stringField(record, "message") ?? "Grok Build reported an error",
+						fatal: true,
+						raw: record
+					});
+					break;
+			}
+			return events;
+		}),
+		sessionRef: () => sessionRef
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/kimi.ts
+/**
+* Kimi Code CLI (`kimi`, npm `@moonshot-ai/kimi-code`) — Moonshot AI's
+* coding agent, the successor of the archived Python `kimi-cli`.
+*
+* Verified against the real `kimi --help` of 2.2.0 and the docs/source at
+* that tag (`docs/en/reference/kimi-command.md`, `apps/kimi-code/src/cli/
+* {options.ts,prompt-render.ts,v2/run-v2-print.ts}`), 2026-10-17.
+*
+* - Headless: `kimi -p <prompt> --output-format stream-json`; the prompt is
+*   an argv value only (print mode never reads stdin).
+* - Stream: OpenAI-chat-shaped messages, one per line, never deltas:
+*   `{"role":"assistant","content","tool_calls"}`, `{"role":"tool",
+*   "tool_call_id","content"}`, and `{"role":"meta","type":…}` records. The
+*   session id appears only in the final `session.resume_hint` record.
+*   No token usage is printed.
+* - Permissions: print mode always runs in "Never Ask" mode (every tool call
+*   runs; only static deny rules apply) and rejects `--yolo`/`--plan`, so
+*   there is no standard mode to choose. The adapter refuses
+*   `permission: "standard"` instead of pretending to enforce it; pass
+*   `"bypass"` to accept the CLI's behaviour.
+* - MCP: no flag; `$KIMI_CODE_HOME/mcp.json` (`mcpServers`), so per-run MCP
+*   needs a private home.
+* - Auth: shell `KIMI_API_KEY`/`MOONSHOT_API_KEY` are not read. For an API
+*   key set `KIMI_MODEL_NAME` (and optionally `KIMI_MODEL_PROVIDER_TYPE`,
+*   `KIMI_MODEL_BASE_URL`) in `env`; `apiKey` becomes `KIMI_MODEL_API_KEY`.
+*/
+const kimiAdapter = {
+	name: "kimi",
+	title: "Kimi Code",
+	command: "kimi",
+	apiKeyEnv: ["KIMI_MODEL_API_KEY"],
+	homeEnv: ["KIMI_CODE_HOME"],
+	transports: ["argv"],
+	effort: false,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "2.2.0",
+		verifiedBy: "help",
+		sources: [
+			"https://moonshotai.github.io/kimi-code/",
+			"https://github.com/MoonshotAI/kimi-code/blob/%40moonshot-ai/kimi-code%402.2.0/docs/en/reference/kimi-command.md",
+			"https://github.com/MoonshotAI/kimi-code/blob/%40moonshot-ai/kimi-code%402.2.0/docs/en/customization/mcp.md"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		if (context.permission !== "bypass") throw unsupportedOption(kimiAdapter, "print mode runs every tool call without asking and has no standard approval mode; pass `permission: \"bypass\"` to run it.");
+		const args = ["--output-format", "stream-json"];
+		const requires = [
+			"-p",
+			"--output-format",
+			"stream-json"
+		];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.resume !== void 0) {
+			args.push("--session", context.resume);
+			requires.push("--session");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, kimiAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, "mcp.json"),
+				content: jsonFile({ mcpServers: kimiMcp(context.mcp) })
+			});
+		}
+		return {
+			args,
+			tail: ["-p", argvPrompt(context.prompt)],
+			env: {
+				...context.home !== void 0 ? { KIMI_CODE_HOME: context.home } : {},
+				KIMI_CODE_NO_AUTO_UPDATE: "1",
+				KIMI_DISABLE_TELEMETRY: "1"
+			},
+			files,
+			requires
+		};
+	},
+	parser: createKimiParser
+};
+/** Kimi's `mcpServers`: SSE servers are marked with `transport: "sse"`. */
+function kimiMcp(servers) {
+	const rendered = mcpServersJson(servers);
+	for (const [name, server] of Object.entries(servers)) {
+		const entry = rendered[name];
+		if (server.type === "sse" && entry !== void 0) entry.transport = "sse";
+	}
+	return rendered;
+}
+/** Parser for `kimi -p … --output-format stream-json`. */
+function createKimiParser() {
+	let sessionRef;
+	return {
+		...jsonLinesParser((record) => {
+			const role = stringField(record, "role");
+			if (role === "meta") {
+				const type = stringField(record, "type");
+				if (type === "system.version") return [{
+					type: "session.started",
+					raw: record
+				}];
+				if (type === "session.resume_hint") {
+					sessionRef = stringField(record, "session_id");
+					return [];
+				}
+				if (type === "turn.step.retrying") return [{
+					type: "error",
+					message: `retrying after ${stringField(record, "error_name") ?? "error"}: ${stringField(record, "error_message") ?? ""}`,
+					raw: record
+				}];
+				return [];
+			}
+			if (role === "assistant") {
+				const events = [];
+				const content = stringField(record, "content");
+				if (content !== void 0 && content.length > 0) events.push({
+					type: "message",
+					text: content,
+					delta: false,
+					raw: record
+				});
+				for (const item of asArray(record.tool_calls)) {
+					const call = asRecord(item);
+					const fn = asRecord(call?.function);
+					events.push({
+						type: "tool.call",
+						id: stringField(call, "id") ?? "",
+						name: stringField(fn, "name") ?? "",
+						input: parseArguments(fn?.arguments),
+						raw: item
+					});
+				}
+				return events;
+			}
+			if (role === "tool") return [{
+				type: "tool.result",
+				id: stringField(record, "tool_call_id") ?? "",
+				output: outputText(record.content),
+				isError: false,
+				raw: record
+			}];
+			return [];
+		}),
+		sessionRef: () => sessionRef
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/mistral-vibe.ts
+/** Folder (inside the run directory) Vibe writes `export.json` to. */
+const EXPORT_DIR = "vibe-output";
+/**
+* Mistral Vibe (`vibe`, PyPI `mistral-vibe`).
+*
+* Verified against the official repo at tag v2.26.1 only (README,
+* `vibe/cli/entrypoint.py`, `vibe/cli/programmatic.py`,
+* `vibe/app_server/run_export.py`, `vibe/core/config/*`); Vibe needs Python
+* 3.12, so no real `--help` was run, 2026-10-17. The capability probe checks
+* every flag against the installed `--help`.
+*
+* - Headless: `vibe -p <prompt> --output streaming` (or `--prompt-file`;
+*   `-p` with no value reads stdin). The stream is NDJSON of completed
+*   history entries (camelCase): `message` (`role`, `content[].text`), and
+*   `effect` — a tool call and its result in one line (`detail.toolName`,
+*   `detail.input`, `state.status`, `state.outputText`/`state.error`).
+*   There is no usage, cost or final record in the stream, so the adapter
+*   adds `--output-dir` and reads usage, cost, session id and outcome from
+*   `export.json` when the stream ends.
+* - Model: no flag; `VIBE_ACTIVE_MODEL=<alias>` (set from `model`). Effort
+*   is a per-model config field, so `effort` is refused.
+* - Permissions: headless auto-denies every approval (the default agent
+*   only auto-approves file edits); bypass is `--auto-approve`.
+* - MCP: `[[mcp_servers]]` in `$VIBE_HOME/config.toml` (private home).
+* - Auth: `MISTRAL_API_KEY`; home `VIBE_HOME`.
+*/
+const mistralVibeAdapter = {
+	name: "mistral-vibe",
+	title: "Mistral Vibe",
+	command: "vibe",
+	apiKeyEnv: ["MISTRAL_API_KEY"],
+	homeEnv: ["VIBE_HOME"],
+	transports: [
+		"argv",
+		"file",
+		"stdin"
+	],
+	effort: false,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "2.26.1",
+		verifiedBy: "docs",
+		sources: [
+			"https://github.com/mistralai/mistral-vibe/blob/v2.26.1/README.md",
+			"https://github.com/mistralai/mistral-vibe/blob/v2.26.1/vibe/cli/entrypoint.py",
+			"https://github.com/mistralai/mistral-vibe/blob/v2.26.1/vibe/cli/programmatic.py"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"--output",
+			"streaming",
+			"--output-dir",
+			node_path.default.join(context.runDir, EXPORT_DIR)
+		];
+		const requires = [
+			"--output",
+			"streaming",
+			"--output-dir"
+		];
+		const files = [];
+		const env = {};
+		if (context.model !== void 0) env.VIBE_ACTIVE_MODEL = context.model;
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--auto-approve");
+			requires.push("--auto-approve");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, mistralVibeAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, "config.toml"),
+				content: toToml({ mcp_servers: vibeMcp(context.mcp) })
+			});
+		}
+		if (context.home !== void 0) env.VIBE_HOME = context.home;
+		if (context.transport === "file") {
+			const prompt = promptFile(context);
+			files.push(prompt);
+			requires.push("--prompt-file");
+			return {
+				args,
+				tail: ["--prompt-file", prompt.path],
+				env,
+				files,
+				requires
+			};
+		}
+		requires.push("-p");
+		if (context.transport === "stdin") return {
+			args,
+			tail: ["-p"],
+			stdin: context.prompt,
+			env,
+			files,
+			requires
+		};
+		return {
+			args,
+			tail: ["-p", argvPrompt(context.prompt)],
+			env,
+			files,
+			requires
+		};
+	},
+	parser: createVibeParser
+};
+function vibeMcp(servers) {
+	return Object.entries(servers).map(([name, server]) => server.type === "stdio" ? {
+		name,
+		transport: "stdio",
+		command: server.command,
+		args: server.args ?? [],
+		env: server.env
+	} : {
+		name,
+		transport: server.type === "http" ? "streamable-http" : "http",
+		url: server.url,
+		auth: server.headers !== void 0 ? {
+			type: "static",
+			headers: server.headers
+		} : void 0
+	});
+}
+/** Read Vibe's `export.json`: usage, cost, session id and outcome of the run. */
+function exportEvents(context) {
+	if (context === void 0) return { events: [] };
+	let report;
+	try {
+		report = parseJsonLine((0, node_fs.readFileSync)(node_path.default.join(context.runDir, EXPORT_DIR, "export.json"), "utf8"));
+	} catch {
+		return { events: [] };
+	}
+	if (report === void 0) return { events: [] };
+	const events = [];
+	const usage = recordField(report, "usage");
+	if (usage !== void 0) {
+		const cached = numberField(usage, "cached_input_tokens");
+		events.push({
+			type: "usage",
+			cumulative: true,
+			usage: usageOf({
+				input: numberField(usage, "input_tokens"),
+				output: numberField(usage, "output_tokens"),
+				total: numberField(usage, "total_tokens"),
+				cachedTokens: cached !== void 0 && cached > 0 ? cached : void 0,
+				costUSD: numberField(report, "cost_usd")
+			}),
+			raw: report
+		});
+	}
+	const outcome = stringField(report, "outcome");
+	if (outcome !== void 0 && outcome !== "finished") events.push({
+		type: "error",
+		message: stringField(recordField(report, "error"), "message") ?? `Mistral Vibe stopped: ${outcome}`,
+		fatal: true,
+		raw: report
+	});
+	return {
+		events,
+		sessionRef: stringField(report, "session_id")
+	};
+}
+/** Parser for `vibe -p … --output streaming` (plus the run's `export.json`). */
+function createVibeParser(context) {
+	let started = false;
+	let sessionRef;
+	return {
+		...jsonLinesParser((record) => {
+			const events = [];
+			const session = stringField(record, "sessionId");
+			if (session !== void 0) sessionRef = session;
+			if (!started) {
+				started = true;
+				events.push({
+					type: "session.started",
+					sessionRef: session,
+					raw: record
+				});
+			}
+			switch (stringField(record, "type")) {
+				case "message": {
+					if (stringField(record, "role") !== "assistant") break;
+					const text = asArray(record.content).map((block) => stringField(asRecord(block), "text") ?? "").join("");
+					if (text.length > 0) events.push({
+						type: "message",
+						text,
+						delta: false,
+						raw: record
+					});
+					break;
+				}
+				case "effect": {
+					const detail = recordField(record, "detail");
+					const state = recordField(record, "state");
+					const status = stringField(state, "status");
+					const id = stringField(record, "id") ?? "";
+					events.push({
+						type: "tool.call",
+						id,
+						name: stringField(detail, "toolName") ?? stringField(record, "title") ?? "",
+						input: detail?.input,
+						raw: record
+					});
+					if (status === "completed" || status === "failed" || status === "cancelled" || status === "skipped") {
+						const error = stringField(recordField(state, "error"), "message");
+						events.push({
+							type: "tool.result",
+							id,
+							output: error ?? stringField(state, "outputText") ?? outputText(state?.output),
+							isError: status !== "completed",
+							raw: record
+						});
+					}
+					break;
+				}
+				case "notice":
+					if (stringField(record, "level") === "error") events.push({
+						type: "error",
+						message: stringField(record, "message") ?? "error",
+						raw: record
+					});
+					break;
+			}
+			return events;
+		}, () => {
+			const exported = exportEvents(context);
+			sessionRef = exported.sessionRef ?? sessionRef;
+			return exported.events;
+		}),
+		sessionRef: () => sessionRef
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/opencode.ts
+/**
+* OpenCode (`opencode`, npm `opencode-ai`).
+*
+* Verified against the real `opencode --help` / `opencode run --help` of
+* 1.19.3, the CLI source at that tag (`packages/opencode/src/cli/cmd/run.ts`)
+* and the docs (`cli.mdx`, `config.mdx`, `mcp-servers.mdx`,
+* `permissions.mdx`), 2026-10-17.
+*
+* - Headless: `opencode run --format json <message..>`; with no message,
+*   piped stdin is the prompt.
+* - Stream: `{"type","timestamp","sessionID","part"|"error"}` lines of six
+*   types: `step_start`, `text` (whole text blocks, no deltas), `reasoning`,
+*   `tool_use` (emitted once the tool finished — call and result together,
+*   `state.status` `completed`/`error`), `step_finish` (per-step `cost` in
+*   USD and `tokens{input,output,reasoning,cache{read,write}}`, input net of
+*   cache) and `error{error:{name,data:{message}}}`. No init or final record.
+* - Permissions: `standard` keeps OpenCode's own rules (permissive by
+*   default; anything that would ask is auto-rejected in `run`); bypass is
+*   `--auto`.
+* - MCP: the `mcp` key of a config file named by `OPENCODE_CONFIG`, written
+*   to the run directory — works with any home.
+* - Home: OpenCode follows XDG; a private/owned home sets `XDG_CONFIG_HOME`,
+*   `XDG_DATA_HOME` (auth lives here), `XDG_STATE_HOME` and `XDG_CACHE_HOME`
+*   beneath it. Provider keys use the provider's own variable
+*   (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, …) — pass them through `env`.
+* - The working directory is passed with `--dir`, because OpenCode prefers a
+*   (possibly stale) `PWD` over the process cwd.
+*/
+const opencodeAdapter = {
+	name: "opencode",
+	title: "OpenCode",
+	command: "opencode",
+	apiKeyEnv: [],
+	homeEnv: [
+		"XDG_CONFIG_HOME",
+		"XDG_DATA_HOME",
+		"XDG_STATE_HOME",
+		"XDG_CACHE_HOME"
+	],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["run", "--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "1.19.3",
+		verifiedBy: "help",
+		sources: [
+			"https://opencode.ai/docs/cli/",
+			"https://opencode.ai/docs/mcp-servers/",
+			"https://opencode.ai/docs/permissions/",
+			"https://github.com/anomalyco/opencode/blob/v1.19.3/packages/opencode/src/cli/cmd/run.ts"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"run",
+			"--format",
+			"json",
+			"--dir",
+			context.cwd
+		];
+		const requires = ["--format", "--dir"];
+		const files = [];
+		const env = { OPENCODE_DISABLE_AUTOUPDATE: "1" };
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--variant", context.effort);
+			requires.push("--variant");
+		}
+		if (context.resume !== void 0) {
+			args.push("--session", context.resume);
+			requires.push("--session");
+		}
+		if (context.permission === "bypass") {
+			args.push("--auto");
+			requires.push("--auto");
+		}
+		if (context.mcp !== void 0) {
+			const file = node_path.default.join(context.runDir, "opencode.json");
+			files.push({
+				path: file,
+				content: jsonFile({
+					$schema: "https://opencode.ai/config.json",
+					mcp: opencodeMcp(context.mcp)
+				})
+			});
+			env.OPENCODE_CONFIG = file;
+		}
+		if (context.home !== void 0) {
+			env.XDG_CONFIG_HOME = node_path.default.join(context.home, "config");
+			env.XDG_DATA_HOME = node_path.default.join(context.home, "data");
+			env.XDG_STATE_HOME = node_path.default.join(context.home, "state");
+			env.XDG_CACHE_HOME = node_path.default.join(context.home, "cache");
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? [argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env,
+			files,
+			requires
+		};
+	},
+	parser: createOpencodeParser
+};
+function opencodeMcp(servers) {
+	const rendered = {};
+	for (const [name, server] of Object.entries(servers)) rendered[name] = server.type === "stdio" ? {
+		type: "local",
+		command: [server.command, ...server.args ?? []],
+		...server.env !== void 0 ? { environment: server.env } : {},
+		enabled: true
+	} : {
+		type: "remote",
+		url: server.url,
+		...server.headers !== void 0 ? { headers: server.headers } : {},
+		enabled: true
+	};
+	return rendered;
+}
+/** Parser for `opencode run --format json`. */
+function createOpencodeParser() {
+	let started = false;
+	return jsonLinesParser((record) => {
+		const events = [];
+		const part = recordField(record, "part");
+		if (!started) {
+			started = true;
+			events.push({
+				type: "session.started",
+				sessionRef: stringField(record, "sessionID"),
+				raw: record
+			});
+		}
+		switch (stringField(record, "type")) {
+			case "text": {
+				const text = stringField(part, "text") ?? "";
+				if (text.length > 0) events.push({
+					type: "message",
+					text,
+					delta: false,
+					raw: record
+				});
+				break;
+			}
+			case "tool_use": {
+				const state = recordField(part, "state");
+				const id = stringField(part, "callID") ?? stringField(part, "id") ?? "";
+				const failed = stringField(state, "status") === "error";
+				events.push({
+					type: "tool.call",
+					id,
+					name: stringField(part, "tool") ?? "",
+					input: state?.input,
+					raw: record
+				}, {
+					type: "tool.result",
+					id,
+					output: (failed ? stringField(state, "error") : stringField(state, "output")) ?? "",
+					isError: failed,
+					raw: record
+				});
+				break;
+			}
+			case "step_finish": {
+				const tokens = recordField(part, "tokens");
+				const cache = recordField(tokens, "cache");
+				if (tokens !== void 0) {
+					const uncached = numberField(tokens, "input") ?? 0;
+					const cacheRead = numberField(cache, "read") ?? 0;
+					const cacheWrite = numberField(cache, "write") ?? 0;
+					events.push({
+						type: "usage",
+						cumulative: false,
+						usage: usageOf({
+							input: uncached + cacheRead + cacheWrite,
+							output: numberField(tokens, "output"),
+							cachedTokens: cacheRead > 0 ? cacheRead : void 0,
+							cacheWriteTokens: cacheWrite > 0 ? cacheWrite : void 0,
+							reasoningTokens: numberField(tokens, "reasoning") || void 0,
+							costUSD: numberField(part, "cost")
+						}),
+						raw: record
+					});
+				}
+				break;
+			}
+			case "error": {
+				const error = asRecord(record.error);
+				const name = stringField(error, "name") ?? "Error";
+				const message = stringField(recordField(error, "data"), "message") ?? name;
+				events.push({
+					type: "error",
+					message: `${name}: ${message}`,
+					fatal: true,
+					raw: record
+				});
+				break;
+			}
+		}
+		return events;
+	});
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/qwen-code.ts
+/**
+* Qwen Code (`qwen`, npm `@qwen-code/qwen-code`), a Gemini CLI fork.
+*
+* Verified against the real `qwen --help` of 0.25.2 and the docs/source at
+* tag v0.25.2 (`docs/users/features/headless.md`, `nonInteractive/types.ts`),
+* 2026-10-17.
+*
+* - Headless: positional prompt (`-p` is deprecated) with
+*   `--output-format stream-json`; piped stdin is used as the prompt when no
+*   positional prompt is given.
+* - Stream: the Claude Code `stream-json` shape (`system/init`, `assistant`,
+*   `user` tool results, `result`), with `input_tokens` that already include
+*   cached tokens and no cost field.
+* - Permissions: headless auto-denies tools that need confirmation (the tool
+*   result says so and `permission_denials` lists it); bypass is `--yolo`.
+* - MCP: `--mcp-config <file>` with `{"mcpServers":…}` — written to the run
+*   directory, so it works with any home. Remote servers use `httpUrl`
+*   (streamable HTTP) or `url` (SSE).
+* - Home: `QWEN_HOME`. Auth depends on the auth type: `OPENAI_API_KEY`
+*   (default for `apiKey`), or `ANTHROPIC_API_KEY` / `GEMINI_API_KEY` with
+*   `--auth-type` in `args`.
+* - Effort has no flag (it is the `model.reasoningEffort` setting), so
+*   `effort` is refused.
+*/
+const qwenCodeAdapter = {
+	name: "qwen-code",
+	title: "Qwen Code",
+	command: "qwen",
+	apiKeyEnv: ["OPENAI_API_KEY"],
+	homeEnv: ["QWEN_HOME"],
+	transports: ["argv", "stdin"],
+	effort: false,
+	mcp: true,
+	probe: {
+		help: [["--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "0.25.2",
+		verifiedBy: "help",
+		sources: ["https://qwenlm.github.io/qwen-code-docs/", "https://github.com/QwenLM/qwen-code/blob/v0.25.2/docs/users/features/headless.md"],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = ["--output-format", "stream-json"];
+		const requires = ["--output-format", "stream-json"];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--yolo");
+			requires.push("--yolo");
+		}
+		if (context.mcp !== void 0) {
+			const file = node_path.default.join(context.runDir, "mcp.json");
+			files.push({
+				path: file,
+				content: jsonFile({ mcpServers: mcpServersJson(context.mcp, { httpUrlKey: "httpUrl" }) })
+			});
+			args.push("--mcp-config", file);
+			requires.push("--mcp-config");
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? [argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env: {
+				...context.home !== void 0 ? { QWEN_HOME: context.home } : {},
+				QWEN_CODE_SUPPRESS_YOLO_WARNING: "1"
+			},
+			files,
+			requires
+		};
+	},
+	parser: () => createClaudeStreamParser({
+		usage: "inclusive",
+		vendor: "Qwen Code"
+	})
+};
+
+//#endregion
+//#region ../../packages/ai-cli/src/adapters/reasonix.ts
+/**
+* Reasonix (`reasonix`, npm `reasonix`) — a cache-first coding agent built
+* around DeepSeek (now multi-provider); the npm package launches a prebuilt
+* Go binary.
+*
+* Verified against the real `reasonix run --help` / `--version` of 2.43.0,
+* real stream-json output (captured against a local fake model server) and
+* the docs at that tag (`docs/CLI.md`, `docs/CONFIG_PATHS.md`), 2026-10-17.
+*
+* - Headless: `reasonix run --output-format stream-json <task>`; with no
+*   positional task, piped stdin is the prompt.
+* - Stream: every line has `kind` (`text` deltas, `message` full text,
+*   `tool_dispatch`/`tool_started`/`tool_result` with a `tool` object whose
+*   non-empty `err` marks a failure, `usage` per model call, `turn_done`) plus
+*   `sessionId`; the final line is `{"type":"result",…}` with totals.
+* - Permissions: headless "ask" mode refuses writes (listed in
+*   `permission_denials`; exit 4 in an untrusted folder); bypass is `--yolo`.
+* - MCP: no flag; `[[plugins]]` in `$REASONIX_HOME/config.toml`.
+* - Auth: provider keys are read only from `$REASONIX_HOME/.env`, never the
+*   shell environment, so `apiKey` is written there (0600) as
+*   `DEEPSEEK_API_KEY` — this needs a private home. For another provider,
+*   put its variable in that file yourself via a caller-owned home.
+*/
+const reasonixAdapter = {
+	name: "reasonix",
+	title: "Reasonix",
+	command: "reasonix",
+	apiKeyEnv: ["DEEPSEEK_API_KEY"],
+	homeEnv: ["REASONIX_HOME"],
+	transports: ["argv", "stdin"],
+	effort: true,
+	mcp: true,
+	probe: {
+		help: [["run", "--help"]],
+		version: ["--version"]
+	},
+	verification: {
+		version: "2.43.0",
+		verifiedBy: "help",
+		sources: [
+			"https://github.com/esengine/DeepSeek-Reasonix/blob/v2.43.0/docs/CLI.md",
+			"https://github.com/esengine/DeepSeek-Reasonix/blob/v2.43.0/docs/CONFIG_PATHS.md",
+			"https://www.npmjs.com/package/reasonix"
+		],
+		checkedAt: "2026-10-17"
+	},
+	plan(context) {
+		const args = [
+			"run",
+			"--output-format",
+			"stream-json"
+		];
+		const requires = ["--output-format", "stream-json"];
+		const files = [];
+		if (context.model !== void 0) {
+			args.push("--model", context.model);
+			requires.push("--model");
+		}
+		if (context.effort !== void 0) {
+			args.push("--effort", mapEffort(context.effort, {
+				none: "disabled",
+				low: "low",
+				high: "high",
+				max: "max"
+			}));
+			requires.push("--effort");
+		}
+		if (context.resume !== void 0) {
+			args.push("--resume", context.resume);
+			requires.push("--resume");
+		}
+		if (context.permission === "bypass") {
+			args.push("--yolo");
+			requires.push("--yolo");
+		}
+		if (context.mcp !== void 0) {
+			const home = requirePrivateHome(context, reasonixAdapter, "MCP servers");
+			files.push({
+				path: node_path.default.join(home, "config.toml"),
+				content: toToml({ plugins: reasonixPlugins(context.mcp) })
+			});
+		}
+		if (context.apiKey !== void 0) {
+			const home = requirePrivateHome(context, reasonixAdapter, "API keys (its .env file)");
+			files.push({
+				path: node_path.default.join(home, ".env"),
+				content: dotenvFile({ DEEPSEEK_API_KEY: context.apiKey })
+			});
+		}
+		return {
+			args,
+			tail: context.transport === "argv" ? [argvPrompt(context.prompt)] : [],
+			stdin: context.transport === "stdin" ? context.prompt : void 0,
+			env: {
+				...context.home !== void 0 ? { REASONIX_HOME: context.home } : {},
+				REASONIX_TELEMETRY: "off"
+			},
+			files,
+			requires
+		};
+	},
+	parser: createReasonixParser
+};
+function reasonixPlugins(servers) {
+	return Object.entries(servers).map(([name, server]) => server.type === "stdio" ? {
+		name,
+		type: "stdio",
+		command: server.command,
+		args: server.args ?? [],
+		env: server.env
+	} : {
+		name,
+		type: server.type,
+		url: server.url,
+		headers: server.headers
+	});
+}
+/** Reasonix per-call usage (`promptTokens` includes cache hits). */
+function callUsage(usage) {
+	if (usage === void 0) return;
+	const cacheHit = numberField(usage, "cacheHitTokens");
+	return usageOf({
+		input: numberField(usage, "promptTokens"),
+		output: numberField(usage, "completionTokens"),
+		total: numberField(usage, "totalTokens"),
+		cachedTokens: cacheHit !== void 0 && cacheHit > 0 ? cacheHit : void 0,
+		reasoningTokens: numberField(usage, "reasoningTokens"),
+		costUSD: numberField(usage, "costUsd")
+	});
+}
+/** Parser for `reasonix run --output-format stream-json`. */
+function createReasonixParser() {
+	let started = false;
+	let sessionRef;
+	return {
+		...jsonLinesParser((record) => {
+			const events = [];
+			const recordSession = stringField(record, "sessionId") ?? stringField(record, "session_id");
+			if (recordSession !== void 0) sessionRef = recordSession;
+			if (!started && recordSession !== void 0) {
+				started = true;
+				events.push({
+					type: "session.started",
+					sessionRef: recordSession,
+					raw: record
+				});
+			}
+			if (stringField(record, "type") === "result") {
+				const usage = recordField(record, "usage");
+				if (usage !== void 0) events.push({
+					type: "usage",
+					cumulative: true,
+					usage: usageOf({
+						input: numberField(usage, "input_tokens"),
+						output: numberField(usage, "output_tokens"),
+						cachedTokens: numberField(usage, "cache_read_input_tokens") || void 0,
+						costUSD: numberField(record, "total_cost_usd")
+					}),
+					raw: record
+				});
+				const result = stringField(record, "result") ?? "";
+				if (record.is_error === true) events.push({
+					type: "error",
+					message: result || "Reasonix run failed",
+					fatal: true,
+					raw: record
+				});
+				else if (result.length > 0) events.push({
+					type: "message",
+					text: result,
+					delta: false,
+					final: true,
+					raw: record
+				});
+				return events;
+			}
+			const tool = asRecord(record.tool);
+			switch (stringField(record, "kind")) {
+				case "text": {
+					const text = stringField(record, "text") ?? "";
+					if (text.length > 0) events.push({
+						type: "message",
+						text,
+						delta: true,
+						raw: record
+					});
+					break;
+				}
+				case "message":
+					events.push({
+						type: "message",
+						text: stringField(record, "text") ?? "",
+						delta: false,
+						raw: record
+					});
+					break;
+				case "tool_dispatch":
+					if (tool !== void 0 && tool.partial !== true) events.push({
+						type: "tool.call",
+						id: stringField(tool, "id") ?? "",
+						name: stringField(tool, "name") ?? "",
+						input: parseArguments(tool.args),
+						raw: record
+					});
+					break;
+				case "tool_result": {
+					const error = stringField(tool, "err") ?? "";
+					events.push({
+						type: "tool.result",
+						id: stringField(tool, "id") ?? "",
+						output: error.length > 0 ? error : stringField(tool, "output") ?? "",
+						isError: error.length > 0,
+						raw: record
+					});
+					break;
+				}
+				case "usage": {
+					const usage = callUsage(recordField(record, "usage"));
+					if (usage !== void 0) events.push({
+						type: "usage",
+						usage,
+						cumulative: false,
+						raw: record
+					});
+					break;
+				}
+				case "turn_done":
+					if (stringField(record, "status") === "failed") events.push({
+						type: "error",
+						message: stringField(record, "err") ?? "Reasonix turn failed",
+						fatal: true,
+						raw: record
+					});
+					break;
+			}
+			return events;
+		}),
+		sessionRef: () => sessionRef
+	};
+}
+
+//#endregion
+//#region ../../packages/ai-cli/src/cli.ts
+/** Every built-in adapter, keyed by its factory name. */
+const cliAdapters = {
+	claudeCode: claudeCodeAdapter,
+	codex: codexAdapter,
+	antigravity: antigravityAdapter,
+	qwenCode: qwenCodeAdapter,
+	kimi: kimiAdapter,
+	cursor: cursorAdapter,
+	copilot: copilotAdapter,
+	grok: grokAdapter,
+	opencode: opencodeAdapter,
+	amp: ampAdapter,
+	droid: droidAdapter,
+	mistralVibe: mistralVibeAdapter,
+	aider: aiderAdapter,
+	reasonix: reasonixAdapter
+};
+const factories = Object.fromEntries(Object.entries(cliAdapters).map(([vendor, adapter]) => [vendor, (options) => createCliAgent(adapter, options)]));
+/**
+* The CLI-agent namespace: one factory per vendor, `custom()` for your own
+* adapter, `model()` to hand a CLI agent to `ai.agent`. Also available as
+* `ai.cli` once the package is imported.
+*
+* @example
+* import { cli } from "@warlock.js/ai-cli";
+*
+* const claude = cli.claudeCode({ model: "sonnet", cwd: "/srv/repo" });
+* const session = await claude.run("Fix the failing test");
+* for await (const event of session.events) console.log(event.type);
+* const { text, usage, sessionRef } = await session.done();
+*/
+const cli = {
+	...factories,
+	custom: (adapter, options) => createCliAgent(adapter, options),
+	model: cliModel,
+	adapters: cliAdapters
+};
+_warlock_js_ai.ai.cli = cli;
+
+//#endregion
+exports.CliError = CliError;
+exports.aiderAdapter = aiderAdapter;
+exports.ampAdapter = ampAdapter;
+exports.anthropicUsage = anthropicUsage;
+exports.antigravityAdapter = antigravityAdapter;
+exports.argvPrompt = argvPrompt;
+exports.asArray = asArray;
+exports.asRecord = asRecord;
+exports.buildInvocation = buildInvocation;
+exports.claudeCodeAdapter = claudeCodeAdapter;
+exports.cli = cli;
+exports.cliAdapters = cliAdapters;
+exports.cliModel = cliModel;
+exports.codexAdapter = codexAdapter;
+exports.copilotAdapter = copilotAdapter;
+exports.createAiderParser = createAiderParser;
+exports.createAntigravityParser = createAntigravityParser;
+exports.createClaudeStreamParser = createClaudeStreamParser;
+exports.createCliAgent = createCliAgent;
+exports.createCodexParser = createCodexParser;
+exports.createCopilotParser = createCopilotParser;
+exports.createCursorParser = createCursorParser;
+exports.createDroidParser = createDroidParser;
+exports.createGrokParser = createGrokParser;
+exports.createKimiParser = createKimiParser;
+exports.createOpencodeParser = createOpencodeParser;
+exports.createReasonixParser = createReasonixParser;
+exports.createVibeParser = createVibeParser;
+exports.currentHost = currentHost;
+exports.cursorAdapter = cursorAdapter;
+exports.dotenvFile = dotenvFile;
+exports.droidAdapter = droidAdapter;
+exports.findExecutable = findExecutable;
+exports.fitsCommandLine = fitsCommandLine;
+exports.grokAdapter = grokAdapter;
+exports.helpLists = helpLists;
+exports.jsonFile = jsonFile;
+exports.jsonLinesParser = jsonLinesParser;
+exports.kimiAdapter = kimiAdapter;
+exports.mapEffort = mapEffort;
+exports.mcpServersJson = mcpServersJson;
+exports.missingFlags = missingFlags;
+exports.mistralVibeAdapter = mistralVibeAdapter;
+exports.numberField = numberField;
+exports.opencodeAdapter = opencodeAdapter;
+exports.outputText = outputText;
+exports.parseAiderCount = parseAiderCount;
+exports.parseArguments = parseArguments;
+exports.parseCmdShim = parseCmdShim;
+exports.parseJsonLine = parseJsonLine;
+exports.parseVersion = parseVersion;
+exports.promptFile = promptFile;
+exports.quoteForCmd = quoteForCmd;
+exports.qwenCodeAdapter = qwenCodeAdapter;
+exports.reasonixAdapter = reasonixAdapter;
+exports.recordField = recordField;
+exports.renderPrompt = renderPrompt;
+exports.requirePrivateHome = requirePrivateHome;
+exports.resolveSpawnTarget = resolveSpawnTarget;
+exports.stringField = stringField;
+exports.toToml = toToml;
+exports.toUsage = toUsage;
+exports.unsupportedOption = unsupportedOption;
+exports.usageOf = usageOf;
+//# sourceMappingURL=index.cjs.map