jev-planner 0.0.1 → 0.1.0

package/dist/jev-aqxfEUdB.cjs

@@ -0,0 +1,2756 @@
+let _typesafe_ai_sdk = require("@typesafe-ai/sdk");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let node_util = require("node:util");
+let node_child_process = require("node:child_process");
+let node_string_decoder = require("node:string_decoder");
+let node_crypto = require("node:crypto");
+//#region ../core/dist/index.mjs
+const MAX_OUTPUT_BYTES = 8388608;
+var ProcessError = class extends Error {
+	command;
+	exitCode;
+	stderr;
+	constructor(command, exitCode, stderr) {
+		const detail = stderr.trim().slice(-2e3);
+		super(`${command} failed${exitCode === null ? "" : ` with exit code ${String(exitCode)}`}${detail ? `:\n${detail}` : ""}`);
+		this.name = "ProcessError";
+		this.command = command;
+		this.exitCode = exitCode;
+		this.stderr = stderr;
+	}
+};
+function runProcess(command, args, options) {
+	return new Promise((resolve, reject) => {
+		if (options.signal?.aborted === true) {
+			reject(/* @__PURE__ */ new Error(`${command} was not started: the run no longer needs it`));
+			return;
+		}
+		const omit = new Set(options.omitEnv);
+		const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !omit.has(name)));
+		const child = (0, node_child_process.spawn)(command, args, {
+			cwd: options.cwd,
+			env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdout = [];
+		const stderr = [];
+		let outputBytes = 0;
+		let settled = false;
+		const decoders = {
+			stdout: new node_string_decoder.StringDecoder("utf8"),
+			stderr: new node_string_decoder.StringDecoder("utf8")
+		};
+		const partial = {
+			stdout: "",
+			stderr: ""
+		};
+		const emit = (stream, chunk) => {
+			const { onLine } = options;
+			if (!onLine) return;
+			const text = chunk ? decoders[stream].write(chunk) : decoders[stream].end();
+			const lines = `${partial[stream]}${text}`.split(/\r?\n/);
+			partial[stream] = chunk ? lines.pop() ?? "" : "";
+			for (const line of lines) if (line.trim()) onLine(line, stream);
+		};
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			if (timer !== void 0) clearTimeout(timer);
+			options.signal?.removeEventListener("abort", abort);
+			callback();
+		};
+		const abort = () => {
+			child.kill("SIGTERM");
+			finish(() => {
+				reject(/* @__PURE__ */ new Error(`${command} was stopped: the run no longer needs it`));
+			});
+		};
+		options.signal?.addEventListener("abort", abort);
+		const collect = (target, chunk) => {
+			outputBytes += chunk.length;
+			if (outputBytes > MAX_OUTPUT_BYTES) {
+				child.kill("SIGTERM");
+				finish(() => {
+					reject(/* @__PURE__ */ new Error(`${command} exceeded the 8 MiB output limit`));
+				});
+				return;
+			}
+			target.push(chunk);
+		};
+		child.stdout.on("data", (chunk) => {
+			collect(stdout, chunk);
+			emit("stdout", chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			collect(stderr, chunk);
+			emit("stderr", chunk);
+		});
+		child.on("error", (error) => {
+			finish(() => {
+				reject(new Error(`Could not start ${command}: ${error.message}`, { cause: error }));
+			});
+		});
+		child.on("close", (exitCode) => {
+			if (!settled) {
+				emit("stdout");
+				emit("stderr");
+			}
+			finish(() => {
+				const result = {
+					stdout: Buffer.concat(stdout).toString("utf8"),
+					stderr: Buffer.concat(stderr).toString("utf8"),
+					exitCode: exitCode ?? 1
+				};
+				if (exitCode !== 0) {
+					reject(new ProcessError(command, exitCode, result.stderr));
+					return;
+				}
+				resolve(result);
+			});
+		});
+		const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+			child.kill("SIGTERM");
+			finish(() => {
+				reject(/* @__PURE__ */ new Error(`${command} timed out after ${String(options.timeoutMs)}ms`));
+			});
+		}, options.timeoutMs);
+		child.stdin.on("error", (error) => {
+			if (error.code !== "EPIPE") finish(() => {
+				reject(error);
+			});
+		});
+		child.stdin.end(options.input);
+	});
+}
+/** The first line of `text`, trimmed; the whole of a one-line message. */
+function firstLine(text) {
+	return text.trim().replace(/\n[\s\S]*$/, "");
+}
+function errorDetail(error) {
+	return error instanceof Error ? firstLine(error.message) : String(error);
+}
+/** Passes when `command args` exits 0; the detail is the first line it printed. */
+async function commandCheck(name, command, args, cwd) {
+	try {
+		const result = await runProcess(command, args, {
+			cwd,
+			timeoutMs: 15e3
+		});
+		return {
+			name,
+			ok: true,
+			detail: firstLine(result.stdout || result.stderr) || "available"
+		};
+	} catch (error) {
+		return {
+			name,
+			ok: false,
+			detail: errorDetail(error)
+		};
+	}
+}
+/** Passes when the variable is set to something other than whitespace. Never prints the value. */
+function envCheck(name, variable, env) {
+	const set = Boolean(env[variable]?.trim());
+	return {
+		name,
+		ok: set,
+		detail: `${variable} is ${set ? "set" : "not set"}`
+	};
+}
+/**
+* Each provider's own checks, in order. No paid call. The CLI adds a check for
+* each variable its judge reads (`PlannerProgram.judgeEnv`).
+*/
+async function runDoctor(cwd, providers, env = process.env) {
+	return (await Promise.all(providers.map((provider) => provider.doctor(cwd, env)))).flat();
+}
+/**
+* Top-level files that say what a repository is and how it is built, read in
+* this order. Tracked files only, so a `.env` or anything else ignored is never
+* sent: the snapshot goes to a third-party API.
+*/
+const SNAPSHOT_FILES = [
+	"AGENTS.md",
+	"CLAUDE.md",
+	"README.md",
+	"CONTRIBUTING.md",
+	"package.json",
+	"pnpm-workspace.yaml",
+	"tsconfig.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod"
+];
+const MAX_SNAPSHOT_PATHS = 2e3;
+const MAX_SNAPSHOT_FILE_CHARS = 16e3;
+function clip(text, max) {
+	return text.length <= max ? text : `${text.slice(0, max)}\n[truncated]`;
+}
+/**
+* What an agent without repository access is told about `cwd`: the files git
+* tracks under it, and the contents of the `SNAPSHOT_FILES` among them, within
+* fixed size budgets. Outside a git repository it says so rather than guessing
+* which files are safe to send.
+*/
+async function repoSnapshot(cwd) {
+	let paths;
+	try {
+		const { stdout } = await runProcess("git", ["ls-files"], {
+			cwd,
+			timeoutMs: 15e3
+		});
+		paths = stdout.split("\n").filter(Boolean);
+	} catch {
+		return "<repository-snapshot>\nNot a git repository: no files are available.\n</repository-snapshot>";
+	}
+	const listed = paths.slice(0, MAX_SNAPSHOT_PATHS);
+	const omitted = paths.length - listed.length;
+	let snapshot = `<repository-snapshot>\nTracked files (${String(paths.length)}):\n${listed.join("\n")}${omitted > 0 ? `\n[${String(omitted)} more not listed]` : ""}`;
+	const tracked = new Set(paths);
+	for (const file of SNAPSHOT_FILES) {
+		if (!tracked.has(file)) continue;
+		const contents = await (0, node_fs_promises.readFile)((0, node_path.join)(cwd, file), "utf8").catch(() => void 0);
+		if (contents === void 0) continue;
+		const block = `\n\n<file path="${file}">\n${clip(contents, MAX_SNAPSHOT_FILE_CHARS)}\n</file>`;
+		if (snapshot.length + block.length > 8e4) break;
+		snapshot += block;
+	}
+	return `${snapshot}\n</repository-snapshot>`;
+}
+/** One line of progress from a longer text: its first non-blank line, clipped. */
+function brief(text, max = 160) {
+	const line = text.trim().split("\n", 1)[0]?.trim() ?? "";
+	return line.length <= max ? line : `${line.slice(0, max - 1)}…`;
+}
+/**
+* An agent's label: the provider's own for an agent named after it, `Codex (sol)`
+* for a named one, so two agents of one provider never share a label, which is
+* how the judge and the prompts tell plans apart.
+*/
+function agentLabel(provider, name) {
+	return name === provider.id ? provider.label : `${provider.label} (${name})`;
+}
+function requireOutput(label, output) {
+	const result = output.trim();
+	if (!result) throw new Error(`${label} returned an empty response`);
+	return result;
+}
+/** An agent CLI installed and logged in on this machine, run read-only in the repository. */
+function cliProvider(config) {
+	return {
+		id: config.id,
+		label: config.label,
+		kind: "cli",
+		secretEnv: [],
+		effort: config.effort ?? false,
+		create: ({ name = config.id, label = agentLabel(config, name), model, effort, omitEnv }) => ({
+			name,
+			label,
+			readsRepository: true,
+			generate: async (request) => {
+				const callEffort = config.effort ? request.effort ?? effort : effort;
+				const overrides = {
+					...model === void 0 ? {} : { model },
+					...callEffort === void 0 ? {} : { effort: callEffort }
+				};
+				const { events, sessions } = config;
+				const read = (line, stream) => {
+					if (stream === "stderr") return { progress: line };
+					if (!events) return {};
+					let event;
+					try {
+						event = JSON.parse(line);
+					} catch {
+						return { progress: line };
+					}
+					return events(event);
+				};
+				const once = async (args, input) => {
+					let answer = "";
+					let session;
+					const { stdout } = await runProcess(config.command, args, {
+						cwd: request.cwd,
+						input,
+						timeoutMs: request.timeoutMs,
+						omitEnv,
+						...request.signal ? { signal: request.signal } : {},
+						onLine: (line, stream) => {
+							const event = read(line, stream);
+							if (event.progress) request.onProgress?.(event.progress);
+							if (event.result !== void 0) answer = event.result;
+							if (event.session !== void 0) session = event.session;
+						}
+					});
+					return {
+						answer: requireOutput(label, events ? answer : stdout),
+						session
+					};
+				};
+				const { session } = request;
+				if (!sessions || !session) return (await once(config.args(overrides), request.prompt)).answer;
+				const start = async (conversation) => {
+					const id = (0, node_crypto.randomUUID)();
+					const result = await once(sessions.start(overrides, id), request.prompt);
+					conversation.id = result.session ?? id;
+					return result.answer;
+				};
+				if (session.id === void 0) return start(session);
+				try {
+					return (await once(sessions.resume(overrides, session.id), request.resumePrompt ?? request.prompt)).answer;
+				} catch (error) {
+					if (!(error instanceof ProcessError)) throw error;
+					const reason = brief(error.stderr.trim().split("\n").at(-1) ?? "") || error.message;
+					request.onProgress?.(`Could not continue the earlier session (${brief(reason)}); starting a new one`);
+					return start(session);
+				}
+			}
+		}),
+		doctor: (cwd) => {
+			const checks = [commandCheck(`${config.label} CLI`, config.command, ["--version"], cwd)];
+			if (typeof config.auth === "function") checks.push(config.auth(cwd));
+			else if (config.auth) checks.push(commandCheck(`${config.label} auth`, config.command, config.auth, cwd));
+			return Promise.all(checks);
+		}
+	};
+}
+/** The instruction an API agent gets in place of the repository access it does not have. */
+const API_AGENT_SYSTEM_PROMPT = `You cannot run commands or open files. The repository snapshot in the task is all
+you can see of the codebase: ground the plan in it, and name the files you would need to read wherever
+the plan depends on code the snapshot does not show.`;
+/**
+* A chat API that speaks OpenAI's `/chat/completions`, as DeepSeek, Moonshot,
+* Z.ai and most others do. It cannot read the repository, so each prompt is
+* sent with a snapshot of it: the tracked file list and the top-level docs and
+* manifests (see `repoSnapshot`). Given an `AgentSession`, it keeps the
+* conversation and sends it back on the next call, so the snapshot is sent once
+* and later prompts can leave out what the conversation already holds.
+*/
+function openAICompatibleProvider(config) {
+	let baseEnd = config.baseUrl.length;
+	while (baseEnd > 0 && config.baseUrl.charAt(baseEnd - 1) === "/") baseEnd -= 1;
+	const endpoint = `${config.baseUrl.slice(0, baseEnd)}/chat/completions`;
+	return {
+		id: config.id,
+		label: config.label,
+		kind: "api",
+		secretEnv: [config.apiKeyEnv],
+		effort: false,
+		create: ({ name = config.id, label = agentLabel(config, name), model = config.model, env, fetch: send = fetch }) => {
+			const snapshots = /* @__PURE__ */ new Map();
+			const conversations = /* @__PURE__ */ new WeakMap();
+			return {
+				name,
+				label,
+				readsRepository: false,
+				generate: async (request) => {
+					const key = env[config.apiKeyEnv]?.trim();
+					if (!key) throw new Error(`${config.apiKeyEnv} is not set, so ${label} cannot run`);
+					const earlier = request.session && conversations.get(request.session);
+					let messages;
+					if (earlier) messages = [...earlier, {
+						role: "user",
+						content: request.resumePrompt ?? request.prompt
+					}];
+					else {
+						let snapshot = snapshots.get(request.cwd);
+						if (!snapshot) {
+							snapshot = repoSnapshot(request.cwd);
+							snapshots.set(request.cwd, snapshot);
+						}
+						messages = [{
+							role: "system",
+							content: API_AGENT_SYSTEM_PROMPT
+						}, {
+							role: "user",
+							content: `${await snapshot}\n\n${request.prompt}`
+						}];
+					}
+					request.onProgress?.(`Waiting for ${model} to answer…`);
+					const timeout = AbortSignal.timeout(request.timeoutMs);
+					const signal = request.signal ? AbortSignal.any([timeout, request.signal]) : timeout;
+					let response;
+					try {
+						response = await send(endpoint, {
+							method: "POST",
+							headers: {
+								"content-type": "application/json",
+								authorization: `Bearer ${key}`
+							},
+							body: JSON.stringify({
+								model,
+								messages
+							}),
+							signal
+						});
+					} catch (error) {
+						if (request.signal?.aborted === true) throw new Error(`${label} was stopped: the run no longer needs it`, { cause: error });
+						if (error instanceof Error && error.name === "TimeoutError") throw new Error(`${label} timed out after ${String(request.timeoutMs / 1e3)}s`, { cause: error });
+						throw error;
+					}
+					if (!response.ok) {
+						const detail = (await response.text()).trim().slice(0, 500);
+						throw new Error(`${label} API failed with status ${String(response.status)}${detail ? `: ${detail}` : ""}`);
+					}
+					const answer = requireOutput(label, (await response.json()).choices?.[0]?.message?.content ?? "");
+					if (request.session) conversations.set(request.session, [...messages, {
+						role: "assistant",
+						content: answer
+					}]);
+					return answer;
+				}
+			};
+		},
+		doctor: (_cwd, env) => Promise.resolve([envCheck(`${config.label} key`, config.apiKeyEnv, env)])
+	};
+}
+async function claudeAuth(cwd) {
+	try {
+		const result = await runProcess("claude", [
+			"auth",
+			"status",
+			"--json"
+		], {
+			cwd,
+			timeoutMs: 15e3
+		});
+		const status = JSON.parse(result.stdout);
+		const detail = [status.authMethod, status.subscriptionType].filter(Boolean).join(", ");
+		return {
+			name: "Claude auth",
+			ok: status.loggedIn === true,
+			detail: status.loggedIn === true ? `Logged in${detail ? ` (${detail})` : ""}` : "Not logged in"
+		};
+	} catch (error) {
+		return {
+			name: "Claude auth",
+			ok: false,
+			detail: errorDetail(error)
+		};
+	}
+}
+/** What Codex is doing, from one of its JSON events; its last message is the answer. */
+function codexEvent(event) {
+	const { type, item, error, message, thread_id: thread } = event;
+	if (type === "thread.started") return thread ? { session: thread } : {};
+	if (type === "turn.failed") return { progress: `failed: ${error?.message ?? "unknown error"}` };
+	if (type === "error") return { progress: `error: ${message ?? "unknown error"}` };
+	if (!item?.type) return {};
+	if (type === "item.started") return item.type === "command_execution" ? { progress: `$ ${brief(item.command ?? "")}` } : {};
+	if (type !== "item.completed") return {};
+	switch (item.type) {
+		case "agent_message": return {
+			progress: brief(item.text ?? ""),
+			result: item.text ?? ""
+		};
+		case "reasoning": return { progress: brief(item.text ?? "") };
+		case "command_execution": return item.exit_code === 0 ? {} : { progress: `exited ${String(item.exit_code)}` };
+		default: return { progress: item.type.replaceAll("_", " ") };
+	}
+}
+/** What Claude is doing, from one of its JSON events; the `result` event is the answer. */
+function claudeEvent(event) {
+	const { type, message, result, is_error: isError } = event;
+	if (type === "result") return isError === true ? { progress: `error: ${result ?? "unknown error"}` } : { result: result ?? "" };
+	if (type !== "assistant") return {};
+	const lines = (message?.content ?? []).flatMap((block) => {
+		if (block.type === "text") return [brief(block.text ?? "")];
+		if (block.type !== "tool_use") return [];
+		const subject = Object.values(block.input ?? {}).find((value) => typeof value === "string");
+		return [`${block.name ?? "tool"}${typeof subject === "string" ? ` ${brief(subject)}` : ""}`];
+	});
+	return lines.length > 0 ? { progress: lines.join("\n") } : {};
+}
+function codexOverrides({ model, effort }) {
+	return [...model ? ["--model", model] : [], ...effort ? ["-c", `model_reasoning_effort=${JSON.stringify(effort)}`] : []];
+}
+/** `codex exec`, read-only, with `session` saying whether its session is kept. */
+function codexArgs(session, overrides) {
+	return [
+		"exec",
+		"--json",
+		...session,
+		"--sandbox",
+		"read-only",
+		"--skip-git-repo-check",
+		"--color",
+		"never",
+		...codexOverrides(overrides),
+		"-"
+	];
+}
+/**
+* `claude --print` in plan mode with three read-only tools, whether it starts,
+* continues or keeps no session: `session` says which.
+*/
+function claudeArgs(session, { model, effort }) {
+	return [
+		"--print",
+		"--permission-mode",
+		"plan",
+		"--permission-prompts",
+		"none",
+		...session,
+		"--output-format",
+		"stream-json",
+		"--verbose",
+		"--tools",
+		"Read,Glob,Grep",
+		"--strict-mcp-config",
+		...model ? ["--model", model] : [],
+		...effort ? ["--effort", effort] : []
+	];
+}
+/**
+* Every AI the planner can plan with. To add one, add an entry here, and the
+* agent to `config.schema.json` and its copy in `apps/docs/public/`, which a
+* test keeps in step: the CLI, `doctor`, `--help`, the config, the prompts and
+* the judge all read this list. An OpenAI-compatible chat API is one
+* `openAICompatibleProvider` call; an agent CLI that can run read-only is one
+* `cliProvider` call.
+*/
+const PROVIDERS = [
+	cliProvider({
+		id: "codex",
+		label: "Codex",
+		command: "codex",
+		args: (overrides) => codexArgs(["--ephemeral"], overrides),
+		sessions: {
+			start: (overrides) => codexArgs([], overrides),
+			resume: (overrides, id) => [
+				"exec",
+				"resume",
+				"--json",
+				"--skip-git-repo-check",
+				"-c",
+				"sandbox_mode=\"read-only\"",
+				...codexOverrides(overrides),
+				id,
+				"-"
+			]
+		},
+		effort: true,
+		events: codexEvent,
+		auth: ["login", "status"]
+	}),
+	cliProvider({
+		id: "claude",
+		label: "Claude",
+		command: "claude",
+		args: (overrides) => claudeArgs(["--no-session-persistence"], overrides),
+		sessions: {
+			start: (overrides, id) => claudeArgs(["--session-id", id], overrides),
+			resume: (overrides, id) => claudeArgs(["--resume", id], overrides)
+		},
+		effort: true,
+		events: claudeEvent,
+		auth: claudeAuth
+	}),
+	openAICompatibleProvider({
+		id: "deepseek",
+		label: "DeepSeek",
+		baseUrl: "https://api.deepseek.com",
+		apiKeyEnv: "DEEPSEEK_API_KEY",
+		model: "deepseek-chat"
+	}),
+	openAICompatibleProvider({
+		id: "kimi",
+		label: "Kimi",
+		baseUrl: "https://api.moonshot.ai/v1",
+		apiKeyEnv: "MOONSHOT_API_KEY",
+		model: "kimi-latest"
+	}),
+	openAICompatibleProvider({
+		id: "glm",
+		label: "GLM",
+		baseUrl: "https://api.z.ai/api/paas/v4",
+		apiKeyEnv: "ZAI_API_KEY",
+		model: "glm-4.6"
+	})
+];
+/** The agents a run uses without `--agents`. */
+const DEFAULT_AGENTS = ["codex", "claude"];
+const IDS = PROVIDERS.map(({ id }) => id);
+const PROVIDER_IDS$1 = IDS.join(", ");
+/** Where the keys a config must never hold belong instead: the judge's, then every provider's. */
+const secretEnv$1 = (judgeEnv) => [...judgeEnv, ...PROVIDERS.flatMap(({ secretEnv }) => secretEnv)];
+const SECRET = /key|token|secret|password/i;
+function object(at, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${at}: must be an object`);
+	return value;
+}
+function string(at, value) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${at}: must be a non-empty string`);
+	return value.trim();
+}
+function boolean(at, value) {
+	if (typeof value !== "boolean") throw new Error(`${at}: must be true or false`);
+	return value;
+}
+function notOneOf(at, options) {
+	return /* @__PURE__ */ new Error(`${at}: must be one of ${options.map((option) => JSON.stringify(option)).join(", ")}`);
+}
+function choice$1(at, value, options) {
+	if (!options.includes(value)) throw notOneOf(at, options);
+	return value;
+}
+/** A number of seconds, as the matching flag's text; zero only where `zero` allows it. */
+function seconds(at, value, zero = false) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || !zero && value === 0) throw new Error(`${at}: must be ${zero ? "a number of seconds, 0 or more" : "a positive number of seconds"}`);
+	return String(value);
+}
+function unknownKey(at, expected, judgeEnv) {
+	const key = at.slice(at.lastIndexOf(".") + 1);
+	if (SECRET.test(key)) return /* @__PURE__ */ new Error(`${at}: a config never holds a secret; it is meant to be committed. Set ${secretEnv$1(judgeEnv).join(", ")} in the environment instead.`);
+	return /* @__PURE__ */ new Error(`${at}: unknown key. Expected one of ${expected.join(", ")}.`);
+}
+const AGENT_FIELDS = {
+	model: "model",
+	effort: "effort",
+	reviewEffort: "review-effort"
+};
+const NAME = /^[a-z][a-z0-9-]{0,23}$/;
+/** Taken by `--finalizer` (`auto`, `none`), by the judge's verdict (`tie`), or by Windows as a file name. */
+const RESERVED = /* @__PURE__ */ new Set([
+	"auto",
+	"none",
+	"tie",
+	"con",
+	"prn",
+	"aux",
+	"nul",
+	...Array.from({ length: 9 }, (_, index) => `com${String(index + 1)}`),
+	...Array.from({ length: 9 }, (_, index) => `lpt${String(index + 1)}`)
+]);
+/**
+* The name of an agent of `provider`, lowercased, or an error: a letter, then
+* letters, digits or `-`, 24 at most, so it fits an objection id
+* (`sol:terra:C1`) and a file name (`sol.md`) on every system. It cannot be a
+* word the run gives its own meaning, nor another provider's id.
+*/
+function validateAgentName(name, provider) {
+	const lower = name.trim().toLowerCase();
+	if (!NAME.test(lower)) throw new Error(`${name}: an agent name is a letter, then letters, digits or -, at most 24 characters`);
+	if (RESERVED.has(lower)) throw new Error(`${lower}: a reserved word, not an agent name`);
+	if (lower !== provider && PROVIDERS.some(({ id }) => id === lower)) throw new Error(`${lower}: the name of another provider, not an agent name`);
+	return lower;
+}
+function agents(value, { judgeEnv }) {
+	const entries = Object.entries(object("agents", value));
+	if (entries.length < 2) throw new Error("agents: needs at least two agents");
+	const values = {
+		model: [],
+		effort: [],
+		"review-effort": []
+	};
+	const specs = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [key, settings] of entries) {
+		const fields = object(`agents.${key}`, settings);
+		const own = PROVIDERS.find(({ id }) => id === key);
+		const named = own === void 0;
+		if (!named && "provider" in fields) throw new Error(`agents.${key}.provider: a provider key names its own provider; use another key for an instance`);
+		if (named && !("provider" in fields)) throw new Error(`agents.${key}: unknown agent. Expected one of ${PROVIDER_IDS$1}. A named agent sets "provider".`);
+		const provider = own ?? PROVIDERS.find(({ id }) => id === fields.provider);
+		if (!provider) throw notOneOf(`agents.${key}.provider`, IDS);
+		let name;
+		try {
+			name = validateAgentName(key, provider.id);
+		} catch (error) {
+			throw new Error(`agents.${error.message}`, { cause: error });
+		}
+		if (names.has(name)) throw new Error(`agents.${key}: ${name} is listed more than once`);
+		names.add(name);
+		specs.push(named ? `${provider.id}:${name}` : name);
+		for (const [field, setting] of Object.entries(fields)) {
+			if (named && field === "provider") continue;
+			const at = `agents.${key}.${field}`;
+			if (!Object.hasOwn(AGENT_FIELDS, field)) throw unknownKey(at, [...named ? ["provider"] : [], ...Object.keys(AGENT_FIELDS)], judgeEnv);
+			const flag = AGENT_FIELDS[field];
+			if (flag !== "model" && !provider.effort) throw new Error(`${at}: ${provider.label} does not take effort`);
+			values[flag].push(`${name}=${string(at, setting)}`);
+		}
+	}
+	return {
+		agents: specs.join(","),
+		...values
+	};
+}
+/** Every top-level key, what it becomes, and its check. The keys follow the flags' names. */
+const SETTINGS = {
+	agents,
+	mode: (value) => ({ mode: choice$1("mode", value, [
+		"fast",
+		"balanced",
+		"ultra"
+	]) }),
+	reviewMode: (value) => ({ "review-mode": choice$1("reviewMode", value, ["standard", "debate"]) }),
+	reviewRounds: (value) => ({ "review-rounds": String(choice$1("reviewRounds", value, [
+		0,
+		1,
+		2
+	])) }),
+	claimChecks: (value) => ({ "claim-checks": boolean("claimChecks", value) }),
+	finalizer: (value) => ({ finalizer: string("finalizer", value) }),
+	judgeModel: (value) => ({ "judge-model": string("judgeModel", value) }),
+	stragglerGrace: (value) => ({ "straggler-grace": seconds("stragglerGrace", value, true) }),
+	timeout: (value) => ({ timeout: seconds("timeout", value) }),
+	resume: (value) => ({ resume: boolean("resume", value) }),
+	rounds: (value) => ({ rounds: boolean("rounds", value) }),
+	json: (value) => ({ json: boolean("json", value) }),
+	verbose: (value) => ({ verbose: boolean("verbose", value) }),
+	allowAnyTask: (value) => ({ "allow-any-task": boolean("allowAnyTask", value) }),
+	runsDir: (value, { dir }) => ({ runsDir: (0, node_path.resolve)(dir, string("runsDir", value)) }),
+	output: (value, { dir }) => ({ output: (0, node_path.resolve)(dir, string("output", value)) }),
+	cwd: (value, { dir }) => ({ cwd: (0, node_path.resolve)(dir, string("cwd", value)) }),
+	task: (value) => ({ task: string("task", value) }),
+	taskFile: (value, { dir }) => ({ taskFile: (0, node_path.resolve)(dir, string("taskFile", value)) })
+};
+/** Every key a config may hold, `$schema` included; `config.schema.json` must list the same. */
+const CONFIG_KEYS = ["$schema", ...Object.keys(SETTINGS)];
+/**
+* Checks a config's text and turns it into flag-shaped values. Every error
+* names the file and the key. Rules that span a config and the flags, such as
+* a finalizer that is not one of the run's agents, are left to the CLI's
+* parsers, which run on the merged values.
+*
+* `explicit` is whether the file was named with `--config`: only such a file
+* may set `cwd`, so a file found inside a repository cannot send the agents to
+* another one. `judgeEnv` joins the providers' variables in the error for a
+* key that looks like a secret.
+*/
+function parseConfig(text, path, explicit, judgeEnv = []) {
+	let raw;
+	try {
+		raw = JSON.parse(text.replace(/^\uFEFF/, ""));
+	} catch (error) {
+		throw new Error(`${path}: not valid JSON: ${error.message}`, { cause: error });
+	}
+	const values = {
+		model: [],
+		effort: [],
+		"review-effort": []
+	};
+	try {
+		const top = object("the top level", raw);
+		const dir = (0, node_path.dirname)(path);
+		for (const [key, value] of Object.entries(top)) {
+			if (key === "$schema") continue;
+			if (!Object.hasOwn(SETTINGS, key)) throw unknownKey(key, CONFIG_KEYS, judgeEnv);
+			Object.assign(values, SETTINGS[key]?.(value, {
+				dir,
+				judgeEnv
+			}));
+		}
+		if ("cwd" in top && !explicit) throw new Error("cwd: allowed only in a file passed with --config, so a config inside a repository cannot point the agents at another one");
+		if ("task" in top && "taskFile" in top) throw new Error("task and taskFile: set one, not both");
+		if (values.runsDir !== void 0 && values.rounds === false) throw new Error("runsDir and rounds: false: set one, not both");
+	} catch (error) {
+		throw new Error(`${path}: ${error.message}`, { cause: error });
+	}
+	return values;
+}
+/**
+* The config for a run: the file named with `--config` (`explicit`, already
+* resolved), which must exist, or else `setup.file` in `dir`, where a missing
+* file just means no config.
+*/
+async function findConfig(dir, explicit, setup) {
+	const path = explicit ?? (0, node_path.join)(dir, setup.file);
+	let text;
+	try {
+		text = await (0, node_fs_promises.readFile)(path, "utf8");
+	} catch (error) {
+		if (explicit === void 0 && error.code === "ENOENT") return void 0;
+		throw new Error(`Cannot read the config ${path}: ${error.message}`, { cause: error });
+	}
+	return {
+		path,
+		values: parseConfig(text, path, explicit !== void 0, setup.judgeEnv)
+	};
+}
+/** Thrown before any agent call when the task is empty or a placeholder. */
+var TaskValidationError = class extends Error {
+	name = "TaskValidationError";
+};
+const MISSING_TASK_MESSAGE = "Missing coding task. Pass it as an argument, with --file, on stdin, or as task in the config file.";
+/** Piped text and a configured task at once: the pipe is never silently ignored. */
+const STDIN_CONFLICT_MESSAGE = "The task is piped on stdin and set in the config. Pass the task as an argument or with --file to override the config's task.";
+/**
+* Whole-text placeholders, compared after normalization. Kept short and fixed:
+* a false rejection costs a user more than a wasted run, so widen it only after
+* a real incident.
+*/
+const PLACEHOLDERS = /* @__PURE__ */ new Set([
+	"describe the coding change you want to plan",
+	"your task here",
+	"todo",
+	"tbd",
+	"<coding task>"
+]);
+/** Unfilled template slots: `<task>`, `{{task}}`, `[task]`, as the whole text. */
+const TEMPLATE_SLOTS = [
+	/^<[^>]*>$/,
+	/^\{\{.*\}\}$/s,
+	/^\[[^\]]*\]$/
+];
+const TRAILING_PUNCTUATION = /* @__PURE__ */ new Set(".!?,;:…");
+/** Lowercase, collapse whitespace, drop trailing punctuation: for comparison only. */
+function normalize(text) {
+	const collapsed = text.toLowerCase().replace(/\s+/g, " ");
+	let end = collapsed.length;
+	while (end > 0 && TRAILING_PUNCTUATION.has(collapsed.charAt(end - 1))) end -= 1;
+	return collapsed.slice(0, end);
+}
+function preview(text) {
+	const line = text.replace(/\s+/g, " ");
+	return line.length > 60 ? `${line.slice(0, 57)}...` : line;
+}
+/** The trimmed task, or a `TaskValidationError` if nothing is left. */
+function requireNonEmptyTask(raw) {
+	const task = raw.trim();
+	if (!task) throw new TaskValidationError(MISSING_TASK_MESSAGE);
+	return task;
+}
+/**
+* The trimmed task, or a `TaskValidationError` if it is empty or a near-certain
+* placeholder: a known template phrase, an unfilled `<…>`, `{{…}}` or `[…]`
+* slot, or text with no letters in it. Matches the whole text only, so a brief
+* that quotes a placeholder passes, and so does any short real task.
+*/
+function validateTask(raw) {
+	const task = requireNonEmptyTask(raw);
+	if (PLACEHOLDERS.has(normalize(task)) || TEMPLATE_SLOTS.some((slot) => slot.test(task)) || !/\p{L}/u.test(task)) throw new TaskValidationError(`The task looks like a placeholder: "${preview(task)}". Pass the change to plan as an argument, with --file, on stdin or in the config file, or use --allow-any-task to plan it anyway.`);
+	return task;
+}
+/** The file a program's CLI looks for in the repository. */
+const configFile = (program) => `${program.name}.json`;
+/** Where a program's runs keep their rounds by default, relative to the repository. */
+const runsDir = (program) => `.${program.name}`;
+/**
+* Every secret the program knows of, the judge's and every provider's: what
+* `createAgents` is given as `omitEnv`, so no agent subprocess inherits one.
+*/
+const secretEnv = (program) => [...program.judgeEnv.map(({ variable }) => variable), ...PROVIDERS.flatMap(({ secretEnv }) => secretEnv)];
+function agentLine(provider) {
+	const access = provider.kind === "cli" ? `agent CLI, reads the repository${provider.effort ? "; takes --effort" : ""}` : `chat API, gets a repository snapshot; needs ${provider.secretEnv.join(", ")}`;
+	return `  ${provider.id.padEnd(26)}${provider.label}: ${access}`;
+}
+/** `--help`'s text for `program`. */
+function helpText(program) {
+	const { name, judge } = program;
+	const variables = program.judgeEnv.map(({ variable }) => variable);
+	const requires = variables.length > 0 ? ` ${judge} requires ${variables.join(", ")}, which the config never holds.` : "";
+	return `${name} — ${program.summary}
+
+Usage:
+  ${name} [plan] [options] "<coding task>"
+  ${name} doctor [--agents <agents>] [--cwd <directory>]
+
+Options:
+  -c, --config <path>         Read the run's settings from this JSON file
+                              (default: ${configFile(program)} in the repository, if there is one)
+      --no-config             Read no config file
+  -C, --cwd <directory>       Repository to inspect (default: current directory)
+  -f, --file <path>           Read the coding task from a UTF-8 file
+  -o, --output <path>         Write the final plan to a file instead of stdout
+  -a, --agents <provider[:name],…>
+                              Two or more comma-separated agents (default: ${DEFAULT_AGENTS.join(",")});
+                              a provider can appear twice under different names,
+                              as codex:sol,codex:terra
+  -m, --model <name>=<model>  Override one agent's model; repeatable
+  -e, --effort <name>=<level> Override one agent's reasoning effort; repeatable
+      --review-effort <name>=<level>
+                              The effort for its cross-review and synthesis only; repeatable
+      --judge-model <model>   Override ${judge}'s model (default: ${program.judgeModelDefault})
+      --finalizer <name>      auto, none, or one of the agents (default: auto/${judge} decides);
+                              none keeps a cross-reviewed plan ${judge} rates stronger, unmerged
+      --mode <fast|balanced|ultra>
+                              fast: answer with the first draft ${judge} accepts alone
+                              balanced: ${judge} skips the rounds a run does not need
+                              ultra: always cross-review, then merge (default: balanced)
+      --review-rounds <0|1|2> Maximum cross-review rounds (default: 2)
+      --review-mode <standard|debate>
+                              debate: agents critique each other, authors answer,
+                              ${judge} rules on the disagreements (experimental; default: standard)
+      --claim-checks          In a debate, have two agents that read the repository
+                              check the disputed claims about it; implies debate
+      --straggler-grace <s>   In balanced and fast mode, how long a round waits for the agents
+                              still working once half have answered; 0 waits for
+                              every agent (default: 90)
+      --timeout <seconds>     Timeout for each agent call (default: 600)
+      --no-resume             Start each agent call afresh, not from its draft session
+      --json                  Emit plan metadata as JSON
+      --verbose               Stream each agent's work, then ${judge}'s verdict, to stderr
+      --rounds-dir <path>     Write every round's plans to round1/, round2/, …, final/
+                              (default: .${name}/<run>/ in the repository)
+      --no-rounds             Do not write the rounds anywhere
+      --allow-any-task        Plan the task even if it looks like a placeholder
+  -h, --help                  Show help
+  -v, --version               Show version
+
+Agents:
+${PROVIDERS.map(agentLine).join("\n")}
+
+The task can also be piped on stdin. A flag given here beats the config; --json,
+--verbose, --claim-checks and --allow-any-task each have a --no- form, and --resume
+and --rounds turn back on what the config turned off. Agent CLIs use their existing
+logins.${requires}`;
+}
+/** The planner's agents for `setup`: each spec's provider, built under the spec's name and label. */
+function createAgents(setup, env, omitEnv) {
+	return setup.agents.map(({ name, label, provider }) => provider.create({
+		name,
+		label,
+		...setup.models[name] === void 0 ? {} : { model: setup.models[name] },
+		...setup.efforts[name] === void 0 ? {} : { effort: setup.efforts[name] },
+		omitEnv,
+		env
+	}));
+}
+async function assertDirectory(path) {
+	if (!(await (0, node_fs_promises.stat)(path).catch(() => void 0))?.isDirectory()) throw new Error(`Not a directory: ${path}`);
+}
+const PROVIDER_IDS = PROVIDERS.map(({ id }) => id).join(", ");
+function provider(id, flag) {
+	const found = PROVIDERS.find((candidate) => candidate.id === id);
+	if (!found) throw new Error(`Unknown agent in ${flag}: ${id}. Expected one of ${PROVIDER_IDS}.`);
+	return found;
+}
+/** `<provider>[:<name>]`, as `--agents` and the config's `agents` list it. */
+function agentSpec(entry) {
+	const [id = "", name, ...rest] = entry.split(":").map((part) => part.trim().toLowerCase());
+	if (rest.length > 0) throw new Error(`Invalid agent in --agents: ${entry}. Expected <provider>[:<name>].`);
+	const found = provider(id, "--agents");
+	const resolved = name === void 0 ? found.id : validateAgentName(name, found.id);
+	return {
+		name: resolved,
+		label: agentLabel(found, resolved),
+		provider: found
+	};
+}
+function parseAgents(value) {
+	const agents = (value ?? DEFAULT_AGENTS.join(",")).split(",").map((entry) => entry.trim()).filter(Boolean).map(agentSpec);
+	const names = agents.map(({ name }) => name);
+	const duplicate = names.find((name, index) => names.indexOf(name) !== index);
+	if (duplicate !== void 0) {
+		const hint = PROVIDERS.some(({ id }) => id === duplicate) ? `; name each instance: ${duplicate}:a,${duplicate}:b` : "";
+		throw new Error(`--agents lists ${duplicate} more than once${hint}`);
+	}
+	if (agents.length < 2) throw new Error("--agents needs at least two agents");
+	return agents;
+}
+/** The run's agent `name` sets, or an error that says what `name` is instead. */
+function agentNamed(name, flag, agents) {
+	const found = agents.find((agent) => agent.name === name);
+	if (found) return found;
+	const instances = agents.filter((agent) => agent.provider.id === name);
+	const first = instances[0];
+	if (first) throw new Error(`${flag} ${name}: the run's ${first.provider.label} agents are ${instances.map((agent) => agent.name).join(", ")}; name one`);
+	if (PROVIDERS.some(({ id }) => id === name)) throw new Error(`${flag} sets ${name}, which is not one of the --agents`);
+	throw new Error(`Unknown agent in ${flag}: ${name}. Expected one of ${agents.map((agent) => agent.name).join(", ")}.`);
+}
+/** Repeated `<name>=<value>` flags, by agent name; each must be one of the run's agents. */
+function parseOverrides(flag, values, agents, accepts = () => true) {
+	const overrides = {};
+	const placeholder = flag.slice(2);
+	for (const value of values) {
+		const separator = value.indexOf("=");
+		const name = value.slice(0, separator).trim().toLowerCase();
+		const setting = value.slice(separator + 1).trim();
+		if (separator < 0 || !name || !setting) throw new Error(`Invalid ${flag} value: ${value}. Expected <agent>=<${placeholder}>.`);
+		const agent = agentNamed(name, flag, agents);
+		if (!accepts(agent.provider)) throw new Error(`${agent.provider.label} does not take ${flag}`);
+		overrides[name] = setting;
+	}
+	return overrides;
+}
+/** `auto` gives `undefined`, `none` gives `'none'`, an agent gives its name. */
+function parseFinalizer(value, agents) {
+	if (value === void 0 || value === "auto") return void 0;
+	const name = value.toLowerCase();
+	if (name === "none" || agents.some((agent) => agent.name === name)) return name;
+	throw new Error(`Invalid --finalizer value: ${value}. Expected auto, none or one of ${agents.map((a) => a.name).join(", ")}.`);
+}
+/** Creates `dir`, which must be new or empty so rounds from different runs never mix. */
+async function prepareRoundsDir(dir) {
+	if ((await (0, node_fs_promises.readdir)(dir).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	})).length > 0) throw new Error(`--rounds-dir must be new or empty: ${dir}`);
+	await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+}
+/**
+* A new folder for this run under `home`, `<cwd>/.<name>/` unless the
+* config names a `runsDir`, named by its UTC start time with no `:` so it is a valid name on Windows too. A second run in the
+* same second gets `-2`, and so on: `mkdir` without `recursive` fails on an
+* existing folder, so two runs can never claim the same one.
+*
+* The first run also writes `.gitignore` with `*` in `home`, so the output
+* never shows up as untracked in the repository being planned. One that is
+* already there is left alone.
+*/
+async function newRunDir(home, now, name) {
+	await (0, node_fs_promises.mkdir)(home, { recursive: true });
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(home, ".gitignore"), `# Written by ${name}: run output, not source.\n*\n`, { flag: "wx" }).catch((error) => {
+		if (error.code !== "EEXIST") throw error;
+	});
+	const stamp = now.toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+	for (let attempt = 1;; attempt++) {
+		const dir = (0, node_path.join)(home, attempt === 1 ? stamp : `${stamp}-${String(attempt)}`);
+		try {
+			await (0, node_fs_promises.mkdir)(dir);
+			return dir;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+}
+/** What a debate round's raw answers are saved as, beside its plans. */
+const ARTIFACT_SUFFIX = {
+	critique: "critique",
+	reply: "reply",
+	review: "reply",
+	check: "check"
+};
+const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+/**
+* One folder per round: `round<N>/<agent>.md` for each agent's plan, with the judge's
+* `verdict.json` beside a judged round's plans, `timings.json` in every
+* round, and `final/plan.md` last. A debate round adds each agent's raw answer
+* as `<agent>.critique.md`, `.reply.md` or `.check.md`, and what was parsed
+* from them as `objections.json`, `replies.json` and `disputes.json`; its
+* critique and check rounds leave the plans unchanged, so write none.
+*/
+async function writeRound(dir, round) {
+	const folder = (0, node_path.join)(dir, round.stage === "final" ? "final" : `round${String(round.round)}`);
+	await (0, node_fs_promises.mkdir)(folder, { recursive: true });
+	const files = round.stage === "final" ? Object.entries(round.plans).map(([agent, plan]) => ["plan.md", `<!-- ${round.selected ? "selected from" : "merged by"} ${agent} -->\n${plan.trim()}\n`]) : round.stage === "critique" || round.stage === "check" ? [] : Object.entries(round.plans).map(([agent, plan]) => [`${agent}.md`, `${plan.trim()}\n`]);
+	const suffix = ARTIFACT_SUFFIX[round.stage];
+	if (round.artifacts && suffix !== void 0) for (const [agent, text] of Object.entries(round.artifacts)) files.push([`${agent}.${suffix}.md`, `${text.trim()}\n`]);
+	const { debate } = round;
+	if (debate) {
+		if (round.stage === "critique") files.push(["objections.json", json(debate.objections)]);
+		if (debate.replies) files.push(["replies.json", json({
+			replies: debate.replies,
+			unanswered: debate.unanswered ?? []
+		})]);
+		if (debate.disputes) files.push(["disputes.json", json({
+			disputes: debate.disputes,
+			overflow: debate.overflow ?? [],
+			...debate.claimChecks ? { claimChecks: debate.claimChecks } : {}
+		})]);
+	}
+	if (round.verdict) files.push(["verdict.json", json(round.verdict)]);
+	files.push(["timings.json", `${JSON.stringify(round.timings, null, 2)}\n`]);
+	await Promise.all(files.map(([name, text]) => (0, node_fs_promises.writeFile)((0, node_path.join)(folder, name), text, "utf8")));
+}
+/** `4m12s`, `51s` or `0.8s`: minutes once a minute has passed, tenths below ten seconds. */
+function formatDuration(ms) {
+	const seconds = ms / 1e3;
+	if (seconds < 10) return `${seconds.toFixed(1)}s`;
+	const whole = Math.round(seconds);
+	if (whole < 60) return `${String(whole)}s`;
+	return `${String(Math.floor(whole / 60))}m${String(whole % 60).padStart(2, "0")}s`;
+}
+const STAGE_NAMES = {
+	draft: "Drafts",
+	critique: "Critiques",
+	reply: "Replies",
+	check: "Claim checks",
+	review: "Review",
+	final: "Final plan"
+};
+/** One line per round for `--verbose`: the round, then each agent call and the judge's. */
+function roundTimingLine(round, labels, judge) {
+	const calls = [...Object.entries(round.timings.agents).map(([agent, ms]) => `${labels.get(agent) ?? agent} ${formatDuration(ms)}`), ...round.timings.judgeMs === void 0 ? [] : [`${judge} ${formatDuration(round.timings.judgeMs)}`]];
+	const line = `${STAGE_NAMES[round.stage]}: ${formatDuration(round.timings.totalMs)}`;
+	return calls.length > 0 ? `${line} (${calls.join(", ")})` : line;
+}
+/**
+* What the run spent, on one line, so the cost of a mode is visible without
+* `--json`. `judge` names the judge's calls: `Jev`.
+*/
+function costLine(cost, judge) {
+	const plural = (count, thing) => `${String(count)} ${thing}${count === 1 ? "" : "s"}`;
+	const parts = [
+		`${cost.mode} mode`,
+		...cost.reviewMode === "debate" ? ["debate review"] : [],
+		plural(cost.agentCalls, "agent call"),
+		plural(cost.judgeCalls, `${judge} call`),
+		plural(cost.reviewRounds, "cross-review round"),
+		cost.synthesized ? "merged" : cost.mode === "fast" ? "selected" : "adopted whole"
+	];
+	if (cost.dropped.length > 0) parts.push(`not waited for: ${cost.dropped.join(", ")}`);
+	return parts.join(", ");
+}
+function parseTimeout(value) {
+	const seconds = Number(value ?? "600");
+	if (!Number.isFinite(seconds) || seconds <= 0) throw new Error("--timeout must be a positive number of seconds");
+	return Math.round(seconds * 1e3);
+}
+function parseReviewRounds(value) {
+	if (value === void 0 || value === "2") return 2;
+	if (value === "1") return 1;
+	if (value === "0") return 0;
+	throw new Error("--review-rounds must be 0, 1 or 2");
+}
+function parseMode(value) {
+	if (value === void 0 || value === "balanced") return "balanced";
+	if (value === "ultra" || value === "fast") return value;
+	throw new Error(`Invalid --mode value: ${value}. Expected fast, balanced or ultra.`);
+}
+function parseReviewMode(value, claimChecks, reviewRounds, planMode) {
+	let mode;
+	if (value === void 0) mode = claimChecks ? "debate" : "standard";
+	else if (value === "standard" || value === "debate") mode = value;
+	else throw new Error(`Invalid --review-mode value: ${value}. Expected standard or debate.`);
+	if (claimChecks && mode !== "debate") throw new Error("--claim-checks runs in the debate review; drop --review-mode standard");
+	if (mode === "debate" && planMode === "fast") throw new Error(`${claimChecks ? "--claim-checks" : "--review-mode debate"} needs a review round, and --mode fast has none`);
+	if (mode === "debate" && reviewRounds === 0) throw new Error("--review-mode debate is a review round; it needs --review-rounds 1 or 2");
+	return mode;
+}
+function parseStragglerGrace(value, mode) {
+	if (value === void 0) return void 0;
+	if (mode === "ultra") throw new Error("--straggler-grace is for --mode balanced or fast; ultra never drops an agent");
+	const seconds = Number(value);
+	if (!Number.isFinite(seconds) || seconds < 0) throw new Error("--straggler-grace must be a number of seconds, 0 or more");
+	return Math.round(seconds * 1e3);
+}
+/**
+* A boolean flag and its `--no-` form: `undefined` when neither was given, so
+* the config decides. Written out rather than with `allowNegative`, which also
+* takes `--no-cwd` and the like as `false`.
+*/
+function toggle(on, off, name) {
+	if (on && off) throw new Error(`Pass --${name} or --no-${name}, not both`);
+	return on ? true : off ? false : void 0;
+}
+/**
+* The config's per-agent `<name>=<value>` entries for the run's agents only,
+* then the flags', which win. An entry is kept only where the run's agent of
+* that name has the provider the config gave it, so a Codex model set for
+* `sol` never reaches `--agents claude:sol`.
+*/
+function withConfig(configured, given, agents, configAgents) {
+	const providerOf = new Map((configAgents ?? "").split(",").map((entry) => {
+		const [id = "", name = id] = entry.split(":");
+		return [name, id];
+	}));
+	return [...configured.filter((entry) => {
+		const name = entry.slice(0, entry.indexOf("="));
+		return agents.some((agent) => agent.name === name && agent.provider.id === providerOf.get(name));
+	}), ...given];
+}
+/**
+* A warning for agents of one provider with the same model and draft effort,
+* whose drafts may barely differ; `undefined` when every agent differs.
+*/
+function identicalWarning(agents, models, efforts) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const agent of agents) {
+		const key = JSON.stringify([
+			agent.provider.id,
+			models[agent.name],
+			efforts[agent.name]
+		]);
+		groups.set(key, [...groups.get(key) ?? [], agent]);
+	}
+	const same = [...groups.values()].find((group) => group.length > 1);
+	if (!same) return void 0;
+	const names = same.map(({ name }) => name);
+	const list = `${names.slice(0, -1).join(", ")} and ${String(names.at(-1))}`;
+	const [first] = same;
+	return `${list} are ${same.length > 2 ? "all" : "both"} ${String(first?.provider.label)} with the same model and effort; their drafts may barely differ. Vary --model or --effort.`;
+}
+const NO_CONFIG = {
+	model: [],
+	effort: [],
+	"review-effort": []
+};
+function parse(argv) {
+	return (0, node_util.parseArgs)({
+		args: [...argv],
+		allowPositionals: true,
+		strict: true,
+		options: {
+			config: {
+				type: "string",
+				short: "c"
+			},
+			"no-config": { type: "boolean" },
+			cwd: {
+				type: "string",
+				short: "C"
+			},
+			file: {
+				type: "string",
+				short: "f"
+			},
+			output: {
+				type: "string",
+				short: "o"
+			},
+			agents: {
+				type: "string",
+				short: "a"
+			},
+			model: {
+				type: "string",
+				short: "m",
+				multiple: true,
+				default: []
+			},
+			effort: {
+				type: "string",
+				short: "e",
+				multiple: true,
+				default: []
+			},
+			"review-effort": {
+				type: "string",
+				multiple: true,
+				default: []
+			},
+			"judge-model": { type: "string" },
+			finalizer: { type: "string" },
+			mode: { type: "string" },
+			"review-rounds": { type: "string" },
+			"review-mode": { type: "string" },
+			"claim-checks": { type: "boolean" },
+			"no-claim-checks": { type: "boolean" },
+			"straggler-grace": { type: "string" },
+			timeout: { type: "string" },
+			resume: { type: "boolean" },
+			"no-resume": { type: "boolean" },
+			json: { type: "boolean" },
+			"no-json": { type: "boolean" },
+			verbose: { type: "boolean" },
+			"no-verbose": { type: "boolean" },
+			"rounds-dir": { type: "string" },
+			rounds: { type: "boolean" },
+			"no-rounds": { type: "boolean" },
+			"allow-any-task": { type: "boolean" },
+			"no-allow-any-task": { type: "boolean" },
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			},
+			version: {
+				type: "boolean",
+				short: "v",
+				default: false
+			}
+		}
+	});
+}
+async function run(argv, deps) {
+	const { values, positionals } = parse(argv);
+	const { program } = deps;
+	const say = (message) => {
+		deps.stderr(`[${program.name}] ${message}\n`);
+	};
+	if (values.help) {
+		deps.stdout(`${helpText(program)}\n`);
+		return 0;
+	}
+	if (values.version) {
+		deps.stdout(`${program.version}\n`);
+		return 0;
+	}
+	const invoked = deps.cwd();
+	if (values.config !== void 0 && values["no-config"]) throw new Error("Pass --config or --no-config, not both");
+	const config = values["no-config"] ? void 0 : await findConfig((0, node_path.resolve)(invoked, values.cwd ?? "."), values.config === void 0 ? void 0 : (0, node_path.resolve)(invoked, values.config), {
+		file: configFile(program),
+		judgeEnv: program.judgeEnv.map(({ variable }) => variable)
+	});
+	if (config) say(`Using config ${config.path}`);
+	const configured = config?.values ?? NO_CONFIG;
+	const cwd = values.cwd === void 0 ? configured.cwd ?? invoked : (0, node_path.resolve)(invoked, values.cwd);
+	await assertDirectory(cwd);
+	const agents = parseAgents(values.agents ?? configured.agents);
+	if (positionals[0] === "doctor") {
+		if (positionals.length > 1) throw new Error("doctor does not accept a task");
+		const providers = [...new Set(agents.map(({ provider }) => provider))];
+		const checks = [...await deps.doctor(cwd, providers), ...program.judgeEnv.map(({ check, variable }) => envCheck(check, variable, deps.env))];
+		for (const check of checks) deps.stdout(`${check.ok ? "✓" : "✗"} ${check.name}: ${check.detail}\n`);
+		return checks.every((check) => check.ok) ? 0 : 1;
+	}
+	const taskPositionals = positionals[0] === "plan" ? positionals.slice(1) : positionals;
+	if (values.file !== void 0 && taskPositionals.length > 0) throw new Error("Provide the task either as arguments or with --file, not both");
+	let task = taskPositionals.join(" ").trim();
+	if (values.file !== void 0) task = (await (0, node_fs_promises.readFile)((0, node_path.resolve)(invoked, values.file), "utf8")).trim();
+	if (!task) {
+		const piped = (await deps.readStdin())?.trim() ?? "";
+		if (piped && (configured.task ?? configured.taskFile) !== void 0) throw new Error(STDIN_CONFLICT_MESSAGE);
+		if (configured.task !== void 0) task = configured.task;
+		else if (configured.taskFile !== void 0) task = (await (0, node_fs_promises.readFile)(configured.taskFile, "utf8")).trim();
+		else task = piped;
+	}
+	const allowAnyTask = toggle(values["allow-any-task"], values["no-allow-any-task"], "allow-any-task") ?? configured["allow-any-task"] ?? false;
+	task = allowAnyTask ? requireNonEmptyTask(task) : validateTask(task);
+	const unset = program.judgeEnv.find(({ variable }) => !deps.env[variable]?.trim());
+	if (unset) throw new Error(unset.missing);
+	const models = parseOverrides("--model", withConfig(configured.model, values.model, agents, configured.agents), agents);
+	const efforts = parseOverrides("--effort", withConfig(configured.effort, values.effort, agents, configured.agents), agents, (provider) => provider.effort);
+	const reviewEfforts = parseOverrides("--review-effort", withConfig(configured["review-effort"], values["review-effort"], agents, configured.agents), agents, (provider) => provider.effort);
+	const finalizer = parseFinalizer(values.finalizer ?? configured.finalizer, agents);
+	const judgeModel = values["judge-model"] ?? configured["judge-model"];
+	const mode = parseMode(values.mode ?? configured.mode);
+	const stragglerGraceMs = parseStragglerGrace(values["straggler-grace"] ?? configured["straggler-grace"], mode);
+	const maxReviewRounds = parseReviewRounds(values["review-rounds"] ?? configured["review-rounds"]);
+	const claimChecks = toggle(values["claim-checks"], values["no-claim-checks"], "claim-checks") ?? configured["claim-checks"] ?? false;
+	const reviewMode = parseReviewMode(values["review-mode"] ?? configured["review-mode"], claimChecks, maxReviewRounds, mode);
+	const resume = toggle(values.resume, values["no-resume"], "resume") ?? configured.resume ?? true;
+	const asJson = toggle(values.json, values["no-json"], "json") ?? configured.json ?? false;
+	const verbose = toggle(values.verbose, values["no-verbose"], "verbose") ?? configured.verbose ?? false;
+	const rounds = toggle(values.rounds, values["no-rounds"], "rounds");
+	if (rounds === false && values["rounds-dir"] !== void 0) throw new Error("Pass --rounds-dir or --no-rounds, not both");
+	let roundsDir;
+	if (values["rounds-dir"] !== void 0) {
+		roundsDir = (0, node_path.resolve)(cwd, values["rounds-dir"]);
+		await prepareRoundsDir(roundsDir);
+	} else if (rounds ?? configured.rounds ?? true) roundsDir = await newRunDir(configured.runsDir ?? (0, node_path.join)(cwd, runsDir(program)), deps.now(), program.name);
+	if (roundsDir !== void 0) say(`Writing rounds to ${roundsDir}`);
+	const warning = identicalWarning(agents, models, efforts);
+	if (warning !== void 0) say(warning);
+	const planner = deps.createPlanner({
+		agents,
+		models,
+		efforts
+	});
+	const labels = new Map(agents.map(({ name, label }) => [name, label]));
+	const result = await planner.plan({
+		task,
+		cwd,
+		timeoutMs: parseTimeout(values.timeout ?? configured.timeout),
+		mode,
+		maxReviewRounds,
+		...reviewMode === "debate" ? { reviewMode } : {},
+		...claimChecks ? { claimChecks } : {},
+		...stragglerGraceMs === void 0 ? {} : { stragglerGraceMs },
+		...judgeModel ? { judgeModel } : {},
+		...finalizer === "none" ? { selectStronger: true } : finalizer ? { finalizer } : {},
+		...allowAnyTask ? { allowAnyTask } : {},
+		...Object.keys(reviewEfforts).length > 0 ? { reviewEfforts } : {},
+		...resume ? {} : { resume: false },
+		onStage: say,
+		...verbose ? { onAgentProgress: (agent, progress) => {
+			for (const line of progress.split("\n")) deps.stderr(`[${agent}] ${line}\n`);
+		} } : {},
+		...roundsDir === void 0 && !verbose ? {} : { onRound: async (round) => {
+			if (verbose) say(roundTimingLine(round, labels, program.judge));
+			if (roundsDir !== void 0) await writeRound(roundsDir, round);
+		} }
+	});
+	if (verbose) {
+		say(`Total: ${formatDuration(result.timings.totalMs)}`);
+		say(`${program.judge} verdict:\n${JSON.stringify(result.verdict, null, 2)}`);
+	}
+	say(costLine(result.cost, program.judge));
+	const rendered = asJson ? `${JSON.stringify({
+		plan: result.plan,
+		verdict: result.verdict,
+		finalizer: result.finalizer,
+		...result.selected ? { selected: true } : {},
+		...result.debate ? { debate: result.debate } : {},
+		timings: result.timings,
+		cost: result.cost
+	}, null, 2)}\n` : `${result.plan.trim()}\n`;
+	const output = values.output ?? configured.output;
+	if (output === void 0) deps.stdout(rendered);
+	else {
+		const outputPath = (0, node_path.resolve)(cwd, output);
+		await (0, node_fs_promises.writeFile)(outputPath, rendered, "utf8");
+		say(`Wrote ${outputPath}`);
+	}
+	return 0;
+}
+/**
+* Runs the CLI and resolves to its exit code. Never rejects: every failure is
+* reported on stderr as `<name>: <message>` with exit code 1.
+*/
+async function main(argv, deps) {
+	try {
+		return await run(argv, deps);
+	} catch (error) {
+		deps.stderr(`${deps.program.name}: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 1;
+	}
+}
+const TARGET = /^[\s#>*_-]*target\s*:\s*[*_`]*\s*(.+?)\s*[*_`]*\s*$/i;
+const OBJECTION = /^\s*[-*]?\s*\**C(\d+)\**\s*(\[[^\]]+\])?\s*\**\s*[:.)]\s*\**\s*(.+)$/i;
+const REASON = /\s+(?:—|–|--|-)\s+|\s*[—–]\s*/;
+const REPLY = /^\s*[-*]?\s*(?:R\s+)?\**([\w.-]+:[\w.-]+:C\d+)\**\s*:\s*\**(accept|reject)\**\s*(?:[—–:-]+\s*)?(.*)$/i;
+const CHECK = /^\s*[-*]?\s*\**(D\d+)\**\s*:\s*\**(confirm|refute|unknown)\**\s*(?:[—–:-]+\s*)?(.*)$/i;
+const lines = (text) => text.replace(/\r\n?/g, "\n").split("\n");
+/** Splits `claim — reason` on the first dash that separates them. */
+function claimAndReason(text) {
+	const match = REASON.exec(text);
+	if (!match) return {
+		claim: text.trim(),
+		why: ""
+	};
+	return {
+		claim: text.slice(0, match.index).trim(),
+		why: text.slice(match.index + match[0].length).trim()
+	};
+}
+/**
+* One critic's objections, by the agent each is aimed at. Lines that are not
+* objections, objections to an agent that is not a peer, repeated ids and
+* objections past `MAX_OBJECTIONS` per peer go to `prose`. Never throws.
+*/
+function parseCritique(critic, text, peers) {
+	const objections = [];
+	const prose = [];
+	const lookup = (value) => {
+		const wanted = value.trim().toLowerCase();
+		return peers.find(({ name, label }) => name.toLowerCase() === wanted || label.toLowerCase() === wanted);
+	};
+	let target = peers.length === 1 ? peers[0] : void 0;
+	for (const line of lines(text)) {
+		const heading = TARGET.exec(line);
+		if (heading?.[1] !== void 0) {
+			target = lookup(heading[1]);
+			if (!target) prose.push(line.trim());
+			continue;
+		}
+		const [, number, tag, body] = OBJECTION.exec(line) ?? [];
+		const id = target && number !== void 0 ? `${critic}:${target.name}:C${number}` : void 0;
+		if (!target || id === void 0 || body === void 0 || objections.some((objection) => objection.id === id) || objections.filter((objection) => objection.target === target?.name).length >= 5) {
+			if (line.trim()) prose.push(line.trim());
+			continue;
+		}
+		objections.push({
+			id,
+			critic,
+			target: target.name,
+			...claimAndReason(body.replace(/\*+$/, "")),
+			repo: tag?.toLowerCase() === "[repo]"
+		});
+	}
+	return {
+		objections,
+		prose: prose.join("\n")
+	};
+}
+/** The text between `<tag>` and `</tag>`, or to the end when it is never closed. */
+function tagged(text, tag) {
+	const open = new RegExp(`<${tag}>`, "i").exec(text);
+	if (!open) return void 0;
+	const from = open.index + open[0].length;
+	const close = new RegExp(`</${tag}>`, "i").exec(text.slice(from));
+	const to = close ? from + close.index : text.length;
+	return {
+		inner: text.slice(from, to),
+		start: open.index,
+		end: close ? to + close[0].length : text.length
+	};
+}
+/**
+* An author's answers to the objections `ids`, and its revised plan.
+*
+* The plan is the `<revised-plan>` block, else what follows a `## Revised plan`
+* heading, else the text outside `<replies>` without the reply lines; when all
+* of those are empty it is `previousPlan`, so reply prose never stands in for
+* a plan. A reply to an id not in `ids` is ignored, and for a repeated id the
+* first reply wins. Never throws.
+*/
+function parseReply(author, text, ids, previousPlan) {
+	const normalized = text.replace(/\r\n?/g, "\n");
+	const planBlock = tagged(normalized, "revised-plan");
+	const withoutPlan = planBlock ? normalized.slice(0, planBlock.start) + normalized.slice(planBlock.end) : normalized;
+	const replyBlock = tagged(withoutPlan, "replies");
+	const replies = [];
+	const prose = [];
+	const known = new Map(ids.map((id) => [id.toLowerCase(), id]));
+	const replyLines = /* @__PURE__ */ new Set();
+	for (const line of lines(replyBlock ? replyBlock.inner : withoutPlan)) {
+		const [, rawId, decision, reason] = REPLY.exec(line) ?? [];
+		const id = rawId === void 0 ? void 0 : known.get(rawId.toLowerCase());
+		if (rawId !== void 0) replyLines.add(line);
+		if (id === void 0 || decision === void 0 || reason === void 0) {
+			if (replyBlock && rawId === void 0 && line.trim()) prose.push(line.trim());
+			continue;
+		}
+		if (replies.some((reply) => reply.id === id)) continue;
+		replies.push({
+			id,
+			author,
+			decision: decision.toLowerCase() === "accept" ? "accept" : "reject",
+			reason: reason.trim()
+		});
+	}
+	let plan = planBlock?.inner.trim() ?? "";
+	if (!plan) {
+		const heading = /^#{1,6}\s*revised plan\s*$/im.exec(withoutPlan);
+		const rest = heading ? withoutPlan.slice(heading.index + heading[0].length) : replyBlock ? withoutPlan.slice(0, replyBlock.start) + withoutPlan.slice(replyBlock.end) : withoutPlan;
+		plan = lines(rest).filter((line) => !replyLines.has(line)).join("\n").trim();
+	}
+	return {
+		replies,
+		plan: plan || previousPlan,
+		prose: prose.join("\n")
+	};
+}
+/** Lowercase, punctuation and whitespace collapsed: two claims match only when these are equal. */
+function normalizeClaim(claim) {
+	return claim.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+/**
+* The objections their authors rejected, as disputes for the judge: the same claim
+* against the same plan is merged, whoever raised it, and nothing else is.
+* Ranked by how many critics raised it, then claims about the repository,
+* then the order they were raised; the first `cap` are for the judge to rule on.
+*/
+function buildDisputes(objections, replies, cap = 8) {
+	const rejected = new Map(replies.filter((reply) => reply.decision === "reject").map((reply) => [reply.id, reply]));
+	const groups = /* @__PURE__ */ new Map();
+	for (const objection of objections) {
+		const reply = rejected.get(objection.id);
+		if (!reply) continue;
+		const key = `${objection.target}\n${normalizeClaim(objection.claim)}`;
+		const group = groups.get(key);
+		if (group) {
+			if (!group.critics.includes(objection.critic)) group.critics.push(objection.critic);
+			group.objections.push(objection.id);
+			if (objection.why) group.reasons.push(objection.why);
+			if (reply.reason) group.rejections.push(reply.reason);
+			group.repo ||= objection.repo;
+			continue;
+		}
+		groups.set(key, {
+			id: "",
+			target: objection.target,
+			critics: [objection.critic],
+			objections: [objection.id],
+			claim: objection.claim,
+			reasons: objection.why ? [objection.why] : [],
+			rejections: reply.reason ? [reply.reason] : [],
+			repo: objection.repo
+		});
+	}
+	const ranked = [...groups.values()].sort((a, b) => b.critics.length - a.critics.length || Number(b.repo) - Number(a.repo)).map((dispute, index) => ({
+		...dispute,
+		id: `D${String(index + 1)}`
+	}));
+	return {
+		disputes: ranked.slice(0, cap),
+		overflow: ranked.slice(cap)
+	};
+}
+/**
+* Who checks each repository claim: an agent that reads the repository and did
+* not raise it, the author's peers before the author. Spread across the
+* checkers in turn; a claim nobody may check is left out.
+*/
+function assignChecks(disputes, checkers) {
+	const assigned = /* @__PURE__ */ new Map();
+	disputes.forEach((dispute, index) => {
+		const eligible = checkers.filter((checker) => !dispute.critics.includes(checker));
+		const peers = eligible.filter((checker) => checker !== dispute.target);
+		const pool = peers.length > 0 ? peers : eligible;
+		const checker = pool[index % Math.max(1, pool.length)];
+		if (checker === void 0) return;
+		assigned.set(checker, [...assigned.get(checker) ?? [], dispute]);
+	});
+	return assigned;
+}
+/** A checker's answer for each id in `ids`; a missing or unparseable answer is `unknown`. */
+function parseChecks(checker, text, ids) {
+	const checks = /* @__PURE__ */ new Map();
+	for (const line of lines(text)) {
+		const [, id, result, evidence] = CHECK.exec(line) ?? [];
+		if (id === void 0 || result === void 0 || evidence === void 0) continue;
+		const wanted = ids.find((candidate) => candidate.toLowerCase() === id.toLowerCase());
+		if (wanted === void 0 || checks.has(wanted)) continue;
+		checks.set(wanted, {
+			checker,
+			result: result.toLowerCase(),
+			evidence: evidence.trim()
+		});
+	}
+	for (const id of ids) if (!checks.has(id)) checks.set(id, {
+		checker,
+		result: "unknown",
+		evidence: ""
+	});
+	return checks;
+}
+/**
+* The rules every stage shares. How much of the repository to read differs by
+* stage: only the draft explores it; later stages open a file to settle a point.
+*/
+function planContract(repository) {
+	return `
+You are designing an implementation plan, not implementing code. Work read-only.
+${repository} Make the plan specific to files and symbols that exist.
+Call out assumptions and unresolved questions. Prefer a small, verifiable sequence of changes.
+Include architecture, edge cases, tests, validation, and rollout/compatibility concerns.
+If the task is a placeholder or too vague to act on, say so and list the clarifying questions instead of inventing scope.
+Keep the response under 1,500 words. Return Markdown only.`;
+}
+const EXPLORE = "Inspect the repository before deciding.";
+const CHECK_DISPUTES = "You examined the repository while drafting. Open a file only to check a claim on which the plans disagree, or one you are unsure of.";
+const SETTLE_CONTRADICTIONS = "Work from the plans below. Open a file only to settle a contradiction between them.";
+/** "Claude", "Claude and GLM", "Claude, GLM and Kimi". */
+function listLabels(labels) {
+	return labels.join(", ").replace(/, ([^,]*)$/, " and $1");
+}
+function planBlocks(plans, tag) {
+	return plans.map(({ label, plan, name }) => `${label}'s plan:\n<${tag} author="${label}"${name === void 0 ? "" : ` agent="${name}"`}>\n${plan}\n</${tag}>`).join("\n\n");
+}
+function initialPlanPrompt(task, peers) {
+	return `${planContract(EXPLORE)}
+
+You are the first planner in a collaboration with ${listLabels(peers)}. Produce your strongest independent plan.
+
+Task:
+<task>
+${task}
+</task>`;
+}
+/** The task, unless the agent is continuing a conversation that already has it. */
+function taskBlock(task, resumed) {
+	return resumed ? "" : `Task:\n<task>\n${task}\n</task>\n\n`;
+}
+/**
+* `resumed` is for an agent continuing its own conversation, which already
+* holds the task and its last plan: both are left out.
+*/
+function revisionPrompt(input) {
+	const peers = listLabels(input.peerPlans.map(({ label }) => label));
+	const ownPlan = input.resumed ? "" : `Your earlier draft:\n<own-plan>\n${input.ownPlan}\n</own-plan>\n\n`;
+	return `${planContract(CHECK_DISPUTES)}
+
+You are reviewing peer plans from ${peers}. Compare them with your ${input.resumed ? "last plan in this conversation" : "own draft"}, correct weak assumptions,
+adopt useful details, and return a revised standalone plan. Do not merely write a critique.
+
+${taskBlock(input.task, input.resumed)}${ownPlan}${planBlocks(input.peerPlans, "peer-plan")}${input.feedback === void 0 ? "" : input.targeted ? `\n\nThe debate left these disagreements open. Settle each one in your revised plan, checking the repository where a claim is about it:\n<open-disagreements>\n${input.feedback}\n</open-disagreements>` : `\n\nThe judge identified remaining uncertainty. Use this typed feedback to target the revision:\n<judge-feedback>\n${input.feedback}\n</judge-feedback>`}`;
+}
+/** `resumed` is for an agent continuing its own conversation: the task is left out. */
+function finalPlanPrompt(input) {
+	return `${planContract(SETTLE_CONTRADICTIONS)}
+
+Act as the final editor. Merge the best concrete parts of all the revised plans, guided by the judge's typed verdict.
+Resolve contradictions explicitly. Return one self-contained execution plan—no discussion of the planning process,
+no winner announcement, and no judge commentary.
+
+${taskBlock(input.task, input.resumed)}${planBlocks(input.plans, "revised-plan")}
+
+Judge verdict:
+<judge-verdict>
+${input.verdict}
+</judge-verdict>${input.disputes === void 0 ? "" : `
+
+The agents' disagreements, and the judge's ruling on each. Follow a ruling unless the plans show it wrong:
+<disputes>
+${input.disputes}
+</disputes>`}`;
+}
+/** The format a critique answers in, shown to the critic. */
+const CRITIQUE_FORMAT = `TARGET: <agent>
+C1 [repo]: <claim about a file, symbol or export> — <why it matters>
+C2: <claim about the design> — <why it matters>`;
+/**
+* Asks an agent for its objections to every peer plan, and nothing else: no
+* revision yet. `resumed` is for an agent continuing its own conversation,
+* which already holds the task and its own plan.
+*/
+function critiquePrompt(input) {
+	const ownPlan = input.resumed ? "" : `Your own draft, for reference:\n<own-plan>\n${input.ownPlan}\n</own-plan>\n\n`;
+	return `${planContract(CHECK_DISPUTES)}
+
+Do not write a plan this time. Critique the peer plans below: find what is wrong in each, not what
+is good. For each peer, write a TARGET line with its agent name, then at most ${String(5)} numbered
+objections, most important first:
+
+${CRITIQUE_FORMAT}
+
+Mark an objection [repo] only when it makes a claim about the repository that someone could check
+by opening a file. Say why each objection matters after a dash. Raise only objections you would
+defend; an author will accept or reject each one, and the judge will rule on the rejected ones.
+
+${taskBlock(input.task, input.resumed)}${ownPlan}${planBlocks(input.peerPlans, "peer-plan")}`;
+}
+/**
+* Asks an author to accept or reject every objection to its plan, then to
+* return its revised plan. `resumed` leaves out the task and its own plan.
+*/
+function replyPrompt(input) {
+	const ownPlan = input.resumed ? "" : `Your plan:\n<own-plan>\n${input.ownPlan}\n</own-plan>\n\n`;
+	const received = input.objections.length === 0 ? "No objections were raised against your plan. Return it, improved where you see fit." : `The other agents raised these objections against your plan:
+<objections>
+${input.objections.map(({ id, criticLabel, claim, why, repo }) => `${id} (${criticLabel}${repo ? ", about the repository" : ""}): ${claim}${why ? ` — ${why}` : ""}`).join("\n")}
+</objections>
+
+Answer every objection on its own line, by its id: ACCEPT when it is right, and change your plan to
+match; REJECT when it is wrong, with the reason. Open a file before rejecting a claim about the
+repository. Then return your revised plan, complete and standalone.`;
+	return `${planContract(CHECK_DISPUTES)}
+
+${received}
+
+Answer in this format:
+<replies>
+<id>: ACCEPT — <what you changed>
+<id>: REJECT — <why the objection is wrong>
+</replies>
+<revised-plan>
+<your whole revised plan>
+</revised-plan>
+
+${taskBlock(input.task, input.resumed)}${ownPlan}`.trimEnd();
+}
+/**
+* Asks an agent that reads the repository to settle disputed claims about it,
+* one answer per claim. `resumed` leaves out the task.
+*/
+function claimCheckPrompt(input) {
+	return `You are checking disputed claims about this repository, not planning. Work read-only.
+Open the files each claim is about and answer on one line per claim, by its id:
+
+D1: CONFIRM — <file:symbol that shows the claim is true>
+D2: REFUTE — <file:symbol that shows it is false>
+D3: UNKNOWN — <what you looked at>
+
+Answer UNKNOWN whenever the files do not settle it. Return nothing else.
+
+${taskBlock(input.task, input.resumed)}<claims>
+${input.claims.map(({ id, claim, criticLabels, authorLabel, rejections }) => `${id}: ${claim}\n  Raised by ${listLabels(criticLabels)} against ${authorLabel}'s plan.${rejections.length > 0 ? ` ${authorLabel} rejected it: ${rejections.join(" / ")}` : ""}`).join("\n")}
+</claims>`;
+}
+const RULING_TEXT = {
+	critic: (critics) => `${critics}'s objection holds`,
+	author: (_critics, author) => `${author}'s position holds`,
+	unclear: () => "the material does not settle it"
+};
+/** Whether a dispute is settled: the judge ruled for a side, and with at least `SETTLED` confidence. */
+function isSettled(ruling) {
+	return ruling !== void 0 && ruling.choice !== "unclear" && ruling.confidence >= .65;
+}
+/** `D1 (Codex → Claude): <claim>. Judge: Claude's position holds (0.72). Check: REFUTE src/jev.ts.` */
+function disputeLine(dispute, ruling, label) {
+	const critics = listLabels(dispute.critics.map(label));
+	const author = label(dispute.target);
+	const parts = [`${dispute.id} (${critics} → ${author}): ${dispute.claim.replace(/\.$/, "")}.`];
+	parts.push(ruling ? `Judge: ${RULING_TEXT[ruling.choice](critics, author)} (${ruling.confidence.toFixed(2)}).` : "Judge: not judged.");
+	if (dispute.check) {
+		const evidence = dispute.check.evidence ? ` ${dispute.check.evidence.replace(/\.$/, "")}` : "";
+		parts.push(`Check: ${dispute.check.result.toUpperCase()}${evidence}.`);
+	}
+	return parts.join(" ");
+}
+/** Every dispute and the judge's ruling on it, one per line, for the final merge. */
+function disputeSummary(input) {
+	const ruling = (id) => input.rulings.find((candidate) => candidate.id === id);
+	return [...input.disputes, ...input.overflow].map((dispute) => disputeLine(dispute, ruling(dispute.id), input.label)).join("\n");
+}
+const SCORE_NAMES = {
+	completeness: "completeness",
+	feasibility: "feasibility and grounding in the repository",
+	riskCoverage: "coverage of edge cases, tests and rollout risks"
+};
+/**
+* What a second pass after a debate aims at: the disputes the judge's rulings left
+* open, and those past the cap that it never judged. With none open, a note
+* saying so and the weakest of the judge's scores, since the judge asking for another pass
+* can also mean something is missing that nobody disputed.
+*/
+function disputeFeedback(input) {
+	const rulings = input.verdict.disputes ?? [];
+	const ruling = (id) => rulings.find((candidate) => candidate.id === id);
+	const lines = [...input.disputes.filter((dispute) => !isSettled(ruling(dispute.id))).map((dispute) => disputeLine(dispute, ruling(dispute.id), input.label)), ...input.overflow.map((dispute) => disputeLine(dispute, void 0, input.label))];
+	if (lines.length > 0) return lines.join("\n");
+	const name = Object.keys(SCORE_NAMES).reduce((weakest, next) => input.verdict[next] < input.verdict[weakest] ? next : weakest);
+	return `No disagreement is left open, but the judge still expects another pass to improve the plan. Its weakest score is ${SCORE_NAMES[name]}: ${input.verdict[name].toFixed(1)} of 3. Strengthen that.`;
+}
+/** A round never returns fewer plans than this: below it, there is no collaboration left to judge. */
+const MIN_PLANS = 2;
+/** Each draft's plan, keyed by its agent's name: how a round is reported. */
+const byName = (drafts) => Object.fromEntries(drafts.map(({ agent, plan }) => [agent.name, plan]));
+const pendingOf = (calls) => calls.map((call) => ({
+	call,
+	controller: new AbortController()
+}));
+/** Half of the round's calls, and at least one: once they are in, the grace starts. */
+const quorumOf = (pending) => Math.max(1, Math.ceil(pending.length / 2));
+const asError = (error) => error instanceof Error ? error : new Error(String(error));
+/**
+* Every agent's plan for one round, in parallel.
+*
+* With a grace, the round stops waiting `graceMs` after half of the agents
+* have answered and aborts the rest, so one slow agent no longer sets the pace
+* of the round. An aborted agent keeps its plan from the round before, and an
+* agent whose plan the round cannot do without — a draft nobody can stand in
+* for, when dropping it would leave fewer than two plans — is waited for
+* anyway. Rejections are the caller's, as `Promise.all` would raise them,
+* except from a call this round aborted itself.
+*/
+function round(calls, generate, graceMs, onDrop) {
+	if (graceMs <= 0) return Promise.all(calls.map(async ({ agent, prompt, later }) => ({
+		agent,
+		plan: await generate(agent, prompt, later)
+	})));
+	return new Promise((resolve, reject) => {
+		const pending = pendingOf(calls);
+		const quorum = quorumOf(pending);
+		let answered = 0;
+		let timer;
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			if (timer !== void 0) clearTimeout(timer);
+			callback();
+		};
+		const settleIfDone = () => {
+			if (pending.some((entry) => entry.plan === void 0 && entry.dropped === void 0)) return;
+			finish(() => {
+				resolve(pending.flatMap(({ call, plan }) => {
+					const answer = plan ?? call.fallback;
+					return answer === void 0 ? [] : [{
+						agent: call.agent,
+						plan: answer
+					}];
+				}));
+			});
+		};
+		const cutOff = () => {
+			let remaining = pending.length;
+			for (const entry of pending) {
+				if (entry.plan !== void 0 || entry.dropped !== void 0) continue;
+				if (entry.call.fallback === void 0) {
+					if (remaining - 1 < MIN_PLANS) continue;
+					remaining -= 1;
+				}
+				entry.dropped = true;
+				entry.controller.abort();
+				onDrop(entry.call.agent);
+			}
+			settleIfDone();
+		};
+		for (const entry of pending) generate(entry.call.agent, entry.call.prompt, entry.call.later, entry.controller.signal).then((plan) => {
+			if (settled || entry.dropped !== void 0) return;
+			entry.plan = plan;
+			answered += 1;
+			if (timer === void 0 && answered >= quorum) timer = setTimeout(cutOff, graceMs);
+			settleIfDone();
+		}, (error) => {
+			if (entry.dropped !== void 0) return;
+			finish(() => {
+				reject(asError(error));
+			});
+		});
+	});
+}
+/**
+* The draft round of `fast` mode: every agent drafts at once, and each draft
+* is handed to `judgeSolo` as it arrives, one at a time, in arrival order.
+* The first one whose verdict stands alone is accepted: the calls still
+* running are aborted and reported to `onDrop` with it, and the round
+* resolves with every draft that arrived, those still waiting to be judged
+* included. With none accepted, it resolves once every call has answered
+* and every draft has been judged.
+*
+* The grace works as in `round`: once half the agents have answered, the
+* rest get `graceMs`, and the round never cuts below two drafts. It is kept
+* apart from `round` so that `balanced` and `ultra` run exactly the code
+* they always have. An agent or the judge failing before a draft is accepted
+* aborts the calls still running and rejects the round.
+*/
+function firstAccepted(calls, generate, graceMs, onDrop, judgeSolo) {
+	return new Promise((resolve, reject) => {
+		const pending = pendingOf(calls);
+		const quorum = quorumOf(pending);
+		const queue = [];
+		let answered = 0;
+		let judging = false;
+		let timer;
+		let settled = false;
+		const running = () => pending.filter((entry) => entry.plan === void 0 && entry.dropped === void 0);
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			if (timer !== void 0) clearTimeout(timer);
+			callback();
+		};
+		const resolveWith = (accepted) => {
+			finish(() => {
+				resolve({
+					drafts: pending.flatMap(({ call, plan }) => plan === void 0 ? [] : [{
+						agent: call.agent,
+						plan
+					}]),
+					...accepted ? { accepted } : {}
+				});
+			});
+		};
+		const fail = (error) => {
+			for (const entry of running()) {
+				entry.dropped = true;
+				entry.controller.abort();
+			}
+			finish(() => {
+				reject(asError(error));
+			});
+		};
+		const judgeNext = () => {
+			if (settled || judging) return;
+			const draft = queue.shift();
+			if (!draft) {
+				if (running().length === 0) resolveWith();
+				return;
+			}
+			judging = true;
+			judgeSolo(draft).then((verdict) => {
+				judging = false;
+				if (settled) return;
+				if (verdict.standsAloneProbability < .5) {
+					judgeNext();
+					return;
+				}
+				for (const entry of running()) {
+					entry.dropped = true;
+					entry.controller.abort();
+					onDrop(entry.call.agent, draft);
+				}
+				resolveWith({
+					draft,
+					verdict
+				});
+			}, fail);
+		};
+		const cutOff = () => {
+			let remaining = pending.length;
+			for (const entry of running()) {
+				if (remaining - 1 < MIN_PLANS) continue;
+				remaining -= 1;
+				entry.dropped = true;
+				entry.controller.abort();
+				onDrop(entry.call.agent);
+			}
+			judgeNext();
+		};
+		for (const entry of pending) {
+			const { agent, prompt, later } = entry.call;
+			generate(agent, prompt, later, entry.controller.signal).then((plan) => {
+				if (settled || entry.dropped !== void 0) return;
+				entry.plan = plan;
+				answered += 1;
+				if (graceMs > 0 && timer === void 0 && answered >= quorum) timer = setTimeout(cutOff, graceMs);
+				queue.push({
+					agent,
+					plan
+				});
+				judgeNext();
+			}, (error) => {
+				if (entry.dropped !== void 0) return;
+				fail(error);
+			});
+		}
+	});
+}
+/**
+* The debate review: each agent critiques the others, each author answers
+* the objections to its plan and revises it, the rejected objections become
+* disputes, and the judge rules on them along with its usual verdict.
+*/
+async function debateReview(run, drafts) {
+	const { task } = run.options;
+	const peersOf = (own) => drafts.filter((draft) => draft !== own);
+	run.stage(`Collecting critiques of the ${String(drafts.length)} drafts…`);
+	const critiques = await run.runRound(drafts.map((own) => {
+		const input = {
+			task,
+			ownPlan: own.plan,
+			peerPlans: peersOf(own).map(({ agent, plan }) => ({
+				name: agent.name,
+				label: agent.label,
+				plan
+			}))
+		};
+		return {
+			agent: own.agent,
+			fallback: "",
+			prompt: critiquePrompt(input),
+			later: run.later((resumed) => critiquePrompt({
+				...input,
+				resumed
+			}))
+		};
+	}));
+	const objections = critiques.flatMap(({ agent, plan }) => parseCritique(agent.name, plan, drafts.filter((draft) => draft.agent !== agent).map((draft) => draft.agent)).objections);
+	await run.report("critique", byName(drafts), {
+		artifacts: byName(critiques),
+		debate: { objections }
+	});
+	run.stage("Asking each author to answer the objections to its plan…");
+	const received = (own) => objections.filter((objection) => objection.target === own.agent.name).map((objection) => ({
+		...objection,
+		criticLabel: run.label(objection.critic)
+	}));
+	const answers = await run.runRound(drafts.map((own) => {
+		const input = {
+			task,
+			ownPlan: own.plan,
+			objections: received(own)
+		};
+		return {
+			agent: own.agent,
+			fallback: "",
+			prompt: replyPrompt(input),
+			later: run.later((resumed) => replyPrompt({
+				...input,
+				resumed
+			}))
+		};
+	}));
+	const replies = [];
+	const revised = drafts.map((own) => {
+		const answer = answers.find(({ agent }) => agent === own.agent)?.plan ?? "";
+		const ids = received(own).map(({ id }) => id);
+		const parsed = parseReply(own.agent.name, answer, ids, own.plan);
+		replies.push(...parsed.replies);
+		return {
+			agent: own.agent,
+			plan: parsed.plan
+		};
+	});
+	const unanswered = objections.map(({ id }) => id).filter((id) => !replies.some((reply) => reply.id === id));
+	const built = buildDisputes(objections, replies);
+	let { disputes } = built;
+	const { overflow } = built;
+	let claimChecks;
+	const record = () => ({
+		objections,
+		replies,
+		unanswered,
+		disputes,
+		overflow,
+		...claimChecks ? { claimChecks } : {}
+	});
+	let checks;
+	if (run.options.claimChecks) {
+		const checkers = revised.filter(({ agent }) => agent.readsRepository === true).map(({ agent }) => agent.name);
+		const assigned = assignChecks(disputes.filter(({ repo }) => repo), checkers);
+		if (checkers.length < 2) {
+			claimChecks = "skipped";
+			run.stage("Claim checks skipped: needs two agents that read the repository");
+		} else if (assigned.size === 0) {
+			claimChecks = "skipped";
+			run.stage("Claim checks skipped: no disputed claim about the repository");
+		} else {
+			await run.report("reply", byName(revised), {
+				artifacts: byName(answers),
+				debate: record()
+			});
+			run.stage(`Checking ${String([...assigned.values()].flat().length)} disputed claims against the repository…`);
+			const toCheck = [...assigned].map(([checker, claims]) => ({
+				agent: run.agent(checker),
+				claims,
+				input: {
+					task,
+					claims: claims.map((dispute) => ({
+						id: dispute.id,
+						claim: dispute.claim,
+						criticLabels: dispute.critics.map((critic) => run.label(critic)),
+						authorLabel: run.label(dispute.target),
+						rejections: dispute.rejections
+					}))
+				}
+			}));
+			checks = await run.runRound(toCheck.map(({ agent, input }) => ({
+				agent,
+				fallback: "",
+				prompt: claimCheckPrompt(input),
+				later: run.later((resumed) => claimCheckPrompt({
+					...input,
+					resumed
+				}))
+			})));
+			const results = new Map(toCheck.flatMap(({ agent, claims }) => [...parseChecks(agent.name, checks?.find((check) => check.agent === agent)?.plan ?? "", claims.map(({ id }) => id))]));
+			disputes = disputes.map((dispute) => {
+				const check = results.get(dispute.id);
+				return check ? {
+					...dispute,
+					check
+				} : dispute;
+			});
+			claimChecks = "ran";
+		}
+	}
+	run.stage(disputes.length > 0 ? `Re-evaluating the revised plans and ${String(disputes.length)} disagreements with ${run.judgeName}…` : `Re-evaluating the revised plans with ${run.judgeName}…`);
+	const verdict = await run.judge(revised, "review", disputes);
+	await run.report(checks ? "check" : "review", byName(revised), {
+		verdict,
+		artifacts: byName(checks ?? answers),
+		debate: record()
+	});
+	return {
+		drafts: revised,
+		verdict,
+		record: record(),
+		disputes,
+		overflow
+	};
+}
+/** The agent of that name, or an error naming the agents there are. */
+function findAgent(agents, name) {
+	const agent = agents.find((candidate) => candidate.name === name);
+	if (!agent) throw new Error(`"${name}" is not one of this planner's agents: ${agents.map((a) => a.name).join(", ")}`);
+	return agent;
+}
+/**
+* One call of `Planner.plan`: what it has spent, how long each round took,
+* each agent's session, and the calls every phase of the run makes through it.
+*/
+var PlanRun = class {
+	agents;
+	planJudge;
+	options;
+	settings;
+	cost;
+	timings = {
+		totalMs: 0,
+		rounds: []
+	};
+	/** Whether each agent continues one conversation through the run. */
+	resume;
+	stage;
+	runStart = performance.now();
+	roundStart = this.runStart;
+	agentMs = {};
+	judgeMs;
+	rounds = 0;
+	sessions;
+	constructor(agents, planJudge, options, settings) {
+		this.agents = agents;
+		this.planJudge = planJudge;
+		this.options = options;
+		this.settings = settings;
+		this.cost = {
+			mode: settings.mode,
+			reviewMode: settings.reviewMode,
+			reviewRounds: 0,
+			synthesized: false,
+			agentCalls: 0,
+			judgeCalls: 0,
+			dropped: []
+		};
+		this.stage = options.onStage ?? (() => void 0);
+		this.resume = options.resume ?? true;
+		this.sessions = new Map(this.resume ? agents.map((agent) => [agent, {}]) : []);
+	}
+	get judgeName() {
+		return this.planJudge.name;
+	}
+	agent(name) {
+		return findAgent(this.agents, name);
+	}
+	label(name) {
+		return this.agent(name).label;
+	}
+	/** The later-call marker, with the shorter prompt when the agent continues its session. */
+	later(prompt) {
+		return { resumePrompt: this.resume ? prompt(true) : void 0 };
+	}
+	/** Ends the round: records its timings, hands it to `onRound`, and starts the next one's clock. */
+	async report(stageName, plans, extra = {}) {
+		this.rounds += 1;
+		const roundTimings = {
+			totalMs: performance.now() - this.roundStart,
+			agents: this.agentMs,
+			...this.judgeMs === void 0 ? {} : { judgeMs: this.judgeMs }
+		};
+		this.timings.rounds.push({
+			round: this.rounds,
+			stage: stageName,
+			...roundTimings
+		});
+		await this.options.onRound?.({
+			round: this.rounds,
+			stage: stageName,
+			plans,
+			...extra.verdict ? { verdict: extra.verdict } : {},
+			timings: roundTimings,
+			...extra.selected ? { selected: extra.selected } : {},
+			...extra.artifacts ? { artifacts: extra.artifacts } : {},
+			...extra.debate ? { debate: extra.debate } : {}
+		});
+		this.roundStart = performance.now();
+		this.agentMs = {};
+		this.judgeMs = void 0;
+	}
+	/** Stops the run's clock. */
+	finish() {
+		this.timings.totalMs = performance.now() - this.runStart;
+	}
+	generate = (agent, prompt, later, signal) => {
+		this.cost.agentCalls += 1;
+		return this.timed(() => agent.generate(this.request(agent, prompt, later, signal)), (ms) => {
+			if (signal?.aborted !== true) this.agentMs[agent.name] = ms;
+		});
+	};
+	runRound(calls) {
+		return round(calls, this.generate, this.settings.graceMs, (agent) => {
+			this.cost.dropped.push(agent.name);
+			this.stage(`${agent.label} is still working; the round goes on without it…`);
+		});
+	}
+	/** A cross-review: each agent revises its own plan against every other one. */
+	revise(drafts, feedback, targeted) {
+		return this.runRound(drafts.map((own) => {
+			const input = {
+				task: this.options.task,
+				ownPlan: own.plan,
+				peerPlans: drafts.filter((draft) => draft !== own).map((draft) => ({
+					label: draft.agent.label,
+					plan: draft.plan
+				})),
+				...feedback ? { feedback } : {},
+				...targeted ? { targeted } : {}
+			};
+			return {
+				agent: own.agent,
+				fallback: own.plan,
+				prompt: revisionPrompt(input),
+				later: this.later((resumed) => revisionPrompt({
+					...input,
+					resumed
+				}))
+			};
+		}));
+	}
+	judge(drafts, judged, disputes = []) {
+		this.cost.judgeCalls += 1;
+		return this.timed(() => this.planJudge.judge({
+			task: this.options.task,
+			stage: judged,
+			plans: drafts.map(({ agent, plan }) => ({
+				agent: agent.name,
+				label: agent.label,
+				plan
+			})),
+			...disputes.length > 0 ? { disputes } : {},
+			...this.options.judgeModel ? { model: this.options.judgeModel } : {}
+		}), (ms) => {
+			this.judgeMs = (this.judgeMs ?? 0) + ms;
+		});
+	}
+	request(agent, prompt, later, signal) {
+		const session = this.sessions.get(agent);
+		const effort = later ? this.options.reviewEfforts?.[agent.name] : void 0;
+		const { onAgentProgress } = this.options;
+		return {
+			prompt,
+			...session ? {
+				session,
+				...later?.resumePrompt ? { resumePrompt: later.resumePrompt } : {}
+			} : {},
+			...effort === void 0 ? {} : { effort },
+			cwd: this.options.cwd,
+			timeoutMs: this.options.timeoutMs,
+			...onAgentProgress ? { onProgress: (line) => {
+				onAgentProgress(agent.name, line);
+			} } : {},
+			...signal ? { signal } : {}
+		};
+	}
+	async timed(work, record) {
+		const start = performance.now();
+		const result = await work();
+		record(performance.now() - start);
+		return result;
+	}
+};
+/** Above this, the judge is saying the strongest plan is final as it stands: no merge needed. */
+const STANDS_ALONE = .7;
+/** The plan the judge called stronger, or the one it routed the merge to when it called them tied. */
+const strongest = (drafts, verdict) => drafts.find(({ agent }) => agent.name === verdict.strongerPlan) ?? drafts.find(({ agent }) => agent.name === verdict.finalizer);
+/**
+* The end of a run: adopt one plan as it stands when the run allows it, or
+* have the finalizer merge them all into one.
+*/
+async function synthesize(run, { drafts, verdict, accepted, debated, finalizerOverride }) {
+	const { options, cost } = run;
+	const debateRecord = debated ? { debate: debated.record } : {};
+	const reviewed = cost.reviewRounds > 0;
+	const selected = reviewed && options.selectStronger ? drafts.find(({ agent }) => agent.name === verdict.strongerPlan) : void 0;
+	const standsAlone = reviewed && cost.mode === "balanced" && finalizerOverride === void 0 && verdict.standsAloneProbability >= STANDS_ALONE;
+	const adopted = accepted?.draft ?? selected ?? (standsAlone ? strongest(drafts, verdict) : void 0);
+	if (adopted) {
+		run.stage(adopted === selected ? `${run.judgeName} rated ${adopted.agent.label}'s plan stronger; using it without a synthesis…` : `Adopting ${adopted.agent.label}'s plan: ${run.judgeName} judged it final as it stands…`);
+		await run.report("final", { [adopted.agent.name]: adopted.plan }, {
+			verdict,
+			selected: true
+		});
+		run.finish();
+		return {
+			plan: adopted.plan,
+			verdict,
+			finalizer: adopted.agent.name,
+			selected: true,
+			drafts: byName(drafts),
+			...debateRecord,
+			timings: run.timings,
+			cost
+		};
+	}
+	const finalizer = finalizerOverride ?? run.agent(verdict.finalizer);
+	run.stage(`Synthesizing the final plan with ${finalizer.label}…`);
+	const summary = debated && debated.disputes.length + debated.overflow.length > 0 ? disputeSummary({
+		disputes: debated.disputes,
+		overflow: debated.overflow,
+		rulings: debated.verdict.disputes ?? [],
+		label: (name) => run.label(name)
+	}) : void 0;
+	const finalInput = {
+		task: options.task,
+		plans: drafts.map(({ agent, plan }) => ({
+			label: agent.label,
+			plan
+		})),
+		verdict: JSON.stringify(verdict, null, 2),
+		...summary === void 0 ? {} : { disputes: summary }
+	};
+	const finalPlan = await run.generate(finalizer, finalPlanPrompt(finalInput), run.later((resumed) => finalPlanPrompt({
+		...finalInput,
+		resumed
+	})));
+	cost.synthesized = true;
+	await run.report("final", { [finalizer.name]: finalPlan }, { verdict });
+	run.finish();
+	return {
+		plan: finalPlan,
+		verdict,
+		finalizer: finalizer.name,
+		drafts: byName(drafts),
+		...debateRecord,
+		timings: run.timings,
+		cost
+	};
+}
+/** Above this, the judge is asking for a cross-review pass rather than merely allowing one. */
+const NEEDS_ANOTHER_PASS = .65;
+/** What a `balanced` round waits for a straggler once enough agents have answered. */
+const DEFAULT_STRAGGLER_GRACE_MS = 9e4;
+const labelsOf = (agents) => agents.map(({ label }) => label);
+var Planner = class {
+	judge;
+	agents;
+	/** Two or more agents with distinct names; each drafts, revises, and may finalize. */
+	constructor(agents, judge) {
+		this.judge = judge;
+		if (agents.length < 2) throw new Error("A planner needs at least two agents");
+		const names = agents.map(({ name }) => name);
+		const duplicate = names.find((name, index) => names.indexOf(name) !== index);
+		if (duplicate !== void 0) throw new Error(`Agent "${duplicate}" is listed more than once`);
+		this.agents = [...agents];
+	}
+	async plan(options) {
+		if (!options.allowAnyTask) validateTask(options.task);
+		const finalizerOverride = options.finalizer === void 0 ? void 0 : findAgent(this.agents, options.finalizer);
+		const mode = options.mode ?? "balanced";
+		const maxReviewRounds = options.maxReviewRounds ?? 2;
+		const reviewMode = options.reviewMode ?? (options.claimChecks ? "debate" : "standard");
+		if (options.claimChecks && reviewMode !== "debate") throw new Error("Claim checks run in the debate review: set reviewMode to 'debate'");
+		if (mode === "fast" && reviewMode === "debate") throw new Error("The debate review is a review round, and fast mode has none");
+		if (reviewMode === "debate" && maxReviewRounds < 1) throw new Error("The debate review is a review round: maxReviewRounds must be at least 1");
+		const graceMs = mode === "ultra" ? 0 : options.stragglerGraceMs ?? 9e4;
+		const run = new PlanRun(this.agents, this.judge, options, {
+			mode,
+			reviewMode,
+			graceMs
+		});
+		const { cost, stage } = run;
+		const judgeName = this.judge.name;
+		const crossReview = (count) => `Cross-reviewing the ${String(count)} drafts…`;
+		let debated;
+		const draftCalls = this.agents.map((agent) => ({
+			agent,
+			prompt: initialPlanPrompt(options.task, labelsOf(this.agents.filter((peer) => peer !== agent))),
+			later: void 0
+		}));
+		stage(`Drafting independent plans with ${listLabels(labelsOf(this.agents))}…`);
+		let drafts;
+		let verdict;
+		let accepted;
+		if (mode === "fast") {
+			({drafts, accepted} = await firstAccepted(draftCalls, run.generate, graceMs, (agent, winner) => {
+				cost.dropped.push(agent.name);
+				stage(winner ? `${judgeName} accepted ${winner.agent.label}'s draft; stopping ${agent.label}…` : `${agent.label} is still working; the round goes on without it…`);
+			}, async (draft) => {
+				stage(`${judgeName} is judging ${draft.agent.label}'s draft alone…`);
+				const solo = await run.judge([draft], "solo");
+				if (solo.standsAloneProbability < .5) stage(`${judgeName} judged ${draft.agent.label}'s draft not final on its own (${solo.standsAloneProbability.toFixed(2)})…`);
+				return solo;
+			}));
+			if (accepted) verdict = accepted.verdict;
+			else {
+				stage(`Asking ${judgeName} for typed quality and routing decisions…`);
+				verdict = await run.judge(drafts, "draft");
+			}
+			await run.report("draft", byName(drafts), { verdict });
+		} else {
+			drafts = await run.runRound(draftCalls);
+			if (mode === "ultra" && maxReviewRounds > 0) {
+				await run.report("draft", byName(drafts));
+				if (reviewMode === "debate") {
+					debated = await debateReview(run, drafts);
+					({drafts, verdict} = debated);
+				} else {
+					stage(crossReview(drafts.length));
+					drafts = await run.revise(drafts);
+					stage(`Asking ${judgeName} for typed quality and routing decisions…`);
+					verdict = await run.judge(drafts, "review");
+					await run.report("review", byName(drafts), { verdict });
+				}
+				cost.reviewRounds = 1;
+			} else {
+				stage(`Asking ${judgeName} for typed quality and routing decisions…`);
+				verdict = await run.judge(drafts, "draft");
+				await run.report("draft", byName(drafts), { verdict });
+			}
+		}
+		while (mode !== "fast" && cost.reviewRounds < maxReviewRounds && verdict.needsAnotherPassProbability >= NEEDS_ANOTHER_PASS) {
+			if (reviewMode === "debate" && debated === void 0) {
+				debated = await debateReview(run, drafts);
+				({drafts, verdict} = debated);
+				cost.reviewRounds += 1;
+				continue;
+			}
+			if (debated) {
+				const rulings = debated.verdict.disputes;
+				stage(`${judgeName} requested another pass on the open disagreements…`);
+				drafts = await run.revise(drafts, disputeFeedback({
+					disputes: debated.disputes,
+					overflow: debated.overflow,
+					verdict: rulings ? {
+						...verdict,
+						disputes: rulings
+					} : verdict,
+					label: (name) => run.label(name)
+				}), true);
+			} else {
+				stage(cost.reviewRounds === 0 ? crossReview(drafts.length) : `${judgeName} requested another cross-review pass…`);
+				drafts = await run.revise(drafts, JSON.stringify(verdict, null, 2));
+			}
+			cost.reviewRounds += 1;
+			stage(`Re-evaluating the revised plans with ${judgeName}…`);
+			verdict = await run.judge(drafts, "review");
+			await run.report("review", byName(drafts), { verdict });
+		}
+		return synthesize(run, {
+			drafts,
+			verdict,
+			...accepted ? { accepted } : {},
+			...debated ? { debated } : {},
+			...finalizerOverride ? { finalizerOverride } : {}
+		});
+	}
+};
+async function readPipedStdin() {
+	if (process.stdin.isTTY) return void 0;
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks).toString("utf8").trim();
+}
+/**
+* `main`'s dependencies in a real process: its stdio, environment and working
+* directory, the real agents, and a judge from `judge` for each run. What a
+* program's `bin` hands `main`.
+*
+* Every provider's credentials, and the judge's, are kept from every agent
+* subprocess: an agent only ever sees the login it uses itself.
+*/
+function processDeps(program, judge) {
+	const omitEnv = secretEnv(program);
+	return {
+		stdout: (text) => process.stdout.write(text),
+		stderr: (text) => process.stderr.write(text),
+		env: process.env,
+		cwd: () => process.cwd(),
+		readStdin: readPipedStdin,
+		createPlanner: (setup) => new Planner(createAgents(setup, process.env, omitEnv), judge()),
+		doctor: runDoctor,
+		now: () => /* @__PURE__ */ new Date(),
+		program
+	};
+}
+const MAX_PLAN_CHARS = 4e4;
+/** A plan cut to what a judge is shown. */
+function bounded(text) {
+	if (text.length <= MAX_PLAN_CHARS) return text;
+	return `${text.slice(0, MAX_PLAN_CHARS)}\n[truncated for evaluation]`;
+}
+/** What a judge is told the plans are. */
+const STAGE_TEXT = {
+	solo: "One agent's independent draft, judged alone: no other agent has seen it",
+	draft: "Independent drafts: no agent has seen another agent’s plan yet",
+	review: "Cross-reviewed plans: each agent has read every other plan and revised its own"
+};
+const disputeKey = (index) => `dispute_${String(index + 1)}`;
+function agentOptions(plans, describe) {
+	return Object.fromEntries(plans.map(({ agent, label }) => [agent, describe(label)]));
+}
+function labelOf(plans, agent) {
+	return plans.find((plan) => plan.agent === agent)?.label ?? agent;
+}
+function disputeQuestion(plans, dispute) {
+	const critics = dispute.critics.map((critic) => labelOf(plans, critic)).join(" and ");
+	const author = labelOf(plans, dispute.target);
+	return {
+		kind: "choice",
+		ask: `${critics} objected to ${author}'s plan, and ${author} rejected the objection. Judging from the plans, which side is right?`,
+		details: {
+			claim: dispute.claim,
+			why: dispute.reasons,
+			rejection: dispute.rejections,
+			check: dispute.check ? `${dispute.check.result.toUpperCase()}${dispute.check.evidence ? `: ${dispute.check.evidence}` : ""}` : "not checked"
+		},
+		options: {
+			critic: `${critics}'s objection holds`,
+			author: `${author}'s position holds`,
+			unclear: "The material does not settle it"
+		},
+		fallback: "unclear"
+	};
+}
+/** Whether the plan could be the final plan: the strongest plan, or a lone draft. */
+function standsAlone(stage) {
+	return stage === "solo" ? {
+		kind: "binary",
+		ask: "Could this plan, as it stands, be handed to an implementer as the final plan, with no review or merge?",
+		yes: "The plan is complete and self-contained; ready to implement",
+		no: "The plan has gaps that review or another plan would need to fill",
+		fallback: 0
+	} : {
+		kind: "binary",
+		ask: "Could the strongest plan be handed to an implementer as the final plan, with no merge of the others?",
+		yes: "One plan is already complete and self-contained; merging would add nothing material",
+		no: "The plans hold complementary material that a final merge has to combine",
+		fallback: 0
+	};
+}
+/** A rubric of four levels; a judge that cannot answer claims the lowest. */
+function rubric(ask, levels) {
+	return {
+		kind: "score",
+		ask,
+		levels,
+		fallback: 0
+	};
+}
+/**
+* Every question of one judgement, in the order a verdict reads them. The
+* `finalizer` falls back to the first plan's agent, so it is always an agent.
+*/
+function planQuestions(input) {
+	const { plans, stage } = input;
+	const disputes = {};
+	input.disputes?.forEach((dispute, index) => {
+		disputes[disputeKey(index)] = disputeQuestion(plans, dispute);
+	});
+	return {
+		stronger_plan: {
+			kind: "choice",
+			ask: "Which plan is most likely to lead to a correct, efficient implementation of the task?",
+			options: {
+				...agentOptions(plans, (label) => `${label}'s plan is materially stronger overall`),
+				tie: "No plan is materially stronger, or their strengths are complementary"
+			},
+			fallback: "tie"
+		},
+		finalizer: {
+			kind: "choice",
+			ask: "Which agent's plan demonstrates the best judgment for merging all the plans into the final plan?",
+			options: agentOptions(plans, (label) => `${label} should perform the final synthesis`),
+			fallback: plans[0]?.agent ?? "tie"
+		},
+		completeness: rubric("How complete is the combined planning material for the requested task?", [
+			"Major requirements or repository impacts are missing",
+			"Several important details are missing",
+			"Mostly complete, with minor gaps",
+			"Complete and implementation-ready"
+		]),
+		feasibility: rubric("How feasible and repository-grounded are the proposed implementation steps?", [
+			"Mostly speculative or incompatible with the repository",
+			"Partly grounded but contains risky assumptions",
+			"Mostly grounded and feasible",
+			"Highly concrete, minimal, and feasible"
+		]),
+		risk_coverage: rubric("How well do the plans cover edge cases, tests, and rollout risks?", [
+			"Risks are largely absent",
+			"Only obvious risks are covered",
+			"Important risks and tests are covered",
+			"Risk, testing, and rollout coverage is thorough"
+		]),
+		needs_another_pass: {
+			kind: "binary",
+			ask: "Would a cross-review round, each agent revising its plan against all the others, materially improve the final implementation plan?",
+			yes: "Important contradictions, omissions, or unsupported assumptions remain",
+			no: "The material is ready for final synthesis",
+			fallback: 0
+		},
+		stands_alone: standsAlone(stage),
+		...disputes
+	};
+}
+/** The plans as a judge sees them: keyed by agent name, the names the choices answer with. */
+function judgedPlans(plans) {
+	return Object.fromEntries(plans.map(({ agent, label, plan }) => [agent, {
+		author: label,
+		plan: bounded(plan)
+	}]));
+}
+//#endregion
+//#region src/jev/jev.ts
+/** A neutral question as the SDK asks it. */
+function toTypeSafe(question) {
+	if (question.kind === "choice") {
+		const instructions = question.details ? {
+			question: question.ask,
+			...question.details
+		} : question.ask;
+		return (0, _typesafe_ai_sdk.choice)(instructions, question.options);
+	}
+	if (question.kind === "score") return (0, _typesafe_ai_sdk.score)(question.ask, question.levels);
+	return (0, _typesafe_ai_sdk.noul)(question.ask, {
+		true: question.yes,
+		false: question.no
+	});
+}
+/** TypeSafe Jev, asked the planner's questions in one `systemOne` call per judged round. */
+var TypeSafeJevJudge = class {
+	client;
+	name = "Jev";
+	constructor(client = new _typesafe_ai_sdk.TypeSafeClient()) {
+		this.client = client;
+	}
+	async judge(input) {
+		const disputes = input.disputes ?? [];
+		const questions = planQuestions({
+			plans: input.plans,
+			stage: input.stage,
+			disputes
+		});
+		const response = await this.client.systemOne({
+			...input.model ? { model: input.model } : {},
+			state: {
+				task: input.task,
+				stage: STAGE_TEXT[input.stage],
+				plans: judgedPlans(input.plans)
+			},
+			questions: Object.fromEntries(Object.entries(questions).map(([key, question]) => [key, toTypeSafe(question)]))
+		});
+		const answers = response.answers;
+		return {
+			strongerPlan: answers.stronger_plan.choice,
+			strongerPlanConfidence: answers.stronger_plan.confidence,
+			finalizer: answers.finalizer.choice,
+			finalizerConfidence: answers.finalizer.confidence,
+			completeness: answers.completeness.score,
+			completenessConfidence: answers.completeness.confidence,
+			feasibility: answers.feasibility.score,
+			feasibilityConfidence: answers.feasibility.confidence,
+			riskCoverage: answers.risk_coverage.score,
+			riskCoverageConfidence: answers.risk_coverage.confidence,
+			needsAnotherPassProbability: answers.needs_another_pass.noul,
+			standsAloneProbability: answers.stands_alone.noul,
+			...disputes.length > 0 ? { disputes: disputes.map((dispute, index) => {
+				const answer = answers[disputeKey(index)];
+				return answer ? {
+					id: dispute.id,
+					choice: answer.choice,
+					confidence: answer.confidence
+				} : {
+					id: dispute.id,
+					choice: "unclear",
+					confidence: 0
+				};
+			}) } : {},
+			model: response.model
+		};
+	}
+};
+//#endregion
+Object.defineProperty(exports, "DEFAULT_AGENTS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_AGENTS;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_STRAGGLER_GRACE_MS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_STRAGGLER_GRACE_MS;
+	}
+});
+Object.defineProperty(exports, "PROVIDERS", {
+	enumerable: true,
+	get: function() {
+		return PROVIDERS;
+	}
+});
+Object.defineProperty(exports, "Planner", {
+	enumerable: true,
+	get: function() {
+		return Planner;
+	}
+});
+Object.defineProperty(exports, "ProcessError", {
+	enumerable: true,
+	get: function() {
+		return ProcessError;
+	}
+});
+Object.defineProperty(exports, "TaskValidationError", {
+	enumerable: true,
+	get: function() {
+		return TaskValidationError;
+	}
+});
+Object.defineProperty(exports, "TypeSafeJevJudge", {
+	enumerable: true,
+	get: function() {
+		return TypeSafeJevJudge;
+	}
+});
+Object.defineProperty(exports, "cliProvider", {
+	enumerable: true,
+	get: function() {
+		return cliProvider;
+	}
+});
+Object.defineProperty(exports, "main", {
+	enumerable: true,
+	get: function() {
+		return main;
+	}
+});
+Object.defineProperty(exports, "openAICompatibleProvider", {
+	enumerable: true,
+	get: function() {
+		return openAICompatibleProvider;
+	}
+});
+Object.defineProperty(exports, "processDeps", {
+	enumerable: true,
+	get: function() {
+		return processDeps;
+	}
+});
+Object.defineProperty(exports, "runDoctor", {
+	enumerable: true,
+	get: function() {
+		return runDoctor;
+	}
+});