@robmclarty/volley 0.11.0 → 0.12.0

package/dist/index.js

@@ -1,9 +1,10 @@
-import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { accessSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { createHmac, randomBytes, randomUUID } from "node:crypto";
+import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import { aborted_error, branch, claude_cli_reported, create_engine, fallback, loop, model_call, pipe, retry, run, sequence, step, throughput } from "fascicle";
+import { z } from "zod";
 import { homedir } from "node:os";
 import { filesystem_logger, tee_logger } from "fascicle/adapters";
 import { lookup } from "node:dns";
@@ -12,7 +13,6 @@ import ipaddr from "ipaddr.js";
 import { parseHTML } from "linkedom";
 import TurndownService from "turndown";
 import { Agent, buildConnector, interceptors, request } from "undici";
-import { z } from "zod";
 import pc from "picocolors";
 //#region src/types.ts
 function config_error(message) {
@@ -530,6 +530,68 @@ function collect_changes(options) {
 		truncated: sorted.length > limit
 	};
 }
+/** A file's content hash under `root`, or null when it can't be read (gone,
+* or a directory). */
+function hash_file(root, path) {
+	try {
+		return createHash("sha256").update(readFileSync(join(root, path))).digest("hex");
+	} catch {
+		return null;
+	}
+}
+/** Every changed path in `root` since the baseline, by its content hash: what
+* the build root holds before the tester writes, so what it writes can be told
+* from a workspace that was dirty to begin with. Empty outside a git
+* repository, where nothing is measured. */
+function snapshot_changes(options) {
+	const changes = collect_changes({
+		...options,
+		limit: Number.POSITIVE_INFINITY
+	});
+	return new Map((changes?.files ?? []).map((file) => [file.path, hash_file(options.root, file.path)]));
+}
+/** What the tester wrote: the changes since the baseline whose content isn't
+* what the snapshot taken before it held, as a change set of their own, and
+* each written file's hash, which a later build is measured against (move 1's
+* D9, D22). Null and none outside a git repository. */
+function tester_written(options, before) {
+	const after = collect_changes({
+		...options,
+		limit: Number.POSITIVE_INFINITY
+	});
+	if (after === null) return {
+		changes: null,
+		hashes: {}
+	};
+	const hashes = {};
+	const files = after.files.filter((file) => {
+		const hash = hash_file(options.root, file.path);
+		if (before.has(file.path) && before.get(file.path) === hash) return false;
+		if (hash !== null) hashes[file.path] = hash;
+		return true;
+	});
+	return {
+		changes: {
+			baseline: after.baseline,
+			gate_edits: files.filter((file) => file.gate).map((file) => file.path),
+			total: files.length,
+			files,
+			truncated: false
+		},
+		hashes
+	};
+}
+/** `changes` with the tester's files taken out of its gate edits, unless the
+* build changed one from the hash it had after the tester: the tester editing
+* the gate is the point, and a builder that left its test alone didn't (D9).
+* A file the build deleted no longer hashes as it did, so it stays an edit. */
+function without_tester_edits(changes, root, hashes) {
+	if (changes === null || Object.keys(hashes).length === 0) return changes;
+	return {
+		...changes,
+		gate_edits: changes.gate_edits.filter((path) => hashes[path] === void 0 || hash_file(root, path) !== hashes[path])
+	};
+}
 //#endregion
 //#region src/check/detect.ts
 /**
@@ -575,6 +637,339 @@ function detect_containment(env) {
 	return value === "1" || value === "true";
 }
 //#endregion
+//#region src/workspace_tools.ts
+/**
+* Shared workspace tools: `contain()` path confinement, the read-only tool set
+* (`read_file`, `search_files`, `list_files`), and the two file writers
+* (`write_file`, `edit_file`).
+*
+* The claude_cli builder/critic get file access from the CLI's own built-in
+* tools. API-style providers (ollama, lmstudio, …) have no built-ins, so
+* volley supplies its own. The critic uses the read-only set as-is via
+* `src/critic/tools.ts`; the builder set in `src/builder/tools.ts` adds the
+* writers and its exec surface; the tester's (`src/tester/tools.ts`) adds the
+* writers held to the test and fixture paths, which is why they live here
+* rather than in the builder's module. Every path is resolved and confined to
+* the workspace root.
+*/
+const READ_FILE_MAX_BYTES = 2e5;
+const WRITE_FILE_MAX_BYTES = 1e6;
+const LIST_MAX_ENTRIES = 2e3;
+/** Directories never worth handing a seat; they bury signal and blow the
+* traversal budget. The acp seats' `list_files` and `search` skip the same
+* names (`./acp_tools.ts`), so a seat sees one tree under acp and on the CLI. */
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".volley",
+	".check",
+	"dist",
+	".cache"
+]);
+/** Resolve `rel` inside `workspace`, rejecting absolute paths and any `..`
+* escape. Returns the absolute path; throws on containment violation. The
+* `workspace` root passed here is the build root, which is the per-run git
+* worktree under `--worktree` (`build_root`), not necessarily the
+* workspace the run was started on. */
+function contain(workspace, rel) {
+	const root = resolve(workspace);
+	const candidate = isAbsolute(rel) ? resolve(rel) : resolve(root, rel);
+	if (!(candidate === root || candidate.startsWith(`${root}${sep}`))) throw new Error(`path escapes the workspace: ${rel}`);
+	return candidate;
+}
+function walk(root, start, limit) {
+	const out = [];
+	const stack = [start];
+	while (stack.length > 0 && out.length < limit) {
+		const dir = stack.pop();
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const name of entries) {
+			const abs = join(dir, name);
+			let is_dir;
+			try {
+				is_dir = statSync(abs).isDirectory();
+			} catch {
+				continue;
+			}
+			if (is_dir) {
+				if (!IGNORED_DIRS.has(name)) stack.push(abs);
+				continue;
+			}
+			out.push({
+				rel: relative(root, abs),
+				abs
+			});
+			if (out.length >= limit) break;
+		}
+	}
+	return out;
+}
+/** The files a read tool's optional `path` covers: the whole tree, the tree
+* under a directory, or the one file it names. A path that doesn't exist
+* throws, so the seat reads why rather than an empty result that looks like
+* "nothing matched". */
+function scoped_files(workspace, path, limit) {
+	const root = resolve(workspace);
+	if (path === void 0) return walk(root, root, limit);
+	const start = contain(workspace, path);
+	let is_dir;
+	try {
+		is_dir = statSync(start).isDirectory();
+	} catch (err) {
+		throw new Error(`no such file or directory: ${path}`, { cause: err });
+	}
+	return is_dir ? walk(root, start, limit) : [{
+		rel: relative(root, start),
+		abs: start
+	}];
+}
+function build_regex(pattern, flags) {
+	try {
+		return new RegExp(pattern, flags);
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`invalid regular expression: ${detail}`);
+	}
+}
+const read_file_input = z.object({ path: z.string().describe("Workspace-relative path to the file to read.") });
+const search_files_input = z.object({
+	pattern: z.string().describe("JavaScript regular expression to match against each line."),
+	path: z.string().optional().describe("Optional workspace-relative directory or file to limit the search to."),
+	ignore_case: z.boolean().optional().describe("Case-insensitive match. Default false.")
+});
+const list_files_input = z.object({
+	path: z.string().optional().describe("Optional workspace-relative directory or file. Default: the workspace root."),
+	contains: z.string().optional().describe("Optional substring filter applied to each relative path.")
+});
+function read_only_tools(workspace) {
+	return [
+		{
+			name: "read_file",
+			read_only: true,
+			description: `Read a UTF-8 text file from the workspace. Returns the file content (truncated at ${String(READ_FILE_MAX_BYTES)} bytes).`,
+			input_schema: read_file_input,
+			execute: (raw) => {
+				const abs = contain(workspace, read_file_input.parse(raw).path);
+				const content = readFileSync(abs, "utf8");
+				return content.length > 2e5 ? `${content.slice(0, READ_FILE_MAX_BYTES)}\n… [truncated at ${String(READ_FILE_MAX_BYTES)} bytes]` : content;
+			}
+		},
+		{
+			name: "search_files",
+			read_only: true,
+			description: `Search workspace files for lines matching a regular expression. Returns up to ${String(200)} "relative/path:line: text" hits.`,
+			input_schema: search_files_input,
+			execute: (raw) => {
+				const input = search_files_input.parse(raw);
+				const regex = build_regex(input.pattern, input.ignore_case === true ? "i" : "");
+				const files = scoped_files(workspace, input.path, LIST_MAX_ENTRIES);
+				const hits = [];
+				for (const file of files) {
+					if (hits.length >= 200) break;
+					let content;
+					try {
+						content = readFileSync(file.abs, "utf8");
+					} catch {
+						continue;
+					}
+					const lines = content.split("\n");
+					for (let i = 0; i < lines.length; i += 1) {
+						if (hits.length >= 200) break;
+						const line = lines[i];
+						if (regex.test(line)) hits.push(`${file.rel}:${String(i + 1)}: ${line.trim()}`);
+					}
+				}
+				if (hits.length === 0) return "no matches";
+				const capped = hits.length >= 200 ? `\n… [capped at ${String(200)} matches]` : "";
+				return `${hits.join("\n")}${capped}`;
+			}
+		},
+		{
+			name: "list_files",
+			read_only: true,
+			description: "List files under a workspace directory (recursively; skips node_modules, .git, and other build/output directories).",
+			input_schema: list_files_input,
+			execute: (raw) => {
+				const input = list_files_input.parse(raw);
+				let files = scoped_files(workspace, input.path, LIST_MAX_ENTRIES).map((f) => f.rel);
+				if (input.contains !== void 0) {
+					const needle = input.contains;
+					files = files.filter((f) => f.includes(needle));
+				}
+				if (files.length === 0) return "no files";
+				const capped = files.length >= LIST_MAX_ENTRIES ? `\n… [capped at ${String(LIST_MAX_ENTRIES)} entries]` : "";
+				return `${files.join("\n")}${capped}`;
+			}
+		}
+	];
+}
+const write_file_input = z.object({
+	path: z.string().describe("Workspace-relative path to write. Parent directories are created."),
+	content: z.string().describe("Full UTF-8 content of the file. Overwrites any existing content.")
+});
+const edit_file_input = z.object({
+	path: z.string().describe("Workspace-relative path of the file to edit."),
+	old_str: z.string().min(1).describe("Exact text to replace. Must occur exactly once in the file."),
+	new_str: z.string().describe("Replacement text.")
+});
+function count_occurrences(haystack, needle) {
+	return haystack.split(needle).length - 1;
+}
+/** `write_file` and `edit_file`, confined to the workspace, and to whatever
+* `guard` allows besides. A wrong-but-recoverable edit (0 or N matches) is
+* returned for the model to read; a refused path or an over-cap write throws,
+* as a containment violation does. */
+function write_tools(workspace, guard) {
+	const target = (path) => {
+		const abs = contain(workspace, path);
+		guard?.(abs, path);
+		return abs;
+	};
+	return [{
+		name: "write_file",
+		description: `Write a UTF-8 text file in the workspace, creating parent directories and overwriting any existing content. Rejects content over ${String(WRITE_FILE_MAX_BYTES)} bytes.`,
+		input_schema: write_file_input,
+		execute: (raw) => {
+			const input = write_file_input.parse(raw);
+			const abs = target(input.path);
+			const bytes = Buffer.byteLength(input.content, "utf8");
+			if (bytes > 1e6) throw new Error(`content is ${String(bytes)} bytes, over the ${String(WRITE_FILE_MAX_BYTES)}-byte write cap`);
+			mkdirSync(dirname(abs), { recursive: true });
+			writeFileSync(abs, input.content, "utf8");
+			return `wrote ${String(bytes)} bytes to ${input.path}`;
+		}
+	}, {
+		name: "edit_file",
+		description: "Replace one exact occurrence of old_str with new_str in a workspace file. old_str must match the file content exactly once — on 0 or multiple matches nothing is changed and an error is returned; read the file and retry with a longer, unique old_str.",
+		input_schema: edit_file_input,
+		execute: (raw) => {
+			const input = edit_file_input.parse(raw);
+			const abs = target(input.path);
+			const content = readFileSync(abs, "utf8");
+			const matches = count_occurrences(content, input.old_str);
+			if (matches === 0) return `error: old_str not found in ${input.path} (0 matches). No change made. Read the file and retry with an exact excerpt of its current content.`;
+			if (matches > 1) return `error: old_str matches ${String(matches)} times in ${input.path}. No change made. Include more surrounding context to make old_str unique.`;
+			writeFileSync(abs, content.replace(input.old_str, input.new_str), "utf8");
+			return `edit applied to ${input.path}`;
+		}
+	}];
+}
+/** A `paths + sizes` listing of the workspace tree, no file contents — the
+* grounding a tool-less critic gets when its provider's tool parser died and the
+* degradation ladder traded read access for survival. Reuses the same
+* `walk` + `IGNORED_DIRS` traversal as the read tools, so the inventory matches
+* what a working `list_files` would have surfaced; caps at `limit` entries. */
+function workspace_inventory(root, limit = LIST_MAX_ENTRIES) {
+	const base = resolve(root);
+	const files = walk(base, base, limit);
+	if (files.length === 0) return "no files";
+	const lines = files.map((file) => {
+		let size;
+		try {
+			size = statSync(file.abs).size;
+		} catch {
+			size = 0;
+		}
+		return `${file.rel} (${String(size)} bytes)`;
+	});
+	const capped = files.length >= limit ? `\n… [capped at ${String(limit)} entries]` : "";
+	return `${lines.join("\n")}${capped}`;
+}
+//#endregion
+//#region src/tester/tools.ts
+/**
+* The tester's tools on any provider but `claude_cli`: the shared reads, and
+* `write_file` and `edit_file` held to the test and fixture gate paths.
+*
+* The tester writes a failing test from the criteria before the first build,
+* and its whole job is the test (move 1's D5). So a write must match a gate
+* pattern, and must not touch the gate's other half: `package.json`, a
+* `*.config.*` file, or anything under `.github/`. A tester that could rewrite
+* the check's configuration could make its own result red or green (D20). It
+* has no `bash` either, though the check runs what it writes, which is why a
+* tester on a local model is contained as a builder is (D14).
+*
+* A path that reaches through a symbolic link is refused too: `contain()` is
+* lexical, so `test/` linked to `src/` would otherwise let a write the
+* patterns allow land in the source.
+*/
+/** Why the tester may not write `rel` (a `/`-separated workspace path) though
+* a gate pattern matches it, or null when it may. */
+function excluded_reason(rel) {
+	const segments = rel.split("/");
+	const name = segments.at(-1) ?? "";
+	if (name === "package.json") return "package.json decides which scripts and tests run";
+	if (name.includes(".config.")) return "a *.config.* file configures the check";
+	if (segments.includes(".github")) return "a path under .github/ is CI configuration";
+	return null;
+}
+/** Whether a gate pattern can only ever name files the tester may not write:
+* `**\/package.json`, `**\/vitest.config.*`, `.github/workflows/**`. */
+function names_only_excluded(pattern) {
+	return excluded_reason(pattern.replace(/\*+$/, "x")) !== null;
+}
+/** The gate patterns the tester may write under: the gate's tests and
+* fixtures, its check configuration and manifest left out. Its prompt names
+* these, and a `claude_cli` tester's `Edit` rules are made from them. */
+function writable_gate_patterns(gate_paths) {
+	return gate_paths.filter((pattern) => !names_only_excluded(pattern));
+}
+/** Whether `path` exists as itself, a dangling link included. */
+function lexists(path) {
+	try {
+		lstatSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Whether `abs` (inside `root`) resolves somewhere other than where it reads:
+* its nearest existing ancestor's real path isn't that ancestor's place under
+* the root's real path, or can't be read (a dangling link). */
+function resolves_elsewhere(root, abs) {
+	let probe = abs;
+	while (!lexists(probe) && probe !== root) probe = dirname(probe);
+	try {
+		return realpathSync(probe) !== join(realpathSync(root), relative(root, probe));
+	} catch {
+		return true;
+	}
+}
+/** Why the tester may not write `abs` (named `path` by the model) in
+* `workspace`, or null when it may. */
+function tester_write_refusal(workspace, gate_paths, abs) {
+	const root = resolve(workspace);
+	const rel = relative(root, abs).split(sep).join("/");
+	if (rel === "" || !matches_any(rel, [...gate_paths])) {
+		const writable = writable_gate_patterns(gate_paths);
+		return writable.length === 0 ? "no gate pattern names a test or fixture path" : `it matches none of the test and fixture gate patterns (${writable.join(", ")})`;
+	}
+	const excluded = excluded_reason(rel);
+	if (excluded !== null) return excluded;
+	if (resolves_elsewhere(root, abs)) return "it reaches through a symbolic link";
+	return null;
+}
+/** The error a tester's write to `path` (named `path`, contained at `abs`)
+* is refused with, or null when it may write there. */
+function refusal_message(workspace, gate_paths, abs, path) {
+	const refusal = tester_write_refusal(workspace, gate_paths, abs);
+	return refusal === null ? null : `the tester can't write ${path}: ${refusal}. It writes tests and fixtures only.`;
+}
+/** The tester's tool set: the read trio, then `write_file` and `edit_file`
+* confined to the test and fixture gate paths. A refused write throws, naming
+* the path and why; fascicle feeds that back to the model. */
+function tester_tools(workspace, gate_paths) {
+	return [...read_only_tools(workspace), ...write_tools(workspace, (abs, path) => {
+		const refusal = refusal_message(workspace, gate_paths, abs, path);
+		if (refusal !== null) throw new Error(refusal);
+	})];
+}
+//#endregion
 //#region src/trust.ts
 /**
 * Which run configs a host-side resume may trust. A resume runs what a run's
@@ -737,9 +1132,13 @@ function write_resolved_config(config, env = process.env) {
 		builder_max_tool_calls: config.builder_max_tool_calls,
 		builder_max_output_tokens: config.builder_max_output_tokens,
 		builder_trim_history: config.builder_trim_history,
+		effort_ladder: config.effort_ladder,
 		critic_model: config.critic_model,
 		critic_provider: config.critic_provider,
 		critic_url: config.critic_url,
+		critic_effort: config.critic_effort,
+		tester: config.tester,
+		tester_model: config.tester_model,
 		builder_permission_mode: config.builder_permission_mode,
 		critic_preset: config.critic_preset,
 		critic_prompt_path: config.critic_prompt_path,
@@ -905,6 +1304,25 @@ const CRITIC_PRESETS = [
 	"researcher"
 ];
 const PERMISSION_MODES = ["acceptEdits", "bypassPermissions"];
+/** The efforts a rung or the critic may take, lowest first. */
+const EFFORT_RUNGS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+/** The critic's effort when a ladder is set and nothing names one: reading a
+* diff costs far less than writing it, and the critic is what makes a cheap
+* build safe. */
+const DEFAULT_LADDER_CRITIC_EFFORT = "high";
+/** Builder providers whose fascicle transport drops `effort` and records
+* `effort_ignored`, so every rung of a ladder runs the same there. */
+const EFFORT_IGNORED_PROVIDERS = ["ollama", "lmstudio"];
+/** Whether a builder on `provider` ignores the effort a rung sets. */
+function ignores_effort(provider) {
+	return EFFORT_IGNORED_PROVIDERS.includes(provider);
+}
 /** `@path/to/file` reads the file; any other string passes through. */
 function expand_at_file(value, cwd) {
 	if (!value.startsWith("@")) return value;
@@ -962,6 +1380,9 @@ const CRITIQUE_REFUSED = [
 	["builder_max_tool_calls", "--builder-max-tool-calls"],
 	["builder_max_output_tokens", "--builder-max-output-tokens"],
 	["builder_trim_history", "--builder-trim-history"],
+	["effort_ladder", "--effort-ladder"],
+	["tester", "--tester"],
+	["tester_model", "--tester-model"],
 	["builder_permission_mode", "--builder-permission-mode"],
 	["allow_unsandboxed_builder", "--allow-unsandboxed-builder"],
 	["sandbox_image", "--sandbox-image"],
@@ -973,7 +1394,7 @@ const CRITIQUE_REFUSED = [
 	["fail_on_gate_edit", "--fail-on-gate-edit"]
 ];
 function refuse_builder_settings(raw) {
-	for (const [field, flag] of CRITIQUE_REFUSED) if (raw[field] !== void 0 && raw[field] !== false) throw config_error(`volley critique refuses ${flag} (${field}): a critique runs no builder and no loop`);
+	for (const [field, flag] of CRITIQUE_REFUSED) if (raw[field] !== void 0 && raw[field] !== false && raw[field] !== "off") throw config_error(`volley critique refuses ${flag} (${field}): a critique runs no builder and no loop`);
 }
 const BUILDER_MAX_STEPS = {
 	flag: "--builder-max-steps",
@@ -1020,6 +1441,84 @@ function positive_count(value, original, count) {
 	if (!Number.isInteger(value) || value < 1) throw config_error(`${count.flag} / ${count.env_var} must be a positive integer; got: ${String(original)}`);
 	return value;
 }
+const EFFORT_LADDER = {
+	flag: "--effort-ladder",
+	field: "effort_ladder",
+	env_var: "VOLLEY_EFFORT_LADDER"
+};
+const CRITIC_EFFORT = {
+	flag: "--critic-effort",
+	field: "critic_effort",
+	env_var: "VOLLEY_CRITIC_EFFORT"
+};
+/** One effort, held to the five from `low` to `max`. `none` gets its own
+* reason, since it's fascicle's level and the likeliest to be tried. */
+function effort_rung(value, setting) {
+	const rung = typeof value === "string" ? value.trim() : value;
+	if (EFFORT_RUNGS.includes(rung)) return rung;
+	const why = rung === "none" ? " (none sets no effort, and on claude_cli leaves Claude Code at its own default)" : "";
+	throw config_error(`${setting.flag} (${setting.field}) / ${setting.env_var} takes ${EFFORT_RUNGS.join(", ")}; got: ${String(value)}${why}`);
+}
+/** `--effort-ladder` (`effort_ladder`), as a list or the flag's comma-separated
+* form, wins over `VOLLEY_EFFORT_LADDER`; an empty variable counts as unset.
+* Unset is null, which passes no effort. A value that names no rung is refused
+* rather than read as unset, since it was asked for. */
+function resolve_effort_ladder(value, env) {
+	const env_value = env[EFFORT_LADDER.env_var];
+	const given = value ?? (env_value === "" ? void 0 : env_value);
+	if (given === void 0 || given === null) return null;
+	const items = typeof given === "string" ? given.split(",") : given;
+	if (!Array.isArray(items)) throw config_error(`${EFFORT_LADDER.flag} (${EFFORT_LADDER.field}) must be a list of rungs; got a ${typeof given}`);
+	const named = items.filter((item) => typeof item !== "string" || item.trim() !== "");
+	if (named.length === 0) throw config_error(`${EFFORT_LADDER.flag} (${EFFORT_LADDER.field}) / ${EFFORT_LADDER.env_var} names no rung; give one or more of ${EFFORT_RUNGS.join(", ")}, comma-separated`);
+	return named.map((item) => effort_rung(item, EFFORT_LADDER));
+}
+/** `--critic-effort` (`critic_effort`) wins over `VOLLEY_CRITIC_EFFORT`; an
+* empty variable counts as unset. Unset is `high` when a ladder is set, else
+* null, so a run without a ladder sends the critic what it always has. */
+function resolve_critic_effort(value, env, ladder) {
+	const env_value = env[CRITIC_EFFORT.env_var];
+	const given = value ?? (env_value === "" ? void 0 : env_value);
+	if (given !== void 0 && given !== null) return effort_rung(given, CRITIC_EFFORT);
+	return ladder === null ? null : DEFAULT_LADDER_CRITIC_EFFORT;
+}
+/** `--tester` (`tester`) wins over `VOLLEY_TESTER`, and takes `on` or `off`;
+* an empty variable counts as unset, and unset is off (move 1's D8). */
+function resolve_tester(value, env) {
+	const env_value = env["VOLLEY_TESTER"];
+	const given = value ?? (env_value === "" ? void 0 : env_value);
+	if (given === void 0 || given === null) return false;
+	const setting = typeof given === "string" ? given.trim() : given;
+	if (setting === "on" || setting === "off") return setting === "on";
+	throw config_error(`--tester (tester) / VOLLEY_TESTER takes on or off; got: ${JSON.stringify(given)}`);
+}
+/** The tester's model with the tester on: `--tester-model` (`tester_model`),
+* else `VOLLEY_TESTER_MODEL`, else the critic's. With it off, null, and a
+* model named by flag or config is refused rather than ignored; the variable,
+* which may be set for every run, is left unread. */
+function resolve_tester_model(tester, value, env, critic_model) {
+	const named = typeof value === "string" ? value.trim() : value;
+	if (!tester) {
+		if (named === void 0 || named === null || named === "") return null;
+		throw config_error("--tester-model (tester_model) applies only with --tester on");
+	}
+	if (named !== void 0 && named !== null && named !== "") {
+		if (typeof named !== "string") throw config_error(`--tester-model (tester_model) must be a model name; got a ${typeof named}`);
+		return named;
+	}
+	const env_value = env["VOLLEY_TESTER_MODEL"]?.trim();
+	return env_value === void 0 || env_value === "" ? critic_model : env_value;
+}
+/** Refuse a tester that can't do its job, or can't be contained, before any
+* spend (P1). It needs a check to go red (D18), a test or fixture gate pattern
+* to write under, and, on any provider but `claude_cli`, the containment a
+* builder needs, since the check runs what it writes (D14). Under acp, where
+* a person approves each edit, a local tester isn't refused here. */
+function refuse_unready_tester(check_resolved, gate_paths, critic_provider, guarded) {
+	if (check_resolved === "none") throw config_error("--tester on needs a check for its test to fail: set --check to a command, or to auto in a workspace with checkride, rather than none");
+	if (writable_gate_patterns(gate_paths).length === 0) throw config_error("--tester on needs a test or fixture gate pattern to write under; gate_paths names none");
+	if (critic_provider !== "claude_cli" && !guarded) throw config_error(`a tester on '${critic_provider}' writes tests the check then runs, so it is contained as a builder is: launch volley inside its sandbox container (VOLLEY_CONTAINED=1), or pass --allow-unsandboxed-builder (VOLLEY_ALLOW_UNSANDBOXED_BUILDER=1). A claude_cli builder stays on the host, so with one, the opt-out is the only way.`);
+}
 /** `--sandbox-image` (a merged flag/config value) wins over the
 * `VOLLEY_SANDBOX_IMAGE` env var, which wins over the default image. Used only
 * on the local-builder Docker sandbox path; the `claude_cli` path never
@@ -1146,6 +1645,8 @@ function resolve_config(raw, options = {}) {
 	if (!CRITIC_PROVIDERS.includes(critic_provider)) throw config_error(`--critic-provider must be one of ${CRITIC_PROVIDERS.join(", ")}; got: ${String(raw.critic_provider)}`);
 	const builder_url = resolve_seat_url("builder", raw.builder_url, builder_provider);
 	const critic_url = resolve_seat_url("critic", raw.critic_url, critic_provider);
+	const effort_ladder = resolve_effort_ladder(raw.effort_ladder, builder_env);
+	const critic_effort = resolve_critic_effort(raw.critic_effort, env, effort_ladder);
 	if (builder_provider === "openrouter" || critic_provider === "openrouter") openrouter_api_key(env);
 	if (contained) {
 		const claude_roles = [builder_provider === "claude_cli" && !critique ? "builder" : null, critic_provider === "claude_cli" ? "critic" : null].filter((role) => role !== null);
@@ -1159,12 +1660,17 @@ function resolve_config(raw, options = {}) {
 	if (discard_worktree && !worktree) throw config_error("--discard-worktree applies only to a --worktree run: there is no worktree to discard");
 	const gate_paths = raw.gate_paths ?? DEFAULT_GATE_PATTERNS;
 	if (!Array.isArray(gate_paths) || gate_paths.some((glob) => typeof glob !== "string")) throw config_error("gate_paths must be an array of glob strings");
+	const check = raw.check ?? "auto";
+	const check_resolved = resolve_check_runner(check, workspace);
+	const tester = resolve_tester(raw.tester, builder_env);
+	if (tester) refuse_unready_tester(check_resolved, gate_paths, critic_provider, options.uncontained_builder === "ask" || !unguarded_builder(raw, builder_env));
+	const critic_model = raw.critic_model ?? DEFAULT_CRITIC_MODEL;
+	const tester_model = resolve_tester_model(tester, raw.tester_model, builder_env, critic_model);
 	const sandbox_image = resolve_sandbox_image(raw, builder_env);
 	const state_dir = options.state_dir !== void 0 ? options.state_dir : resolve_state_dir(raw.state_dir, cwd, env);
 	if (state_dir === workspace) throw config_error(`--state-dir (state_dir) can't be the workspace itself: ${workspace}`);
 	const run_id = resolve_run_id(options.run_id);
 	if (state_dir !== null) validate_run_state_dir(join(state_dir, run_id), contained);
-	const check = raw.check ?? "auto";
 	return {
 		version: 2,
 		run_id,
@@ -1173,7 +1679,7 @@ function resolve_config(raw, options = {}) {
 		prompt,
 		criteria,
 		check,
-		check_resolved: resolve_check_runner(check, workspace),
+		check_resolved,
 		builder_model: raw.builder_model ?? "opus",
 		builder_provider,
 		builder_url,
@@ -1181,10 +1687,14 @@ function resolve_config(raw, options = {}) {
 		builder_max_tool_calls,
 		builder_max_output_tokens,
 		builder_trim_history,
+		effort_ladder,
 		allow_unsandboxed_builder,
-		critic_model: raw.critic_model ?? DEFAULT_CRITIC_MODEL,
+		critic_model,
 		critic_provider,
 		critic_url,
+		critic_effort,
+		tester,
+		tester_model,
 		builder_permission_mode,
 		critic_preset,
 		critic_prompt_path,
@@ -1410,290 +1920,64 @@ function stub(message, input, later) {
 	const detail = exit_code === null ? size : `${size}, exit ${String(exit_code)}`;
 	return `[volley] ${message.name} output (${detail}) elided from an earlier turn. Run it again if you need it.`;
 }
-/**
-* The request with every tool result before `cutoff` that is long enough to
-* matter and didn't fail replaced by a stub. Every message keeps its place,
-* role, id, and name. A stub reads only what comes before `cutoff`, so the
-* same transcript prefix always gives the same bytes.
-*/
-function trim_view(messages, cutoff) {
-	const window = messages.slice(0, cutoff);
-	const inputs = call_inputs(window);
-	const next_on_path = /* @__PURE__ */ new Map();
-	const later_for = /* @__PURE__ */ new Map();
-	for (let i = window.length - 1; i >= 0; i -= 1) {
-		const message = window[i];
-		if (message?.role !== "tool") continue;
-		const input = inputs.get(message.tool_call_id);
-		const path = input?.path ?? null;
-		if (path === null) continue;
-		if (message.name === "read_file") {
-			const later = next_on_path.get(path);
-			if (later !== void 0) later_for.set(i, later);
-		}
-		const supersedes = supersession_of(message, input);
-		if (supersedes !== null) next_on_path.set(path, supersedes);
-	}
-	return messages.map((message, i) => {
-		if (i >= cutoff || message.role !== "tool" || message.is_error === true) return message;
-		if (message.content.length <= 200) return message;
-		return {
-			...message,
-			content: stub(message, inputs.get(message.tool_call_id), later_for.get(i))
-		};
-	});
-}
-/**
-* Where to cut this turn's request, as a message index, or null to send it
-* whole. Boundaries are the starts of turns `TRIM_STRIDE_TURNS`,
-* `2 * TRIM_STRIDE_TURNS`, and so on, short of the last `TRIM_KEEP_TURNS`.
-* The cut moves to the next boundary only while the request, trimmed at the
-* last one, is still over `threshold`. A trimmed request only grows as the
-* session goes on, so a boundary once taken is kept.
-*/
-function trim_cutoff(messages, threshold) {
-	const turn_starts = messages.flatMap((message, i) => message.role === "assistant" ? [i] : []);
-	let cutoff = null;
-	for (let turn = 8; turn <= turn_starts.length - 6; turn += 8) {
-		if (estimate_tokens(cutoff === null ? messages : trim_view(messages, cutoff)) <= threshold) break;
-		cutoff = turn_starts[turn] ?? null;
-	}
-	return cutoff;
-}
-/** The `prepare_step` hook that trims a request estimated above `threshold`
-* tokens. */
-function step_trim(threshold) {
-	return ({ messages }) => {
-		const cutoff = trim_cutoff(messages, threshold);
-		return cutoff === null ? void 0 : { messages: trim_view(messages, cutoff) };
-	};
-}
-//#endregion
-//#region src/workspace_tools.ts
-/**
-* Shared workspace tools: `contain()` path confinement plus the read-only
-* tool set (`read_file`, `search_files`, `list_files`).
-*
-* The claude_cli builder/critic get file access from the CLI's own built-in
-* tools. API-style providers (ollama, lmstudio, …) have no built-ins, so
-* volley supplies its own. The critic uses the read-only set as-is via
-* `src/critic/tools.ts`; the builder set in
-* `src/builder/tools.ts` reuses `contain()` and the read tools and adds its
-* write/exec surface. Every path is resolved and confined to the
-* workspace root.
-*/
-const READ_FILE_MAX_BYTES = 2e5;
-const LIST_MAX_ENTRIES = 2e3;
-/** Directories never worth handing a seat; they bury signal and blow the
-* traversal budget. The acp seats' `list_files` and `search` skip the same
-* names (`./acp_tools.ts`), so a seat sees one tree under acp and on the CLI. */
-const IGNORED_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	".git",
-	".volley",
-	".check",
-	"dist",
-	".cache"
-]);
-/** Resolve `rel` inside `workspace`, rejecting absolute paths and any `..`
-* escape. Returns the absolute path; throws on containment violation. The
-* `workspace` root passed here is the build root, which is the per-run git
-* worktree under `--worktree` (`build_root`), not necessarily the
-* workspace the run was started on. */
-function contain(workspace, rel) {
-	const root = resolve(workspace);
-	const candidate = isAbsolute(rel) ? resolve(rel) : resolve(root, rel);
-	if (!(candidate === root || candidate.startsWith(`${root}${sep}`))) throw new Error(`path escapes the workspace: ${rel}`);
-	return candidate;
-}
-function walk(root, start, limit) {
-	const out = [];
-	const stack = [start];
-	while (stack.length > 0 && out.length < limit) {
-		const dir = stack.pop();
-		let entries;
-		try {
-			entries = readdirSync(dir);
-		} catch {
-			continue;
-		}
-		for (const name of entries) {
-			const abs = join(dir, name);
-			let is_dir;
-			try {
-				is_dir = statSync(abs).isDirectory();
-			} catch {
-				continue;
-			}
-			if (is_dir) {
-				if (!IGNORED_DIRS.has(name)) stack.push(abs);
-				continue;
-			}
-			out.push({
-				rel: relative(root, abs),
-				abs
-			});
-			if (out.length >= limit) break;
-		}
-	}
-	return out;
-}
-/** The files a read tool's optional `path` covers: the whole tree, the tree
-* under a directory, or the one file it names. A path that doesn't exist
-* throws, so the seat reads why rather than an empty result that looks like
-* "nothing matched". */
-function scoped_files(workspace, path, limit) {
-	const root = resolve(workspace);
-	if (path === void 0) return walk(root, root, limit);
-	const start = contain(workspace, path);
-	let is_dir;
-	try {
-		is_dir = statSync(start).isDirectory();
-	} catch (err) {
-		throw new Error(`no such file or directory: ${path}`, { cause: err });
-	}
-	return is_dir ? walk(root, start, limit) : [{
-		rel: relative(root, start),
-		abs: start
-	}];
-}
-function build_regex(pattern, flags) {
-	try {
-		return new RegExp(pattern, flags);
-	} catch (err) {
-		const detail = err instanceof Error ? err.message : String(err);
-		throw new Error(`invalid regular expression: ${detail}`);
-	}
-}
-const read_file_input = z.object({ path: z.string().describe("Workspace-relative path to the file to read.") });
-const search_files_input = z.object({
-	pattern: z.string().describe("JavaScript regular expression to match against each line."),
-	path: z.string().optional().describe("Optional workspace-relative directory or file to limit the search to."),
-	ignore_case: z.boolean().optional().describe("Case-insensitive match. Default false.")
-});
-const list_files_input = z.object({
-	path: z.string().optional().describe("Optional workspace-relative directory or file. Default: the workspace root."),
-	contains: z.string().optional().describe("Optional substring filter applied to each relative path.")
-});
-function read_only_tools(workspace) {
-	return [
-		{
-			name: "read_file",
-			read_only: true,
-			description: `Read a UTF-8 text file from the workspace. Returns the file content (truncated at ${String(READ_FILE_MAX_BYTES)} bytes).`,
-			input_schema: read_file_input,
-			execute: (raw) => {
-				const abs = contain(workspace, read_file_input.parse(raw).path);
-				const content = readFileSync(abs, "utf8");
-				return content.length > 2e5 ? `${content.slice(0, READ_FILE_MAX_BYTES)}\n… [truncated at ${String(READ_FILE_MAX_BYTES)} bytes]` : content;
-			}
-		},
-		{
-			name: "search_files",
-			read_only: true,
-			description: `Search workspace files for lines matching a regular expression. Returns up to ${String(200)} "relative/path:line: text" hits.`,
-			input_schema: search_files_input,
-			execute: (raw) => {
-				const input = search_files_input.parse(raw);
-				const regex = build_regex(input.pattern, input.ignore_case === true ? "i" : "");
-				const files = scoped_files(workspace, input.path, LIST_MAX_ENTRIES);
-				const hits = [];
-				for (const file of files) {
-					if (hits.length >= 200) break;
-					let content;
-					try {
-						content = readFileSync(file.abs, "utf8");
-					} catch {
-						continue;
-					}
-					const lines = content.split("\n");
-					for (let i = 0; i < lines.length; i += 1) {
-						if (hits.length >= 200) break;
-						const line = lines[i];
-						if (regex.test(line)) hits.push(`${file.rel}:${String(i + 1)}: ${line.trim()}`);
-					}
-				}
-				if (hits.length === 0) return "no matches";
-				const capped = hits.length >= 200 ? `\n… [capped at ${String(200)} matches]` : "";
-				return `${hits.join("\n")}${capped}`;
-			}
-		},
-		{
-			name: "list_files",
-			read_only: true,
-			description: "List files under a workspace directory (recursively; skips node_modules, .git, and other build/output directories).",
-			input_schema: list_files_input,
-			execute: (raw) => {
-				const input = list_files_input.parse(raw);
-				let files = scoped_files(workspace, input.path, LIST_MAX_ENTRIES).map((f) => f.rel);
-				if (input.contains !== void 0) {
-					const needle = input.contains;
-					files = files.filter((f) => f.includes(needle));
-				}
-				if (files.length === 0) return "no files";
-				const capped = files.length >= LIST_MAX_ENTRIES ? `\n… [capped at ${String(LIST_MAX_ENTRIES)} entries]` : "";
-				return `${files.join("\n")}${capped}`;
-			}
-		}
-	];
-}
-/** A `paths + sizes` listing of the workspace tree, no file contents — the
-* grounding a tool-less critic gets when its provider's tool parser died and the
-* degradation ladder traded read access for survival. Reuses the same
-* `walk` + `IGNORED_DIRS` traversal as the read tools, so the inventory matches
-* what a working `list_files` would have surfaced; caps at `limit` entries. */
-function workspace_inventory(root, limit = LIST_MAX_ENTRIES) {
-	const base = resolve(root);
-	const files = walk(base, base, limit);
-	if (files.length === 0) return "no files";
-	const lines = files.map((file) => {
-		let size;
-		try {
-			size = statSync(file.abs).size;
-		} catch {
-			size = 0;
+/**
+* The request with every tool result before `cutoff` that is long enough to
+* matter and didn't fail replaced by a stub. Every message keeps its place,
+* role, id, and name. A stub reads only what comes before `cutoff`, so the
+* same transcript prefix always gives the same bytes.
+*/
+function trim_view(messages, cutoff) {
+	const window = messages.slice(0, cutoff);
+	const inputs = call_inputs(window);
+	const next_on_path = /* @__PURE__ */ new Map();
+	const later_for = /* @__PURE__ */ new Map();
+	for (let i = window.length - 1; i >= 0; i -= 1) {
+		const message = window[i];
+		if (message?.role !== "tool") continue;
+		const input = inputs.get(message.tool_call_id);
+		const path = input?.path ?? null;
+		if (path === null) continue;
+		if (message.name === "read_file") {
+			const later = next_on_path.get(path);
+			if (later !== void 0) later_for.set(i, later);
 		}
-		return `${file.rel} (${String(size)} bytes)`;
+		const supersedes = supersession_of(message, input);
+		if (supersedes !== null) next_on_path.set(path, supersedes);
+	}
+	return messages.map((message, i) => {
+		if (i >= cutoff || message.role !== "tool" || message.is_error === true) return message;
+		if (message.content.length <= 200) return message;
+		return {
+			...message,
+			content: stub(message, inputs.get(message.tool_call_id), later_for.get(i))
+		};
 	});
-	const capped = files.length >= limit ? `\n… [capped at ${String(limit)} entries]` : "";
-	return `${lines.join("\n")}${capped}`;
 }
-//#endregion
-//#region src/builder/tools.ts
 /**
-* Builder tool set for local (non-CLI) builders.
-*
-* A local model brings no built-in tools, so volley supplies the whole
-* agentic surface: the shared read-only trio (reused from
-* `src/workspace_tools.ts`) plus `write_file`, `edit_file`, `bash`,
-* `fetch`, and the terminal `finish`. File paths are confined to the
-* workspace via `contain()`.
-*
-* Error semantics: a wrong-but-recoverable input — `edit_file`
-* matching 0 or N places, a `bash` command exiting non-zero or timing out, a
-* `fetch` that is SSRF-blocked or fails — is *returned* as a tool result the
-* model reads and acts on. Tools throw only on a genuine harness fault
-* (containment violation, unreadable input, over-cap write).
-*
-* `fetch` is a native readability pipeline (`linkedom` + `@mozilla/
-* readability` + `turndown`) with SSRF protection at the undici connector, not
-* as a pre-flight URL check: a validating DNS `lookup` rejects hostnames that
-* resolve to a non-unicast address before the TCP connect, and the resolved
-* socket's peer address is re-checked after connect — which also catches
-* literal-IP URLs (Node skips `lookup` for those) and every redirect hop
-* (each re-dispatches through the same guarded connector). The byte cap is
-* enforced while reading the HTTP stream, so raw HTML is never returned and a
-* huge page cannot OOM the tool.
-*
-* Egress is defended in two independent layers: this tool's SSRF
-* deny-list (above) and the sandbox's container network posture (`--network none`
-* by default, or a host-collapsed allowlist bridge — see `SandboxNetwork` in
-* `src/sandbox.ts`). Under whole-process containment the whole volley
-* process — `fetch` included — runs inside the container, so both layers apply to
-* `fetch`'s egress: `--network none` leaves it no route and it returns a "could
-* not fetch" error result, and the loop continues.
+* Where to cut this turn's request, as a message index, or null to send it
+* whole. Boundaries are the starts of turns `TRIM_STRIDE_TURNS`,
+* `2 * TRIM_STRIDE_TURNS`, and so on, short of the last `TRIM_KEEP_TURNS`.
+* The cut moves to the next boundary only while the request, trimmed at the
+* last one, is still over `threshold`. A trimmed request only grows as the
+* session goes on, so a boundary once taken is kept.
 */
-const WRITE_FILE_MAX_BYTES = 1e6;
+function trim_cutoff(messages, threshold) {
+	const turn_starts = messages.flatMap((message, i) => message.role === "assistant" ? [i] : []);
+	let cutoff = null;
+	for (let turn = 8; turn <= turn_starts.length - 6; turn += 8) {
+		if (estimate_tokens(cutoff === null ? messages : trim_view(messages, cutoff)) <= threshold) break;
+		cutoff = turn_starts[turn] ?? null;
+	}
+	return cutoff;
+}
+/** The `prepare_step` hook that trims a request estimated above `threshold`
+* tokens. */
+function step_trim(threshold) {
+	return ({ messages }) => {
+		const cutoff = trim_cutoff(messages, threshold);
+		return cutoff === null ? void 0 : { messages: trim_view(messages, cutoff) };
+	};
+}
 const BASH_MAX_OUTPUT_BYTES = 1e5;
 const BASH_CAPTURE_MAX_BYTES = 1e7;
 const FETCH_MAX_BYTES = 2e5;
@@ -1702,15 +1986,6 @@ const FETCH_MAX_REDIRECTS = 5;
 const FETCH_TIMEOUT_MS = 3e4;
 const FETCH_MIN_EXTRACT_CHARS = 200;
 const FETCH_USER_AGENT = "volley-local-builder";
-const write_file_input = z.object({
-	path: z.string().describe("Workspace-relative path to write. Parent directories are created."),
-	content: z.string().describe("Full UTF-8 content of the file. Overwrites any existing content.")
-});
-const edit_file_input = z.object({
-	path: z.string().describe("Workspace-relative path of the file to edit."),
-	old_str: z.string().min(1).describe("Exact text to replace. Must occur exactly once in the file."),
-	new_str: z.string().describe("Replacement text.")
-});
 const bash_input = z.object({ command: z.string().describe("Shell command to run in the workspace directory.") });
 const finish_input = z.object({ summary: z.string().describe("Short summary of what was accomplished.") });
 const fetch_input = z.object({
@@ -1718,9 +1993,6 @@ const fetch_input = z.object({
 	max_chars: z.number().int().positive().optional().describe(`Maximum characters of extracted markdown to return (default ${String(FETCH_MAX_CHARS)}).`),
 	start_index: z.number().int().min(0).optional().describe("Character offset into the extracted markdown to start from, for paging a long page. Default 0.")
 });
-function count_occurrences(haystack, needle) {
-	return haystack.split(needle).length - 1;
-}
 /** Truncate `text` to at most `max` bytes, appending a marker when clipped.
 * Byte-based to honor the byte cap; a split multibyte char at the boundary
 * renders as the replacement char, which is acceptable for tool output. */
@@ -1960,35 +2232,6 @@ function builder_tools(workspace, options = {}) {
 	const bash_timeout_ms = options.bash_timeout_ms ?? 6e5;
 	const bash_max_output_bytes = options.bash_max_output_bytes ?? BASH_MAX_OUTPUT_BYTES;
 	const bash_executor = options.bash_executor ?? host_bash_executor(workspace);
-	const write_file = {
-		name: "write_file",
-		description: `Write a UTF-8 text file in the workspace, creating parent directories and overwriting any existing content. Rejects content over ${String(WRITE_FILE_MAX_BYTES)} bytes.`,
-		input_schema: write_file_input,
-		execute: (raw) => {
-			const input = write_file_input.parse(raw);
-			const abs = contain(workspace, input.path);
-			const bytes = Buffer.byteLength(input.content, "utf8");
-			if (bytes > 1e6) throw new Error(`content is ${String(bytes)} bytes, over the ${String(WRITE_FILE_MAX_BYTES)}-byte write cap`);
-			mkdirSync(dirname(abs), { recursive: true });
-			writeFileSync(abs, input.content, "utf8");
-			return `wrote ${String(bytes)} bytes to ${input.path}`;
-		}
-	};
-	const edit_file = {
-		name: "edit_file",
-		description: "Replace one exact occurrence of old_str with new_str in a workspace file. old_str must match the file content exactly once — on 0 or multiple matches nothing is changed and an error is returned; read the file and retry with a longer, unique old_str.",
-		input_schema: edit_file_input,
-		execute: (raw) => {
-			const input = edit_file_input.parse(raw);
-			const abs = contain(workspace, input.path);
-			const content = readFileSync(abs, "utf8");
-			const matches = count_occurrences(content, input.old_str);
-			if (matches === 0) return `error: old_str not found in ${input.path} (0 matches). No change made. Read the file and retry with an exact excerpt of its current content.`;
-			if (matches > 1) return `error: old_str matches ${String(matches)} times in ${input.path}. No change made. Include more surrounding context to make old_str unique.`;
-			writeFileSync(abs, content.replace(input.old_str, input.new_str), "utf8");
-			return `edit applied to ${input.path}`;
-		}
-	};
 	const bash = {
 		name: "bash",
 		description: `Run a shell command in the workspace and return its exit code, stdout, and stderr. Each call is independent — no shell state (working directory, environment, variables) carries over between commands. A non-zero exit is a normal result, not an error: read it and adjust. Each stream is truncated past ${String(bash_max_output_bytes)} bytes, and the command is killed if it runs longer than ${String(bash_timeout_ms)}ms.`,
@@ -2023,8 +2266,7 @@ function builder_tools(workspace, options = {}) {
 	};
 	return [
 		...read_only_tools(workspace),
-		write_file,
-		edit_file,
+		...write_tools(workspace),
 		bash,
 		fetch,
 		finish_tool()
@@ -2295,6 +2537,32 @@ const BUILDER_ALLOWED_TOOLS = [
 ];
 const CRITIC_ALLOWED_TOOLS = ["Read(/**)"];
 const CRITIC_DISALLOWED_TOOLS = "Write,Edit,MultiEdit,NotebookEdit,Bash";
+/** A gate pattern an `Edit(...)` rule can carry: one with no space, comma or
+* parenthesis, which the CLI would read as the rule list's own syntax. One
+* that can't be carried is left out, so the tester can write less, never
+* more. */
+function rule_safe(pattern) {
+	return !/[\s,()]/.test(pattern);
+}
+/** A `claude_cli` tester's allowlist (move 1's D19): reads anywhere in the
+* build root, and one `Edit` rule per writable gate pattern
+* (`writable_gate_patterns`), anchored at the build root. The tester runs in
+* the CLI's default permission mode, where an edit no rule allows is refused,
+* since `-p` has no one to ask. */
+function tester_allowed_tools(writable) {
+	return ["Read(/**)", ...writable.filter(rule_safe).map((pattern) => `Edit(/${pattern.replace(/^\/+/, "")})`)];
+}
+/** What a `claude_cli` tester is refused outright: a shell and notebooks, and
+* an edit to the files the gate patterns cover that configure the check rather
+* than test the work (D20). A deny rule wins over the allowlist in every
+* permission mode. */
+const TESTER_DISALLOWED_TOOLS = [
+	"Bash",
+	"NotebookEdit",
+	"Edit(/**/package.json)",
+	"Edit(/**/*.config.*)",
+	"Edit(/**/.github/**)"
+].join(",");
 const PERMISSION_BLOCKS = { permissions: {
 	blockWritesOutsideWorkingDirectories: true,
 	blockReadsOutsideWorkingDirectories: true
@@ -2435,6 +2703,7 @@ function accumulate(state, role, result, model, duration_ms) {
 		iteration_cost_usd: state.iteration_cost_usd + cost,
 		builder_cost_usd: state.builder_cost_usd + (role === "builder" ? cost : 0),
 		critic_cost_usd: state.critic_cost_usd + (role === "critic" ? cost : 0),
+		tester_cost_usd: state.tester_cost_usd + (role === "tester" ? cost : 0),
 		cost_warned: state.cost_warned || record.cost_usd === null
 	};
 }
@@ -2983,6 +3252,29 @@ function previous_check_section(check) {
 	if (excerpt.length > 0) lines.push("", excerpt);
 	return lines;
 }
+/** The tester's test, in every build after it: its files, which the builder
+* makes pass rather than edits, and in the build it ran before, the check
+* that failed on them. A tester outside a git repository wrote files volley
+* can't name, so only the check is said. */
+function tester_section(tester) {
+	if (tester === null || tester === void 0) return [];
+	const lines = [
+		"",
+		"THE TESTER'S TEST",
+		"-----------------"
+	];
+	if (tester.paths.length > 0) lines.push("Before the first build, a tester wrote these tests from the acceptance", "criteria:", ...tester.paths.map((path) => `  ${path}`), "Do the work that makes them pass. Never weaken, skip or delete one: an edit", "to any of them is reported as a gate edit.");
+	else lines.push("Before the first build, a tester wrote a test from the acceptance criteria.");
+	const check = tester.check;
+	if (check !== null && check.ran && !check.ok) {
+		const exit = check.exit_code === null ? "no exit code" : `exit ${String(check.exit_code)}`;
+		lines.push("", `The check fails on it now, as it must (${exit}).`);
+		if (check.failing_slots.length > 0) lines.push(`Failing slots: ${check.failing_slots.join(", ")}.`);
+		const excerpt = check_excerpt(check);
+		if (excerpt.length > 0) lines.push("", excerpt);
+	}
+	return lines;
+}
 /** The line a later iteration's prompt carries when the last session ran out
 * of steps: it never got to verify, so this one should check first. */
 function step_limit_lines(step_limit_hit) {
@@ -3008,16 +3300,19 @@ function compose_builder_prompt(input) {
 	];
 	if (input.iteration > 1 && input.feedback !== null) parts.push("", "PREVIOUS CRITIC FEEDBACK", "------------------------", input.feedback, "", "Address the feedback above. The workspace already contains your prior work;", "read the current state, then make the necessary changes.");
 	if (input.iteration > 1 && input.previous !== null) parts.push(...previous_check_section(input.previous.check), ...step_limit_lines(input.previous.step_limit_hit));
+	parts.push(...tester_section(input.tester));
 	if (input.checkride) parts.push("", "The definition of done for this workspace includes checkride exiting 0. Run", "`pnpm exec checkride --digest`, the check volley gates on, after each batch of", "edits and again before you finish. When it fails, read .check/digest.md", "first: it lists each failing slot's first findings. Open a slot's raw", "output under .check/ only if the digest isn't enough, then fix and re-run.");
 	return parts.join("\n");
 }
 function builder_max_steps_warning(max_steps) {
 	return `builder hit the ${String(max_steps)}-step limit without calling finish; handing the partial workspace to check + critic (raise --builder-max-steps if this recurs)`;
 }
-/** Build the builder leaf for this run. Everything but the prompt is fixed for
-* the whole run, so it is wired once here: the provider's system prompt, its
-* tool surface, and the live chunk stream to the renderer. */
-function make_builder_step(deps) {
+/** Build the builder leaf for this run at `effort`. Everything but the prompt
+* is fixed for the whole run, so it is wired once here: the provider's system
+* prompt, its tool surface, the live chunk stream to the renderer, and the
+* effort, which fascicle's `model_call` takes only as it's built. Null passes
+* no effort at all, so a run with no ladder makes the call it always has. */
+function make_builder_step(deps, effort = null) {
 	const { config } = deps;
 	return model_call({
 		engine: deps.engine,
@@ -3027,9 +3322,45 @@ function make_builder_step(deps) {
 		model: config.builder_model,
 		system: resolve_builder_system(config, deps.tool_set),
 		on_chunk: deps.on_chunk,
+		...effort !== null ? { effort } : {},
 		...builder_tool_options(deps)
 	});
 }
+function make_builder_ladder(deps) {
+	const built = /* @__PURE__ */ new Map();
+	const at = (rung) => {
+		const cached = built.get(rung);
+		if (cached !== void 0) return cached;
+		const leaf = make_builder_step(deps, rung);
+		built.set(rung, leaf);
+		return leaf;
+	};
+	return {
+		arm: at(deps.config.effort_ladder?.[0] ?? null),
+		at
+	};
+}
+/** The tester's test as `state` carries it, or null when no tester ran: its
+* files' hashes outlive the iteration it opened, its check doesn't. */
+function tester_test(state) {
+	const paths = Object.keys(state.tester_hashes).toSorted();
+	if (paths.length === 0 && state.tester_check === null) return null;
+	return {
+		paths,
+		check: state.tester_check
+	};
+}
+/** Mark the builder record as having asked for an effort its provider drops. */
+function with_effort_ignored(state, ignored) {
+	if (!ignored || state.builder === null) return state;
+	return {
+		...state,
+		builder: {
+			...state.builder,
+			effort_ignored: true
+		}
+	};
+}
 /** Run one builder session on the opened iteration `state`, told what the
 * iteration before it left behind (`previous`, null on the first). */
 async function run_builder(deps, state, previous, ctx) {
@@ -3046,9 +3377,10 @@ async function run_builder(deps, state, previous, ctx) {
 			feedback: state.feedback,
 			iteration: state.iteration,
 			checkride: config.check_resolved === "checkride",
-			previous
+			previous,
+			tester: tester_test(state)
 		}));
-		const built = accumulate(state, "builder", result, config.builder_model);
+		const built = with_effort_ignored(accumulate(state, "builder", result, config.builder_model), state.rung !== null && ignores_effort(config.builder_provider));
 		if (result.finish_reason !== "max_steps") return built;
 		deps.warn(builder_max_steps_warning(config.builder_max_steps));
 		return {
@@ -3104,6 +3436,26 @@ function place_iterations_dir(append, config) {
 	const outside = path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path);
 	return append.split("\n").filter((line) => !(outside && line.includes(ITERATIONS_DIR))).join("\n").replaceAll(ITERATIONS_DIR, `${path}/`);
 }
+/** The tester's test, for the critic to judge as well as the work: whether it
+* tests the criteria at all, since a check is only as good as what it runs.
+* Null when no tester wrote one. */
+function format_tester_section(paths) {
+	if (paths === void 0 || paths.length === 0) return null;
+	return [
+		"THE TESTER'S TEST",
+		"-----------------",
+		"Before the first build, a tester wrote these tests from the acceptance",
+		"criteria, and the check failed on them then:",
+		"",
+		...paths.map((path) => `  ${path}`),
+		"",
+		"Read them, and judge whether they test the criteria: a test a wrong",
+		"implementation would pass, or one that leaves out a criterion a test could",
+		"check, does not. Name each problem in test_findings, one per entry, and leave",
+		"it empty when the test is sound. Judge the work against the criteria either",
+		"way, not against the test alone."
+	].join("\n");
+}
 /** One-letter status column, so a hundred-path list stays readable. */
 const STATUS_MARKS = {
 	added: "A",
@@ -3165,6 +3517,7 @@ function format_check_section(check) {
 }
 function compose_critic_prompt(input) {
 	const changes = format_changes_section(input.changes);
+	const tester = format_tester_section(input.tester_paths);
 	return [
 		"ACCEPTANCE CRITERIA",
 		"-------------------",
@@ -3174,6 +3527,7 @@ function compose_critic_prompt(input) {
 		"",
 		format_check_section(input.check),
 		...changes === null ? [] : ["", changes],
+		...tester === null ? [] : ["", tester],
 		"",
 		"Review the workspace against the acceptance criteria and return your",
 		"structured verdict."
@@ -3196,7 +3550,8 @@ function compose_critic_prompt(input) {
 const verdict_schema = z.object({
 	verdict: z.enum(["approved", "changes_requested"]),
 	feedback: z.string().nullable().transform((feedback) => feedback ?? "").describe("Free-form markdown for the builder. Concrete and actionable. Will be passed verbatim into the next iteration."),
-	unmet_criteria: z.array(z.string()).nullable().transform((unmet) => unmet ?? []).describe("The specific acceptance criteria judged unmet, verbatim. Empty when approved.")
+	unmet_criteria: z.array(z.string()).nullable().transform((unmet) => unmet ?? []).describe("The specific acceptance criteria judged unmet, verbatim. Empty when approved."),
+	test_findings: z.array(z.string()).nullable().optional().describe("Problems with the tester's test, one per entry: a criterion it leaves out, or an assertion a wrong implementation would pass. Empty or omitted when no tester ran or its test is sound.")
 });
 /** Read-only tool wiring per provider. The claude_cli critic is confined at
 * the CLI permission layer (allowlist + explicit disallow, and the settings
@@ -3266,6 +3621,12 @@ function retry_cause_kind_of(err) {
 	const cause = err.cause_kind;
 	return cause === "provider_5xx" || cause === "network" ? cause : "unknown";
 }
+/** The critic's findings about the tester's test, for its record, when it
+* named any. */
+function test_findings_of(verdict) {
+	const findings = verdict.test_findings ?? [];
+	return findings.length > 0 ? { test_findings: findings } : {};
+}
 /** Fold a successful critic `generate` result into loop state, stamping the
 * ladder bookkeeping onto the critic record. Shared by the tool-bearing path and
 * the tool-less fallback so both shape the record identically (the fallback just
@@ -3279,7 +3640,8 @@ function finalize_critic(state, result, model, mark, duration_ms) {
 			retries: mark.retries,
 			...mark.retry_cause_kind !== void 0 ? { retry_cause_kind: mark.retry_cause_kind } : {},
 			...mark.critic_degraded === true ? { critic_degraded: true } : {},
-			...mark.degrade_cause !== void 0 ? { degrade_cause: mark.degrade_cause } : {}
+			...mark.degrade_cause !== void 0 ? { degrade_cause: mark.degrade_cause } : {},
+			...test_findings_of(result.content)
 		},
 		verdict: result.content.verdict,
 		feedback: result.content.feedback,
@@ -3303,6 +3665,8 @@ function toolless_critic_prompt(config, tool_prompt) {
 		workspace_inventory(build_root(config.workspace, config.worktree))
 	].join("\n");
 }
+/** What both of the critic's calls share, its effort included when one is set
+* (`critic_effort`); unset, no effort is passed, as before there was one. */
 function critic_call_config(deps) {
 	const { config } = deps;
 	return {
@@ -3311,7 +3675,8 @@ function critic_call_config(deps) {
 		model: config.critic_model,
 		system: resolve_critic_prompt(config, deps.tool_set),
 		schema: verdict_schema,
-		on_chunk: deps.on_chunk
+		on_chunk: deps.on_chunk,
+		...config.critic_effort !== null ? { effort: config.critic_effort } : {}
 	};
 }
 /** Rung 1's leaf: the critic with its read tools (or the CLI's read-only
@@ -3429,11 +3794,20 @@ async function run_critic(deps, state, ctx) {
 			criteria: config.criteria,
 			iteration: state.iteration,
 			check,
-			changes: state.changes
+			changes: state.changes,
+			tester_paths: Object.keys(state.tester_hashes).toSorted()
 		});
 		const started = Date.now();
 		const { result, mark } = await ctx.call(deps.critic, prompt);
-		return finalize_critic(state, result, config.critic_model, mark, Date.now() - started);
+		const critiqued = finalize_critic(state, result, config.critic_model, mark, Date.now() - started);
+		if (config.critic_effort === null || !ignores_effort(config.critic_provider)) return critiqued;
+		return critiqued.critic === null ? critiqued : {
+			...critiqued,
+			critic: {
+				...critiqued.critic,
+				effort_ignored: true
+			}
+		};
 	} catch (err) {
 		throw phase_error("critic", state.iteration, err);
 	}
@@ -3457,17 +3831,59 @@ function initial_state() {
 		changes: null,
 		builder: null,
 		critic: null,
+		tester: null,
+		tester_check: null,
+		tester_changes: null,
+		tester_hashes: {},
 		total_usage: EMPTY_USAGE,
 		total_cost_usd: 0,
 		builder_cost_usd: 0,
 		critic_cost_usd: 0,
+		tester_cost_usd: 0,
 		check_duration_ms: 0,
 		builder_max_steps_hits: 0,
+		builds: 0,
+		rung: null,
+		climbed: null,
 		iteration_cost_usd: 0,
 		halt: null,
 		cost_warned: false
 	};
 }
+/** The effort build `build` (counted from 1) runs at: one rung further up the
+* ladder per build before it, the top rung repeating once it's reached. Null
+* with no ladder, which passes no effort at all. */
+function rung_for_build(ladder, build) {
+	if (ladder === null || ladder.length === 0) return null;
+	return ladder[Math.min(Math.max(build, 1), ladder.length) - 1] ?? null;
+}
+/** Why build `build` runs a rung above the build before it, read off the state
+* that build left (`previous`). That build didn't end the run, so its check
+* failed or the critic sent it back: a check that didn't fail means the critic,
+* which is also how a resumed run reads it, since a resume keeps the last
+* check but not the last verdict. Null when it doesn't climb, because it's the
+* first build, the ladder's top has been reached, or there is no ladder. */
+function climb_reason(ladder, build, previous) {
+	if (ladder === null || build < 2 || build > ladder.length) return null;
+	return previous.check?.ok === false ? "check_failed" : "critic_rejected";
+}
+/** Whether the tester opens the iteration after `s`: it's on, and this is the
+* run's first (move 1's D17). A run resumed before iteration 1 completed runs
+* it again. */
+function tester_opens(config, s) {
+	return config.tester && s.iteration === 0;
+}
+/** Whether the test phase opened this iteration and no build has run in it
+* yet: the tester ran, and the run has started no build. The build then works
+* in the iteration the tester opened rather than opening the next. */
+function tester_opened(s) {
+	return s.tester !== null && s.builds === 0;
+}
+/** Whether the check passed right after the tester, before any build. A check
+* skipped for the cost cap didn't run, so it never counts. */
+function tester_passed_early(s) {
+	return tester_opened(s) && s.tester_check?.ran === true && s.tester_check.ok;
+}
 /** How many rounds the loop may still run: the whole budget on a fresh run, what
 * the resumed run's completed iterations left of it otherwise. */
 function remaining_iterations(config, resume_from) {
@@ -3480,7 +3896,8 @@ function gate_edit_halt(config, state) {
 	return config.fail_on_gate_edit && (state.changes?.gate_edits.length ?? 0) > 0;
 }
 /** All stopping conditions live here: acceptance, cost cap, the gate
-* edit refusal, and — implicitly via `max_rounds` — the iteration budget.
+* edit refusal, a tester's test passing before any build, and — implicitly
+* via `max_rounds` — the iteration budget.
 * Success wins when it and the cap land on the same iteration.
 *
 * A gate edit is the one condition that *beats* success rather than losing to
@@ -3491,9 +3908,10 @@ function gate(config, state) {
 	const gate_edit = gate_edit_halt(config, state);
 	const success = state.check?.ok === true && state.verdict === "approved" && !gate_edit;
 	const cap = cost_cap_hit(config, state);
-	const halt = gate_edit ? "gate_edit" : !success && cap ? "cost_cap" : null;
+	const passed_early = tester_passed_early(state);
+	const halt = gate_edit ? "gate_edit" : passed_early ? "tester_passed_early" : !success && cap ? "cost_cap" : null;
 	return {
-		stop: success || cap || gate_edit,
+		stop: success || cap || gate_edit || passed_early,
 		state: {
 			...state,
 			halt
@@ -3502,6 +3920,7 @@ function gate(config, state) {
 }
 function status_of(value, converged) {
 	if (value.halt === "gate_edit") return "gate_edit_blocked";
+	if (value.halt === "tester_passed_early") return "tester_passed_early";
 	if (value.halt === "cost_cap") return "cost_cap_reached";
 	return converged ? "success" : "budget_exhausted";
 }
@@ -3519,6 +3938,7 @@ function paint(role, text, color) {
 	switch (role) {
 		case "builder": return pc.cyan(text);
 		case "critic": return pc.yellow(text);
+		case "tester": return pc.blue(text);
 		case "check": return pc.green(text);
 		case "cost": return pc.magenta(text);
 		case "error": return pc.bold(pc.red(text));
@@ -3531,6 +3951,11 @@ function truncate(text, max, pointer) {
 	if (text.length <= max) return text;
 	return `${text.slice(0, max)}\n… [truncated at ${String(max)} chars; ${pointer}]`;
 }
+/** The rung a build runs at, and why it's above the last build's when it is:
+* `rung medium (climbed: check_failed)`. */
+function format_rung(rung, climbed) {
+	return `rung ${rung}${climbed === null ? "" : ` (climbed: ${climbed})`}`;
+}
 function format_usd(value) {
 	return value === null ? "$?" : `$${value.toFixed(3)}`;
 }
@@ -3578,10 +4003,23 @@ function phase_summary(record) {
 		...record.retry_cause_kind !== void 0 ? { retry_cause_kind: record.retry_cause_kind } : {},
 		...record.critic_degraded === true ? { critic_degraded: true } : {},
 		...record.degrade_cause !== void 0 ? { degrade_cause: record.degrade_cause } : {},
+		...record.test_findings !== void 0 ? { test_findings: record.test_findings } : {},
+		...record.effort_ignored === true ? { effort_ignored: true } : {},
 		...record.throughput !== void 0 ? { throughput: record.throughput } : {},
 		...record.steps !== void 0 ? { steps: record.steps } : {}
 	};
 }
+/** A check as the iteration archive records it, its artifacts aside. */
+function check_summary(check) {
+	return check === null ? null : {
+		ran: check.ran,
+		runner: check.runner,
+		ok: check.ok,
+		exit_code: check.exit_code,
+		duration_ms: check.duration_ms,
+		failing_slots: check.failing_slots
+	};
+}
 /** Archive one completed iteration: verdict files, check artifacts, and the
 * per-iteration summary. */
 function archive_iteration(config, state) {
@@ -3610,16 +4048,17 @@ function archive_iteration(config, state) {
 		started_at: state.iteration_started_at,
 		completed_at,
 		duration_ms: Date.parse(completed_at) - Date.parse(state.iteration_started_at),
+		builds: state.builds,
+		rung: state.rung,
+		climbed: state.climbed,
+		effort_ignored: state.builder?.effort_ignored === true,
 		builder: phase_summary(state.builder),
-		check: check === null ? null : {
-			ran: check.ran,
-			runner: check.runner,
-			ok: check.ok,
-			exit_code: check.exit_code,
-			duration_ms: check.duration_ms,
-			failing_slots: check.failing_slots
-		},
+		check: check_summary(check),
 		critic: phase_summary(state.critic),
+		tester: phase_summary(state.tester),
+		tester_check: check_summary(state.tester_check),
+		tester_changes: state.tester_changes,
+		tester_hashes: state.tester_hashes,
 		changes: state.changes,
 		verdict: state.verdict,
 		unmet_criteria: state.unmet_criteria,
@@ -3638,6 +4077,7 @@ function run_result_from_state(config, state, status, completed_at) {
 		total_cost_usd: state.total_cost_usd,
 		builder_cost_usd: state.builder_cost_usd,
 		critic_cost_usd: state.critic_cost_usd,
+		tester_cost_usd: state.tester_cost_usd,
 		check_duration_ms: state.check_duration_ms,
 		builder_max_steps_hits: state.builder_max_steps_hits,
 		final_verdict: state.verdict,
@@ -3721,6 +4161,18 @@ function all_gate_edits(archives) {
 	for (const archive of archives) for (const path of archive.changes?.gate_edits ?? []) edits.add(path);
 	return [...edits].toSorted();
 }
+/** An archived build's rung, or null for none, or one this volley doesn't
+* know. */
+function archived_rung(archive) {
+	const rung = archive.rung;
+	return EFFORT_RUNGS.includes(rung) ? rung : null;
+}
+/** Whether every build ran at one effort: each build's rung, or the provider's
+* own where the provider ignored it, taking one value across the run. */
+function ladder_flat(archives) {
+	const efforts = archives.map((archive) => archive.effort_ignored === true ? "ignored" : archived_rung(archive));
+	return new Set(efforts).size <= 1;
+}
 function salvage_stats(archives) {
 	let tool_calls = 0;
 	let salvaged_tool_calls = 0;
@@ -3750,13 +4202,17 @@ function build_run_summary(config, result) {
 			total_cost_usd: result.total_cost_usd,
 			builder_cost_usd: result.builder_cost_usd,
 			critic_cost_usd: result.critic_cost_usd,
+			tester_cost_usd: result.tester_cost_usd,
+			tester_passed_early: result.status === "tester_passed_early",
 			final_verdict: result.final_verdict,
 			check_trajectory: check_trajectory(archives),
 			gate_edits: all_gate_edits(archives),
 			unmet_criteria: archives.at(-1)?.unmet_criteria ?? [],
 			local_salvage: salvage_stats(archives),
 			critic_degraded: any_critic_degraded(archives),
-			critic_degrade_causes: critic_degrade_causes(archives)
+			critic_degrade_causes: critic_degrade_causes(archives),
+			rungs: config.mode === "critique" ? [] : archives.map(archived_rung),
+			ladder_flat: config.mode === "critique" || ladder_flat(archives)
 		}
 	};
 }
@@ -3766,6 +4222,183 @@ function write_run_summary(config, result) {
 	writeFileSync(state_path(config, "summary.json"), `${JSON.stringify(build_run_summary(config, result), null, 2)}\n`);
 }
 //#endregion
+//#region src/tester/prompt.ts
+/**
+* The tester's prompts: its system prompt, the `tester.md` preset and a line
+* naming the tools its seat holds, and the prompt of its one call, composed
+* from the criteria, where it may write, the check that will run its test, and
+* the workspace inventory.
+*
+* The tester writes from the criteria rather than the task (move 1's Frame): a
+* critic can be argued with about prose criteria, a test can't, so the test
+* is the criteria made executable. The inventory saves its first turns on
+* finding where the tests live.
+*/
+/** Walk up from this module to the package root (works from src/ under tsx
+* and from dist/ in the published package, which ships src/tester/presets). */
+function tester_presets_dir() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let depth = 0; depth < 6; depth += 1) {
+		const candidate = join(dir, "src", "tester", "presets");
+		if (existsSync(candidate)) return candidate;
+		const local = join(dir, "presets");
+		if (existsSync(join(local, "tester.md"))) return local;
+		dir = dirname(dir);
+	}
+	throw config_error("tester presets directory not found");
+}
+/** The tools a tester on `provider` holds, as its system prompt names them:
+* the Claude CLI's own, under the tester's permission list, fascicle's under
+* `volley acp`, whose writes ask the person in the editor first, or
+* volley's. */
+function tools_paragraph(provider, tool_set) {
+	if (provider === "claude_cli") return [
+		"Read the workspace with Read, Grep and Glob. Write and Edit work only on the",
+		"paths your prompt lists as writable, and are refused anywhere else. You",
+		"cannot run commands."
+	].join("\n");
+	if (tool_set === "acp") return [
+		"You have five tools, every path relative to the workspace root:",
+		"- read_file, list_files and search read the workspace.",
+		"- write_file(path, content) and edit_file(path, old_text, new_text) write",
+		"  only the paths your prompt lists as writable; anywhere else they refuse,",
+		"  naming why. The person in the editor may be asked before each write, and",
+		"  a write they decline is not made.",
+		"You cannot run commands; no other tools are available to you."
+	].join("\n");
+	return [
+		"You have five tools, every path workspace-relative:",
+		"- read_file(path), search_files(pattern, path?, ignore_case?) and",
+		"  list_files(path?, contains?) read the workspace.",
+		"- write_file(path, content) and edit_file(path, old_str, new_str) write",
+		"  only the paths your prompt lists as writable; anywhere else they refuse,",
+		"  naming why.",
+		"You cannot run commands; no other tools are available to you."
+	].join("\n");
+}
+/** The tester's system prompt for a seat on `provider` holding `tool_set`. */
+function resolve_tester_prompt(provider, tool_set = "volley") {
+	return `${readFileSync(join(tester_presets_dir(), "tester.md"), "utf8").trimEnd()}\n\n${tools_paragraph(provider, tool_set)}`;
+}
+function compose_tester_prompt(input) {
+	const check = input.check === "auto" ? "checkride, found by --check auto" : `\`${input.check}\``;
+	return [
+		"ACCEPTANCE CRITERIA",
+		"-------------------",
+		input.criteria,
+		"",
+		"WHERE YOU MAY WRITE",
+		"-------------------",
+		"Paths matching these patterns, except package.json, *.config.* files and",
+		"anything under .github/:",
+		...input.writable.map((pattern) => `  ${pattern}`),
+		"",
+		"THE CHECK",
+		"---------",
+		`${check} runs once you finish. It must fail then, on your test.`,
+		"",
+		"WORKSPACE FILE INVENTORY",
+		"------------------------",
+		input.inventory,
+		"",
+		"Write the failing test now."
+	].join("\n");
+}
+//#endregion
+//#region src/tester/run.ts
+/**
+* The tester seat: one session before the first build that writes a failing
+* test from the criteria under the test and fixture gate paths (move 1's D5,
+* D20). It takes the critic's provider, URL and effort, and the critic's model
+* unless `--tester-model` names one (D7, D15), since writing the right test is
+* reading work and the critic seat is on every run.
+*
+* Confinement is per provider, as the critic's is. A `claude_cli` tester runs
+* under its own permission list (`tester_allowed_tools`,
+* `TESTER_DISALLOWED_TOOLS`) in the CLI's default mode; every other tester gets
+* volley's `tester_tools`, with no shell. This module builds the call and the
+* dry run's probe of it; the flow runs it.
+*/
+/** The tester's step budget on a tool-loop provider: reading the workspace,
+* then a test file or two. Its own constant, so a change to the builder's or
+* fascicle's default can't move it. */
+const TESTER_MAX_STEPS = 30;
+/** One write a turn, as a local builder makes by default: some model and
+* runtime pairs return parallel calls badly. Reads don't count. */
+const TESTER_MAX_TOOL_CALLS = 1;
+/** The model the tester runs: `--tester-model`, else the critic's. */
+function tester_model(config) {
+	return config.tester_model ?? config.critic_model;
+}
+/** The tester's tool wiring for its provider. */
+function tester_tool_options(config, deps) {
+	const { tools } = deps;
+	if (config.critic_provider === "claude_cli") return { provider_options: { claude_cli: {
+		allowed_tools: tester_allowed_tools(writable_gate_patterns(config.gate_paths)),
+		extra_args: [
+			"--disallowedTools",
+			TESTER_DISALLOWED_TOOLS,
+			...settings_args()
+		]
+	} } };
+	return {
+		tools: tools === void 0 ? tester_tools(build_root(config.workspace, config.worktree), config.gate_paths) : [...tools],
+		...deps.on_tool_approval !== void 0 ? { on_tool_approval: deps.on_tool_approval } : {},
+		max_steps: TESTER_MAX_STEPS,
+		tool_error_policy: "feed_back",
+		max_tool_calls_per_step: TESTER_MAX_TOOL_CALLS
+	};
+}
+/** The tester's one call: its system prompt, its tools, the critic's effort. */
+function make_tester_step(deps) {
+	const { config } = deps;
+	return model_call({
+		engine: deps.engine,
+		id: "tester",
+		description: "model call writing a failing test under the test and fixture gate paths",
+		provider: config.critic_provider,
+		model: tester_model(config),
+		system: resolve_tester_prompt(config.critic_provider, deps.tool_set),
+		on_chunk: deps.on_chunk,
+		...config.critic_effort !== null ? { effort: config.critic_effort } : {},
+		...tester_tool_options(config, deps)
+	});
+}
+/** The prompt of the tester's call, from the run's criteria, writable
+* patterns, check, and the build root as it stands. */
+function tester_prompt(config) {
+	return compose_tester_prompt({
+		criteria: config.criteria,
+		writable: writable_gate_patterns(config.gate_paths),
+		check: config.check,
+		inventory: workspace_inventory(build_root(config.workspace, config.worktree))
+	});
+}
+/** Run the tester's session on the iteration `state` opened, folding its
+* record and spend into the state as `tester` (D21). A failure is a phase
+* error of its own, which exits as a provider error does. */
+async function run_tester(tester, config, state, ctx) {
+	try {
+		if (config.critic_provider === "ollama") await prewarm_ollama_model(seat_base_url("ollama", config.critic_url, process.env), tester_model(config), ctx.abort);
+		const tested = accumulate(state, "tester", await ctx.call(tester, tester_prompt(config)), tester_model(config));
+		if (config.critic_effort === null || !ignores_effort(config.critic_provider)) return tested;
+		return tested.tester === null ? tested : {
+			...tested,
+			tester: {
+				...tested.tester,
+				effort_ignored: true
+			}
+		};
+	} catch (err) {
+		throw phase_error("tester", state.iteration, err);
+	}
+}
+[
+	"CANARY CHECK: a tiny wiring probe, not a real task. Write nothing.",
+	"Call the read_file tool on the path \"package.json\", then, whatever it",
+	"returns, reply with the one word \"canary\"."
+].join("\n");
+//#endregion
 //#region src/phases.ts
 /**
 * The step bodies behind the nodes of `./flow.ts`, one function per node. Each
@@ -3879,7 +4512,10 @@ function next_iteration(s) {
 		critic: null,
 		check: null,
 		verdict: null,
-		unmet_criteria: []
+		unmet_criteria: [],
+		tester: null,
+		tester_check: null,
+		tester_changes: null
 	};
 }
 /** What the builder of the iteration after `s` hears about it beyond the
@@ -3898,29 +4534,102 @@ function previous_round(config, s) {
 * builder's work this way after every build, and a critique measures the
 * change under review the same way, so the critic is shown one shape either
 * way. */
-function measure_changes(deps, root) {
+function measure_changes(deps, root, tester_hashes = {}) {
 	const { config, renderer } = deps;
-	const changes = collect_changes({
-		root,
-		baseline: deps.baseline,
-		gate_patterns: config.gate_paths,
-		excluded_dir: state_root_within(root, config.state_dir)
-	});
+	const changes = without_tester_edits(collect_changes(change_options(deps, root)), root, tester_hashes);
 	report_changes(config, renderer, changes);
 	return changes;
 }
-/** `build`: one builder session edits the build root, then volley measures what
-* it changed and, under `--git`, checkpoints it. */
-async function build_phase(deps, builder, s, ctx) {
+/** How the build root's changes are collected: from the run's baseline,
+* against the gate, leaving out a state root inside it. */
+function change_options(deps, root) {
+	return {
+		root,
+		baseline: deps.baseline,
+		gate_patterns: deps.config.gate_paths,
+		excluded_dir: state_root_within(root, deps.config.state_dir)
+	};
+}
+/** The next build counted, with the rung it runs at and why that rung is
+* above the last build's, read off the state the last build left. */
+function climb(config, s, next) {
+	const builds = s.builds + 1;
+	return {
+		...next,
+		builds,
+		rung: rung_for_build(config.effort_ladder, builds),
+		climbed: climb_reason(config.effort_ladder, builds, s)
+	};
+}
+/** `test`: the tester opens iteration 1 and writes its failing test, then
+* volley records what it wrote, by hash, and under `--git` checkpoints it, so
+* the build that follows is measured apart from it (move 1's D9, D22). */
+async function test_phase(deps, tester, s, ctx) {
 	const { config, renderer } = deps;
 	const next = next_iteration(s);
 	emit(ctx, {
-		volley: "round_start",
+		volley: "test_start",
 		round: next.iteration
 	});
+	renderer.phase_start(next.iteration, "tester");
+	const root = build_root(config.workspace, config.worktree);
+	const before = snapshot_changes(change_options(deps, root));
+	const tested = await run_tester(tester, config, next, ctx);
+	renderer.phase_end(tested.iteration, "tester", true);
+	renderer.cost_line(tested.iteration, "tester", tested.tester?.cost_usd ?? null, tested.total_cost_usd);
+	if (tested.cost_warned && !s.cost_warned) renderer.warn("cost unavailable for this phase; recording null (run totals sum what is known)");
+	const written = tester_written(change_options(deps, root), before);
+	if (written.changes !== null) {
+		const paths = written.changes.files.map((file) => file.path);
+		renderer.info(paths.length === 0 ? "tester: wrote no file" : `tester: wrote ${String(paths.length)} file(s): ${paths.join(", ")}`);
+	}
+	if (config.git_checkpoints) git_checkpoint(root, `volley iter ${String(tested.iteration)}: test`, state_root_within(root, config.state_dir));
+	return {
+		...tested,
+		tester_changes: written.changes,
+		tester_hashes: written.hashes
+	};
+}
+/** `red_check`: the check right after the tester, which must fail on its
+* test. It's recorded apart from the check after the build. A pass ends the
+* run before any build, at the loop guard (D6). */
+async function red_check_phase(deps, s, ctx) {
+	const checked = await check_phase(deps, s, ctx);
+	const result = checked.check;
+	if (result?.ok === true) deps.renderer.warn("the check passed on the tester's test before any build: the test is vacuous, or the work is already done. Ending the run with no build (tester_passed_early, exit 2).");
+	else deps.renderer.info("the check fails on the tester's test, as it must; building");
+	return {
+		...checked,
+		check: null,
+		tester_check: result
+	};
+}
+/** `skip_red`: the tester alone crossed the cost cap, so the check is recorded
+* as skipped, and the guard halts the run on the cap with no build (D21). */
+function skip_red_phase(deps, s) {
+	deps.renderer.warn("cost cap crossed during the tester; skipping the check, the build and the critic");
+	return {
+		...s,
+		tester_check: skipped_check("cost_cap")
+	};
+}
+/** `build`: one builder session at the build's rung edits the build root, then
+* volley measures what it changed, its tester's untouched test aside, and,
+* under `--git`, checkpoints it. It opens the iteration, unless the tester
+* already did. */
+async function build_phase(deps, builders, s, ctx) {
+	const { config, renderer } = deps;
+	const opened = tester_opened(s);
+	const next = climb(config, s, opened ? s : next_iteration(s));
+	emit(ctx, {
+		volley: "round_start",
+		round: next.iteration,
+		...opened ? { after_test: true } : {}
+	});
 	renderer.phase_start(next.iteration, "builder");
+	if (next.rung !== null) renderer.rung(next.iteration, next.rung, next.climbed);
 	const built = await run_builder({
-		builder,
+		builder: builders.at(next.rung),
 		config,
 		warn: renderer.warn
 	}, next, previous_round(config, s), ctx);
@@ -3928,7 +4637,7 @@ async function build_phase(deps, builder, s, ctx) {
 	renderer.cost_line(built.iteration, "builder", built.builder?.cost_usd ?? null, built.total_cost_usd);
 	if (built.cost_warned && !s.cost_warned) renderer.warn("cost unavailable for this phase; recording null (run totals sum what is known)");
 	const root = build_root(config.workspace, config.worktree);
-	const changes = measure_changes(deps, root);
+	const changes = measure_changes(deps, root, built.tester_hashes);
 	if (config.git_checkpoints) git_checkpoint(root, `volley iter ${String(built.iteration)}: build`, state_root_within(root, config.state_dir));
 	return {
 		...built,
@@ -4077,6 +4786,12 @@ function record_phase(deps, s) {
 * around the flow (workspace setup, the worktree lifecycle, `run`, the final
 * summary) in `./orchestrator.ts`.
 *
+* With `--tester on`, the run's first iteration opens with the test phase: the
+* tester writes a failing test, then the check must fail on it. A green check
+* there, or a tester that crossed the cost cap, holds the iteration with no
+* build, and the guard ends the run. Every other iteration, and every run with
+* the tester off, passes through `test` and `work` to today's build and verify.
+*
 * A critique (`build_critique_flow`) is one round over a change already made,
 * so it has no builder, no loop, and no guard: `measure`, which opens the
 * round and measures the change from its baseline, then the same `check`,
@@ -4086,22 +4801,33 @@ function record_phase(deps, s) {
 * `test/unit/flow_diagram.test.ts` holds it to the code: change a row by changing
 * its step's `description`, then paste `pnpm diagram --prefix ' *   '` over it.
 *
-*   volley                                loop: one round per iteration, up to max_iterations
-*   ├─ iteration                          sequence
-*   │  ├─ build                           open the iteration, run the builder, measure the change
-*   │  │  └─ builder                      model call: one agentic session in the build root
-*   │  ├─ verify                          branch: did the build alone cross the cost cap?
-*   │  │  ├─ then  skip_verify            record the check as skipped and call no critic
+*   volley                                      loop: one round per iteration, up to max_iterations
+*   ├─ iteration                                sequence
+*   │  ├─ test                                  branch: does the tester open this iteration? (--tester on, the run's first)
+*   │  │  ├─ then  sequence
+*   │  │  │  ├─ write_test                      open the iteration, run the tester, record what it wrote
+*   │  │  │  │  └─ tester                       model call writing a failing test under the test and fixture gate paths
+*   │  │  │  └─ red                             branch: did the tester alone cross the cost cap?
+*   │  │  │     ├─ then  skip_red               record the check as skipped and build nothing
+*   │  │  │     └─ else  red_check              the check, which must fail on the tester's test
+*   │  │  └─ else  no_test                      no tester this iteration
+*   │  ├─ work                                  branch: did the test phase end the run: a green check, or the cost cap?
+*   │  │  ├─ then  hold                         build nothing, and leave the run to the guard
 *   │  │  └─ else  sequence
-*   │  │     ├─ check                     the deterministic gate: checkride, a command, or none
-*   │  │     └─ critique                  the read-only critic's verdict and feedback
-*   │  │        └─ critic                 fallback: judge without tools if a critic on any provider but claude_cli keeps dying or runs out of steps
-*   │  │           ├─ retry               one more try after a stream death, on any provider but claude_cli
-*   │  │           │  └─ critic_tools     model call with read-only workspace tools
-*   │  │           └─ pipe                mark the verdict degraded
-*   │  │              └─ critic_toolless  model call judging from the check output and a file list
-*   │  └─ record                          archive the iteration and rewrite the run summary
-*   └─ guard  gate                        stop on approval over a green check, the cost cap, or a gate edit
+*   │  │     ├─ build                           open the iteration unless the tester did, run the builder, measure the change
+*   │  │     │  └─ builder                      model call: one agentic session in the build root
+*   │  │     └─ verify                          branch: did the build alone cross the cost cap?
+*   │  │        ├─ then  skip_verify            record the check as skipped and call no critic
+*   │  │        └─ else  sequence
+*   │  │           ├─ check                     the deterministic gate: checkride, a command, or none
+*   │  │           └─ critique                  the read-only critic's verdict and feedback
+*   │  │              └─ critic                 fallback: judge without tools if a critic on any provider but claude_cli keeps dying or runs out of steps
+*   │  │                 ├─ retry               one more try after a stream death, on any provider but claude_cli
+*   │  │                 │  └─ critic_tools     model call with read-only workspace tools
+*   │  │                 └─ pipe                mark the verdict degraded
+*   │  │                    └─ critic_toolless  model call judging from the check output and a file list
+*   │  └─ record                                archive the iteration and rewrite the run summary
+*   └─ guard  gate                              stop on approval over a green check, the cost cap, a gate edit, or a green check before any build
 */
 /** The critic arm: the degradation ladder. A critic on any provider but
 * `claude_cli` whose tool-bearing stream dies is retried at once (the death is
@@ -4143,17 +4869,52 @@ function critique_step(deps, seat) {
 function record_step(deps) {
 	return step("record", (s) => record_phase(deps, s), { description: "archive the iteration and rewrite the run summary" });
 }
+/** The test phase (move 1's D6, D17, D21): with the tester on, the run's
+* first iteration opens with the tester writing a failing test, then the
+* check, which must fail on it, unless the tester alone crossed the cost cap.
+* Every other iteration passes straight through. */
+function test_step(deps) {
+	const { config } = deps;
+	const tester = make_tester_step({
+		...deps.seats.tester ?? { engine: deps.seats.critic.engine },
+		config,
+		on_chunk: deps.renderer.tester_chunk
+	});
+	const write_test = step("write_test", (s, ctx) => test_phase(deps, tester, s, ctx), {
+		description: "open the iteration, run the tester, record what it wrote",
+		arm: tester
+	});
+	const red = branch({
+		name: "red",
+		description: "did the tester alone cross the cost cap?",
+		when: (s) => cost_cap_hit(config, s),
+		then: step("skip_red", (s) => skip_red_phase(deps, s), { description: "record the check as skipped and build nothing" }),
+		otherwise: step("red_check", (s, ctx) => red_check_phase(deps, s, ctx), { description: "the check, which must fail on the tester's test" })
+	});
+	return branch({
+		name: "test",
+		description: "does the tester open this iteration? (--tester on, the run's first)",
+		when: (s) => tester_opens(config, s),
+		then: sequence([write_test, red]),
+		otherwise: step("no_test", (s) => s, { description: "no tester this iteration" })
+	});
+}
+/** Whether the test phase ended the run before its build: the check passed on
+* the tester's test, or the tester crossed the cost cap. */
+function test_ended_run(config, s) {
+	return tester_opened(s) && (tester_passed_early(s) || cost_cap_hit(config, s));
+}
 function build_flow(deps, resume_from) {
 	const { config, renderer } = deps;
-	const builder = make_builder_step({
+	const builders = make_builder_ladder({
 		...deps.seats.builder,
 		config,
 		on_chunk: renderer.builder_chunk,
 		bash_executor: deps.bash_executor
 	});
-	const build = step("build", (s, ctx) => build_phase(deps, builder, s, ctx), {
-		description: "open the iteration, run the builder, measure the change",
-		arm: builder
+	const build = step("build", (s, ctx) => build_phase(deps, builders, s, ctx), {
+		description: "open the iteration unless the tester did, run the builder, measure the change",
+		arm: builders.arm
 	});
 	const skip_verify = step("skip_verify", (s) => skip_verify_phase(deps, s), { description: "record the check as skipped and call no critic" });
 	const check = check_step(deps);
@@ -4166,9 +4927,16 @@ function build_flow(deps, resume_from) {
 		then: skip_verify,
 		otherwise: sequence([check, critique])
 	});
+	const work = branch({
+		name: "work",
+		description: "did the test phase end the run: a green check, or the cost cap?",
+		when: (s) => test_ended_run(config, s),
+		then: step("hold", (s) => s, { description: "build nothing, and leave the run to the guard" }),
+		otherwise: sequence([build, verify])
+	});
 	const iteration = sequence([
-		build,
-		verify,
+		test_step(deps),
+		work,
 		record
 	], { name: "iteration" });
 	return loop({
@@ -4176,7 +4944,7 @@ function build_flow(deps, resume_from) {
 		description: "one round per iteration, up to max_iterations",
 		init: (input) => input.resume_from ?? initial_state(),
 		body: iteration,
-		guard: step("gate", (s) => gate(config, s), { description: "stop on approval over a green check, the cost cap, or a gate edit" }),
+		guard: step("gate", (s) => gate(config, s), { description: "stop on approval over a green check, the cost cap, a gate edit, or a green check before any build" }),
 		finish: (s, { converged }) => ({
 			value: s,
 			converged
@@ -4274,6 +5042,10 @@ async function run_loop(config, deps, resume_from, bash_executor, baseline) {
 			critic: {
 				...deps.seats?.critic,
 				engine: engines.critic
+			},
+			tester: {
+				...deps.seats?.tester,
+				engine: engines.critic
 			}
 		},
 		config,
@@ -4402,12 +5174,28 @@ function create_renderer(options) {
 	const see_trajectory = `see ${options.trajectory_path ?? "the run's trajectory.jsonl"}`;
 	const silent = mode === "json";
 	const streaming = mode === "default" || mode === "verbose";
+	const protocol = mode === "protocol";
 	let mid_line = false;
+	let current_iteration = 0;
+	let run_spend = 0;
 	const line = (text) => {
 		if (silent) return;
 		write(`${mid_line ? "\n" : ""}${text}\n`);
 		mid_line = false;
 	};
+	/** One of runciter's typed stderr lines (its spec §5.4), which it reads into
+	* the run's live state. */
+	const typed = (value) => {
+		line(JSON.stringify(value));
+	};
+	const progress = (n, message) => {
+		typed({
+			type: "runciter.progress",
+			message: `iteration ${String(n)}: ${message}`,
+			done: n - 1,
+			...options.max_iterations !== void 0 ? { total: options.max_iterations } : {}
+		});
+	};
 	const chunk_renderer = (role) => (chunk) => {
 		if (!streaming) return;
 		switch (chunk.kind) {
@@ -4442,18 +5230,39 @@ function create_renderer(options) {
 	return {
 		builder_chunk: chunk_renderer("builder"),
 		critic_chunk: chunk_renderer("critic"),
-		phase_start: (iteration, phase) => {
+		tester_chunk: chunk_renderer("tester"),
+		phase_start: (n, phase) => {
 			if (mode === "json") return;
-			line(paint(phase, `▶ [iter ${String(iteration)}] ${phase}`, color));
+			if (protocol) {
+				if (n > current_iteration && current_iteration > 0) typed({
+					type: "runciter.usage",
+					cost_usd: run_spend
+				});
+				current_iteration = Math.max(current_iteration, n);
+				progress(n, phase);
+				return;
+			}
+			line(paint(phase, `▶ [iter ${String(n)}] ${phase}`, color));
 		},
-		phase_end: (iteration, phase, ok, detail) => {
+		phase_end: (n, phase, ok, detail) => {
 			if (mode === "json") return;
+			if (protocol) {
+				progress(n, `${phase} ${detail ?? (ok ? "done" : "failed")}`);
+				return;
+			}
 			const glyph = ok ? "✓" : "✗";
 			const suffix = detail !== void 0 ? ` — ${detail}` : "";
-			line(paint(phase, `${glyph} [iter ${String(iteration)}] ${phase}${suffix}`, color));
+			line(paint(phase, `${glyph} [iter ${String(n)}] ${phase}${suffix}`, color));
+		},
+		rung: (iteration, rung, climbed) => {
+			line(paint("builder", `  [iter ${String(iteration)}] ${format_rung(rung, climbed)}`, color));
 		},
 		cost_line: (iteration, phase, phase_cost, run_total) => {
 			if (mode === "json") return;
+			if (protocol) {
+				run_spend = run_total;
+				return;
+			}
 			const cap = options.max_cost_usd !== null ? ` / ${format_usd(options.max_cost_usd)}` : "";
 			line(paint("cost", `${GLYPH_COST} [iter ${String(iteration)}] [${phase}] phase: ${format_usd(phase_cost)} | run: ${format_usd(run_total)}${cap}`, color));
 		},
@@ -4472,10 +5281,16 @@ function create_renderer(options) {
 		},
 		final_summary: (result) => {
 			if (silent) return;
+			if (protocol) typed({
+				type: "runciter.usage",
+				cost_usd: result.total_cost_usd,
+				input_tokens: result.total_usage.input_tokens,
+				output_tokens: result.total_usage.output_tokens
+			});
 			line("");
 			line(`run ${result.run_id}: ${result.status}`);
 			line(`iterations: ${String(result.iterations_completed)} | verdict: ${result.final_verdict ?? "n/a"}`);
-			line(paint("cost", `${GLYPH_COST} total: ${format_usd(result.total_cost_usd)} (builder ${format_usd(result.builder_cost_usd)}, critic ${format_usd(result.critic_cost_usd)})`, color));
+			line(paint("cost", `${GLYPH_COST} total: ${format_usd(result.total_cost_usd)} (builder ${format_usd(result.builder_cost_usd)}, critic ${format_usd(result.critic_cost_usd)}${result.tester_cost_usd > 0 ? `, tester ${format_usd(result.tester_cost_usd)}` : ""})`, color));
 			line(`tokens: ${String(result.total_usage.input_tokens)} in / ${String(result.total_usage.output_tokens)} out`);
 			line(`state: ${result.run_state_dir}`);
 		}
@@ -4679,7 +5494,8 @@ function exit_code_for_status(status) {
 	switch (status) {
 		case "success": return 0;
 		case "budget_exhausted":
-		case "rejected": return 2;
+		case "rejected":
+		case "tester_passed_early": return 2;
 		case "cost_cap_reached": return 7;
 		case "gate_edit_blocked": return 8;
 		case "interrupted": return 130;