@robmclarty/volley 0.5.1

package/dist/cli.js

@@ -0,0 +1,3405 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { cac } from "cac";
+
+// src/config.ts
+import { accessSync, constants, existsSync, readFileSync, statSync } from "fs";
+import { isAbsolute, resolve } from "path";
+import { pathToFileURL } from "url";
+import { randomUUID } from "crypto";
+
+// src/changes.ts
+import { spawnSync } from "child_process";
+var DEFAULT_GATE_PATTERNS = [
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*_test.*",
+  "**/test/**",
+  "**/tests/**",
+  "**/__tests__/**",
+  "**/spec/**",
+  "**/fixtures/**",
+  "**/checkride.config.*",
+  "**/vitest.config.*",
+  "**/jest.config.*",
+  "**/playwright.config.*",
+  "**/package.json",
+  ".github/workflows/**"
+];
+var EXCLUDED_PREFIXES = [".volley/", ".volley.bak.", ".check/", ".git/", "node_modules/"];
+var DEFAULT_LIMIT = 200;
+function git(root, args) {
+  try {
+    const result = spawnSync("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      maxBuffer: 32 * 1024 * 1024
+    });
+    return { status: result.status ?? -1, stdout: result.stdout ?? "" };
+  } catch {
+    return { status: -1, stdout: "" };
+  }
+}
+function in_git_repo(root) {
+  return git(root, ["rev-parse", "--git-dir"]).status === 0;
+}
+function capture_baseline(root) {
+  const head = git(root, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) return null;
+  const sha = head.stdout.trim();
+  return sha.length > 0 ? sha : null;
+}
+function change_status(code) {
+  const letter = code.charAt(0);
+  if (letter === "A") return "added";
+  if (letter === "M" || letter === "T") return "modified";
+  if (letter === "D") return "deleted";
+  if (letter === "R" || letter === "C") return "renamed";
+  return "unknown";
+}
+function parse_name_status(stdout) {
+  const tokens = stdout.split("\0").filter((token) => token.length > 0);
+  const changes = [];
+  let index = 0;
+  while (index < tokens.length) {
+    const code = tokens[index] ?? "";
+    const paired = code.startsWith("R") || code.startsWith("C");
+    const path = tokens[index + (paired ? 2 : 1)];
+    if (path !== void 0) changes.push({ path, status: change_status(code) });
+    index += paired ? 3 : 2;
+  }
+  return changes;
+}
+function parse_paths(stdout) {
+  return stdout.split("\0").filter((path) => path.length > 0);
+}
+function excluded(path) {
+  return EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix));
+}
+function glob_to_regexp(pattern) {
+  let source = "";
+  let index = 0;
+  while (index < pattern.length) {
+    const char = pattern.charAt(index);
+    if (char === "*" && pattern.charAt(index + 1) === "*") {
+      const slashed = pattern.charAt(index + 2) === "/";
+      source += slashed ? "(?:.*/)?" : ".*";
+      index += slashed ? 3 : 2;
+      continue;
+    }
+    if (char === "*") {
+      source += "[^/]*";
+      index += 1;
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      index += 1;
+      continue;
+    }
+    source += /[.+^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+    index += 1;
+  }
+  return new RegExp(`^${source}$`);
+}
+function matches_any(path, patterns) {
+  return patterns.some((pattern) => glob_to_regexp(pattern).test(path));
+}
+function by_path(left, right) {
+  if (left.path < right.path) return -1;
+  return left.path > right.path ? 1 : 0;
+}
+function collect_changes(options) {
+  const { root, baseline } = options;
+  if (!in_git_repo(root)) return null;
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const tracked = baseline === null ? [] : parse_name_status(
+    git(root, ["diff", "--name-status", "--relative", "-z", baseline, "--", "."]).stdout
+  );
+  const untracked = parse_paths(
+    git(root, ["ls-files", "--others", "--exclude-standard", "-z"]).stdout
+  ).map((path) => ({ path, status: "added" }));
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const change of [...tracked, ...untracked]) {
+    if (excluded(change.path) || seen.has(change.path)) continue;
+    seen.add(change.path);
+    files.push({ ...change, gate: matches_any(change.path, options.gate_patterns) });
+  }
+  const sorted = files.toSorted(by_path);
+  return {
+    baseline,
+    // Over the full list, before the cap: truncation must never hide a gate edit.
+    gate_edits: sorted.filter((file) => file.gate).map((file) => file.path),
+    total: sorted.length,
+    files: sorted.slice(0, limit),
+    truncated: sorted.length > limit
+  };
+}
+
+// src/types.ts
+function config_error(message) {
+  return Object.assign(new Error(message), { kind: "config_error" });
+}
+function check_error(message) {
+  return Object.assign(new Error(message), { kind: "check_error" });
+}
+function phase_error(phase, iteration, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return Object.assign(
+    new Error(`${phase} failed on iteration ${iteration}: ${detail}`),
+    { kind: "phase_error", phase, iteration, cause }
+  );
+}
+function error_kind(err) {
+  if (typeof err === "object" && err !== null && "kind" in err) {
+    const kind = err.kind;
+    return typeof kind === "string" ? kind : null;
+  }
+  return null;
+}
+
+// src/config.ts
+var DEFAULT_BUILDER_MODEL = "opus";
+var DEFAULT_CRITIC_MODEL = "opus";
+var DEFAULT_MAX_ITERATIONS = 10;
+var DEFAULT_BUILDER_MAX_STEPS = 50;
+var DEFAULT_CHECK = "auto";
+var DEFAULT_CRITIC = "reviewer";
+var DEFAULT_BUILDER_PROVIDER = "claude_cli";
+var DEFAULT_CRITIC_PROVIDER = "claude_cli";
+var DEFAULT_PERMISSION_MODE = "acceptEdits";
+var DEFAULT_SANDBOX_IMAGE = "volley-sandbox:latest";
+var BUILDER_PROVIDERS = [
+  "claude_cli",
+  "ollama",
+  "lmstudio"
+];
+var LOCAL_BUILDER_PROVIDERS = [
+  "ollama",
+  "lmstudio"
+];
+var CRITIC_PROVIDERS = [
+  "claude_cli",
+  "ollama",
+  "lmstudio"
+];
+var CRITIC_PRESETS = [
+  "reviewer",
+  "optimizer",
+  "researcher"
+];
+var PERMISSION_MODES = [
+  "acceptEdits",
+  "bypassPermissions"
+];
+function expand_at_file(value, cwd) {
+  if (!value.startsWith("@")) return value;
+  const path = resolve(cwd, value.slice(1));
+  if (!existsSync(path)) {
+    throw config_error(`file not found: ${path} (from ${value})`);
+  }
+  return readFileSync(path, "utf8");
+}
+function is_critic_preset(value) {
+  return CRITIC_PRESETS.includes(value);
+}
+async function load_config_file(path) {
+  const abs = resolve(path);
+  if (!existsSync(abs)) {
+    throw config_error(`config file not found: ${abs}`);
+  }
+  let loaded;
+  try {
+    const mod = await import(pathToFileURL(abs).href);
+    loaded = mod.default;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw config_error(`failed to load config file ${abs}: ${detail}`);
+  }
+  if (typeof loaded !== "object" || loaded === null) {
+    throw config_error(`config file ${abs} must default-export a VolleyConfig object`);
+  }
+  return loaded;
+}
+function validate_workspace(workspace) {
+  const abs = isAbsolute(workspace) ? workspace : resolve(workspace);
+  if (!existsSync(abs)) {
+    throw config_error(`workspace not found: ${abs}`);
+  }
+  if (!statSync(abs).isDirectory()) {
+    throw config_error(`workspace is not a directory: ${abs}`);
+  }
+  try {
+    accessSync(abs, constants.W_OK);
+  } catch {
+    throw config_error(`workspace not writable: ${abs}`);
+  }
+  return abs;
+}
+function resolve_critic(critic, cwd) {
+  if (is_critic_preset(critic)) {
+    return { critic_preset: critic, critic_prompt_path: null };
+  }
+  const path = resolve(cwd, critic);
+  if (!existsSync(path)) {
+    throw config_error(
+      `--critic must be one of ${CRITIC_PRESETS.join(", ")} or a path to a prompt file; got: ${critic}`
+    );
+  }
+  return { critic_preset: "custom", critic_prompt_path: path };
+}
+function resolve_builder_max_steps(raw, env) {
+  if (raw.builder_max_steps !== void 0) {
+    return validate_builder_max_steps(raw.builder_max_steps, raw.builder_max_steps);
+  }
+  const env_value = env["VOLLEY_BUILDER_MAX_STEPS"];
+  if (env_value !== void 0 && env_value !== "") {
+    return validate_builder_max_steps(Number(env_value), env_value);
+  }
+  return DEFAULT_BUILDER_MAX_STEPS;
+}
+function validate_builder_max_steps(value, original) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw config_error(
+      `--builder-max-steps / VOLLEY_BUILDER_MAX_STEPS must be a positive integer; got: ${String(original)}`
+    );
+  }
+  return value;
+}
+function resolve_sandbox_image(raw, env) {
+  if (raw.sandbox_image !== void 0 && raw.sandbox_image !== "") {
+    return raw.sandbox_image;
+  }
+  const env_value = env["VOLLEY_SANDBOX_IMAGE"];
+  if (env_value !== void 0 && env_value !== "") {
+    return env_value;
+  }
+  return DEFAULT_SANDBOX_IMAGE;
+}
+function resolve_allow_unsandboxed_builder(raw, env) {
+  if (raw.allow_unsandboxed_builder === true) return true;
+  const env_value = env["VOLLEY_ALLOW_UNSANDBOXED_BUILDER"];
+  return env_value === "1" || env_value === "true";
+}
+function detect_containment(env) {
+  const value = env["VOLLEY_CONTAINED"];
+  return value === "1" || value === "true";
+}
+function resolve_config(raw, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  if (typeof raw.prompt !== "string" || raw.prompt.length === 0) {
+    throw config_error("missing required option: --prompt");
+  }
+  if (typeof raw.workspace !== "string" || raw.workspace.length === 0) {
+    throw config_error("missing required option: --workspace");
+  }
+  if (typeof raw.criteria !== "string" || raw.criteria.length === 0) {
+    throw config_error("missing required option: --criteria");
+  }
+  const workspace = validate_workspace(resolve(cwd, raw.workspace));
+  const prompt = expand_at_file(raw.prompt, cwd);
+  const criteria = expand_at_file(raw.criteria, cwd);
+  const max_iterations = raw.max_iterations ?? DEFAULT_MAX_ITERATIONS;
+  if (!Number.isInteger(max_iterations) || max_iterations < 1) {
+    throw config_error(`--max-iterations must be a positive integer; got: ${String(raw.max_iterations)}`);
+  }
+  const max_cost_usd = raw.max_cost_usd ?? null;
+  if (max_cost_usd !== null && !(typeof max_cost_usd === "number" && max_cost_usd > 0)) {
+    throw config_error(`--max-cost-usd must be a positive number; got: ${String(raw.max_cost_usd)}`);
+  }
+  const builder_permission_mode = raw.builder_permission_mode ?? DEFAULT_PERMISSION_MODE;
+  if (!PERMISSION_MODES.includes(builder_permission_mode)) {
+    throw config_error(
+      `--builder-permission-mode must be one of ${PERMISSION_MODES.join(", ")}; got: ${String(raw.builder_permission_mode)}`
+    );
+  }
+  const { critic_preset, critic_prompt_path } = resolve_critic(
+    raw.critic ?? DEFAULT_CRITIC,
+    cwd
+  );
+  const builder_provider = raw.builder_provider ?? DEFAULT_BUILDER_PROVIDER;
+  if (!BUILDER_PROVIDERS.includes(builder_provider)) {
+    throw config_error(
+      `--builder-provider must be one of ${BUILDER_PROVIDERS.join(", ")}; got: ${String(raw.builder_provider)}`
+    );
+  }
+  const allow_unsandboxed_builder = resolve_allow_unsandboxed_builder(raw, env);
+  const contained = detect_containment(env);
+  if (LOCAL_BUILDER_PROVIDERS.includes(builder_provider) && !contained && !allow_unsandboxed_builder) {
+    throw config_error(
+      `builder-provider '${builder_provider}' runs a local model with a real bash (write + exec) \u2014 refused unless contained. Launch volley inside its sandbox container (docker run <hardened flags> <image> volley run \u2026, which sets VOLLEY_CONTAINED=1), or pass --allow-unsandboxed-builder (VOLLEY_ALLOW_UNSANDBOXED_BUILDER=1) to run uncontained on the host.`
+    );
+  }
+  const builder_max_steps = resolve_builder_max_steps(raw, env);
+  const critic_provider = raw.critic_provider ?? DEFAULT_CRITIC_PROVIDER;
+  if (!CRITIC_PROVIDERS.includes(critic_provider)) {
+    throw config_error(
+      `--critic-provider must be one of ${CRITIC_PROVIDERS.join(", ")}; got: ${String(raw.critic_provider)}`
+    );
+  }
+  if (contained) {
+    const claude_roles = [
+      builder_provider === "claude_cli" ? "builder" : null,
+      critic_provider === "claude_cli" ? "critic" : null
+    ].filter((role) => role !== null);
+    const auth_mode = env["VOLLEY_AUTH_MODE"] ?? "auto";
+    if (claude_roles.length > 0 && auth_mode !== "api_key") {
+      throw config_error(
+        `claude_cli (${claude_roles.join(", ")}) cannot use its subscription/OAuth token inside a container \u2014 it is mangled there. Set VOLLEY_AUTH_MODE=api_key (with ANTHROPIC_API_KEY) to drive Claude contained, or run claude_cli on the host uncontained.`
+      );
+    }
+  }
+  if (raw.git_checkpoints === true && !existsSync(resolve(workspace, ".git"))) {
+    throw config_error(`--git requires the workspace to be a git repository: ${workspace}`);
+  }
+  const worktree = raw.worktree ?? false;
+  if (worktree && !existsSync(resolve(workspace, ".git"))) {
+    throw config_error(`--worktree requires the workspace to be a git repository: ${workspace}`);
+  }
+  const discard_worktree = raw.discard_worktree ?? false;
+  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 sandbox_image = resolve_sandbox_image(raw, env);
+  return {
+    version: 2,
+    run_id: options.run_id ?? randomUUID(),
+    started_at: options.started_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    prompt,
+    criteria,
+    check: raw.check ?? DEFAULT_CHECK,
+    check_resolved: "none",
+    builder_model: raw.builder_model ?? DEFAULT_BUILDER_MODEL,
+    builder_provider,
+    builder_max_steps,
+    allow_unsandboxed_builder,
+    critic_model: raw.critic_model ?? DEFAULT_CRITIC_MODEL,
+    critic_provider,
+    builder_permission_mode,
+    critic_preset,
+    critic_prompt_path,
+    max_iterations,
+    max_cost_usd,
+    git_checkpoints: raw.git_checkpoints ?? false,
+    worktree,
+    discard_worktree,
+    gate_paths: [...gate_paths],
+    fail_on_gate_edit: raw.fail_on_gate_edit ?? false,
+    sandbox_image,
+    workspace,
+    verbose: raw.verbose ?? false,
+    quiet: raw.quiet ?? false,
+    json: raw.json ?? false,
+    show_thinking: raw.show_thinking ?? true
+  };
+}
+
+// src/check/detect.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+function package_check_script_is_checkride(workspace) {
+  const path = join(workspace, "package.json");
+  if (!existsSync2(path)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync2(path, "utf8"));
+    const script = pkg.scripts?.["check"];
+    return typeof script === "string" && /(^|\s)checkride(\s|$)/.test(script);
+  } catch {
+    return false;
+  }
+}
+function checkride_detected(workspace) {
+  return existsSync2(join(workspace, "checkride.config.json")) || package_check_script_is_checkride(workspace) || existsSync2(join(workspace, "node_modules", ".bin", "checkride"));
+}
+function resolve_check_runner(check, workspace) {
+  if (check === "none") return "none";
+  if (check === "auto") {
+    return checkride_detected(workspace) ? "checkride" : "none";
+  }
+  return /(^|\s)checkride(\s|$)/.test(check.trim()) ? "checkride" : "command";
+}
+
+// src/exit_codes.ts
+var EXIT_SUCCESS = 0;
+var EXIT_BUDGET_EXHAUSTED = 2;
+var EXIT_BUILDER_ERROR = 3;
+var EXIT_CHECK_ERROR = 4;
+var EXIT_CONFIG_ERROR = 5;
+var EXIT_CRITIC_ERROR = 6;
+var EXIT_COST_CAP = 7;
+var EXIT_GATE_EDIT = 8;
+var EXIT_INTERRUPTED = 130;
+function exit_code_for_status(status) {
+  switch (status) {
+    case "success":
+      return EXIT_SUCCESS;
+    case "budget_exhausted":
+      return EXIT_BUDGET_EXHAUSTED;
+    case "cost_cap_reached":
+      return EXIT_COST_CAP;
+    case "gate_edit_blocked":
+      return EXIT_GATE_EDIT;
+    case "interrupted":
+      return EXIT_INTERRUPTED;
+    default:
+      return EXIT_BUILDER_ERROR;
+  }
+}
+var PROVIDER_ERROR_KINDS = /* @__PURE__ */ new Set([
+  "provider_error",
+  "provider_auth_error",
+  "provider_not_configured_error",
+  "provider_capability_error",
+  "claude_cli_error",
+  "rate_limit_error",
+  "engine_disposed_error",
+  "timeout_error"
+]);
+function exit_code_for_error(err) {
+  const kind = error_kind(err);
+  if (kind === "aborted_error") return EXIT_INTERRUPTED;
+  if (kind === "config_error" || kind === "engine_config_error") {
+    return EXIT_CONFIG_ERROR;
+  }
+  if (kind === "check_error") return EXIT_CHECK_ERROR;
+  if (kind === "schema_validation_error") return EXIT_CRITIC_ERROR;
+  if (kind === "phase_error") {
+    const phase = err.phase;
+    const cause_kind = error_kind(err.cause);
+    if (cause_kind === "aborted_error") return EXIT_INTERRUPTED;
+    if (phase === "critic") return EXIT_CRITIC_ERROR;
+    if (phase === "check") return EXIT_CHECK_ERROR;
+    return EXIT_BUILDER_ERROR;
+  }
+  if (kind !== null && PROVIDER_ERROR_KINDS.has(kind)) {
+    return EXIT_BUILDER_ERROR;
+  }
+  return EXIT_BUILDER_ERROR;
+}
+
+// src/iteration.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, join as join3 } from "path";
+
+// src/cost.ts
+var EMPTY_USAGE = { input_tokens: 0, output_tokens: 0 };
+function add_usage(a, b) {
+  const sum = {
+    input_tokens: a.input_tokens + b.input_tokens,
+    output_tokens: a.output_tokens + b.output_tokens
+  };
+  const optional = ["cached_input_tokens", "cache_write_tokens", "reasoning_tokens"];
+  for (const key of optional) {
+    const total = (a[key] ?? 0) + (b[key] ?? 0);
+    if (a[key] !== void 0 || b[key] !== void 0) sum[key] = total;
+  }
+  return sum;
+}
+function cost_source_of(result) {
+  if (result.cost === void 0) return "unknown";
+  return result.model_resolved.provider === "claude_cli" ? "provider_reported" : "engine_derived";
+}
+function session_of(result) {
+  const reported = result.provider_reported?.["claude_cli"];
+  return {
+    session_id: typeof reported?.session_id === "string" ? reported.session_id : null,
+    duration_ms: typeof reported?.duration_ms === "number" ? reported.duration_ms : 0
+  };
+}
+function phase_record(result, model) {
+  const { session_id, duration_ms } = session_of(result);
+  return {
+    provider: result.model_resolved.provider,
+    model,
+    session_id,
+    duration_ms,
+    usage: result.usage,
+    cost_usd: result.cost?.total_usd ?? null,
+    cost_source: cost_source_of(result),
+    finish_reason: result.finish_reason,
+    tool_calls: result.tool_calls.length,
+    salvaged_tool_calls: result.tool_calls.filter((call) => call.salvaged === true).length
+  };
+}
+function accumulate(state, role, result, model) {
+  const record = phase_record(result, model);
+  const cost = record.cost_usd ?? 0;
+  return {
+    ...state,
+    [role]: record,
+    total_usage: add_usage(state.total_usage, result.usage),
+    total_cost_usd: state.total_cost_usd + cost,
+    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),
+    cost_warned: state.cost_warned || record.cost_usd === null
+  };
+}
+function cost_cap_hit(config, state) {
+  return config.max_cost_usd !== null && state.total_cost_usd >= config.max_cost_usd;
+}
+
+// src/workspace.ts
+import { existsSync as existsSync3, mkdirSync, renameSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+function volley_path(workspace, ...parts) {
+  return join2(workspace, ".volley", ...parts);
+}
+function iteration_dir(workspace, iteration) {
+  return volley_path(workspace, "iterations", String(iteration).padStart(3, "0"));
+}
+function backup_stamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function initialize_workspace(workspace, options = {}) {
+  const dir = volley_path(workspace);
+  if (existsSync3(dir) && options.preserve !== true) {
+    renameSync(dir, join2(workspace, `.volley.bak.${backup_stamp()}`));
+  }
+  mkdirSync(volley_path(workspace, "iterations"), { recursive: true });
+}
+function write_resolved_config(config) {
+  const record = {
+    version: config.version,
+    run_id: config.run_id,
+    started_at: config.started_at,
+    prompt: config.prompt,
+    criteria: config.criteria,
+    check: config.check,
+    check_resolved: config.check_resolved,
+    builder_model: config.builder_model,
+    builder_provider: config.builder_provider,
+    builder_max_steps: config.builder_max_steps,
+    critic_model: config.critic_model,
+    critic_provider: config.critic_provider,
+    builder_permission_mode: config.builder_permission_mode,
+    critic_preset: config.critic_preset,
+    critic_prompt_path: config.critic_prompt_path,
+    max_iterations: config.max_iterations,
+    max_cost_usd: config.max_cost_usd,
+    git_checkpoints: config.git_checkpoints,
+    worktree: config.worktree,
+    discard_worktree: config.discard_worktree,
+    gate_paths: config.gate_paths,
+    fail_on_gate_edit: config.fail_on_gate_edit,
+    sandbox_image: config.sandbox_image,
+    workspace: config.workspace
+  };
+  writeFileSync(
+    volley_path(config.workspace, "config.json"),
+    `${JSON.stringify(record, null, 2)}
+`
+  );
+}
+function git_checkpoint(root, message) {
+  if (!existsSync3(join2(root, ".git"))) {
+    throw config_error(`git checkpoints require a git repository: ${root}`);
+  }
+  const add = spawnSync2("git", ["add", "-A"], { cwd: root });
+  if (add.error !== void 0 || add.status !== 0) {
+    throw check_error(`git add failed: ${add.stderr?.toString() ?? String(add.error)}`);
+  }
+  const commit = spawnSync2("git", ["commit", "-m", message, "--no-verify"], {
+    cwd: root
+  });
+  if (commit.error !== void 0) {
+    throw check_error(`git commit failed to start: ${String(commit.error)}`);
+  }
+  const out = `${commit.stdout?.toString() ?? ""}${commit.stderr?.toString() ?? ""}`;
+  if (commit.status !== 0 && !out.includes("nothing to commit")) {
+    throw check_error(`git commit failed: ${out.trim()}`);
+  }
+}
+function integrate_worktree(workspace, branch, message) {
+  if (!existsSync3(join2(workspace, ".git"))) {
+    throw config_error(`--worktree integration requires a git repository: ${workspace}`);
+  }
+  const squash = spawnSync2("git", ["merge", "--squash", branch], {
+    cwd: workspace,
+    encoding: "utf8"
+  });
+  if (squash.error !== void 0) {
+    throw check_error(`git merge --squash failed to start: ${String(squash.error)}`);
+  }
+  if (squash.status !== 0) {
+    throw check_error(
+      `git merge --squash ${branch} failed: ${(squash.stderr || squash.stdout).trim()}`
+    );
+  }
+  const commit = spawnSync2("git", ["commit", "-m", message, "--no-verify"], {
+    cwd: workspace,
+    encoding: "utf8"
+  });
+  if (commit.error !== void 0) {
+    throw check_error(`git commit failed to start: ${String(commit.error)}`);
+  }
+  const out = `${commit.stdout ?? ""}${commit.stderr ?? ""}`;
+  if (commit.status !== 0 && !out.includes("nothing to commit")) {
+    throw check_error(`git commit failed: ${out.trim()}`);
+  }
+}
+
+// src/iteration.ts
+function write_json(path, value) {
+  writeFileSync2(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function persist_verdict_files(workspace, feedback, verdict) {
+  writeFileSync2(volley_path(workspace, "feedback.md"), feedback.endsWith("\n") ? feedback : `${feedback}
+`);
+  writeFileSync2(volley_path(workspace, "verdict"), `${verdict}
+`);
+}
+function phase_summary(record) {
+  if (record === null) return null;
+  return {
+    provider: record.provider,
+    model: record.model,
+    session_id: record.session_id,
+    duration_ms: record.duration_ms,
+    usage: record.usage,
+    cost_usd: record.cost_usd,
+    cost_source: record.cost_source,
+    finish_reason: record.finish_reason,
+    tool_calls: record.tool_calls,
+    salvaged_tool_calls: record.salvaged_tool_calls,
+    // Salvage rate (a health metric): the share of tool calls recovered from
+    // assistant text. A high rate on a local run means the model's native
+    // tool-call encoding is drifting from its runtime's parser (pin them as one
+    // unit). 0 when the phase made no tool calls (the CLI builder's own loop).
+    salvage_rate: record.tool_calls === 0 ? 0 : record.salvaged_tool_calls / record.tool_calls,
+    // Degradation-ladder bookkeeping, critic-only: the provider-error
+    // retries that preceded this verdict, their cause, and whether it was rendered
+    // by the tool-less fallback. Emitted only when set, so the builder record and
+    // old summary consumers are untouched. `critic_degraded` is the on-disk
+    // half of the contract — the comparison block reads it back from here.
+    ...record.retries !== void 0 ? { retries: record.retries } : {},
+    ...record.retry_cause_kind !== void 0 ? { retry_cause_kind: record.retry_cause_kind } : {},
+    ...record.critic_degraded === true ? { critic_degraded: true } : {}
+  };
+}
+function archive_iteration(config, state) {
+  const dir = iteration_dir(config.workspace, state.iteration);
+  mkdirSync2(join3(dir, "check"), { recursive: true });
+  if (state.verdict !== null && state.feedback !== null) {
+    persist_verdict_files(config.workspace, state.feedback, state.verdict);
+    writeFileSync2(join3(dir, "feedback.md"), readFileSync3(volley_path(config.workspace, "feedback.md")));
+    writeFileSync2(join3(dir, "verdict"), `${state.verdict}
+`);
+  }
+  const check = state.check;
+  if (check !== null && check.ran) {
+    if (check.runner === "checkride") {
+      if (check.summary !== void 0) {
+        write_json(join3(dir, "check", "summary.json"), check.summary);
+      }
+      for (const artifact of check.detail) {
+        if (artifact.path !== null && existsSync4(artifact.path)) {
+          writeFileSync2(join3(dir, "check", basename(artifact.path)), readFileSync3(artifact.path));
+        }
+      }
+    } else {
+      writeFileSync2(join3(dir, "check", "check.log"), check.log ?? "");
+      writeFileSync2(join3(dir, "check", "check.exit"), `${String(check.exit_code)}
+`);
+    }
+  }
+  const completed_at = (/* @__PURE__ */ new Date()).toISOString();
+  write_json(join3(dir, "summary.json"), {
+    iteration: state.iteration,
+    started_at: state.iteration_started_at,
+    completed_at,
+    duration_ms: Date.parse(completed_at) - Date.parse(state.iteration_started_at),
+    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
+    },
+    critic: phase_summary(state.critic),
+    // What the builder reached for this iteration (`src/changes.ts`), archived
+    // beside the check's verdict so the two can be read against each other after
+    // the fact: green + a gate edit is a different result from green alone.
+    // Null when the build root is not a git repository. Additive.
+    changes: state.changes,
+    verdict: state.verdict,
+    // The criteria the critic judged unmet, verbatim. The run-level summary
+    // reads the last iteration's list, so a non-converged run says what it was
+    // still missing when it stopped instead of only that it stopped. Additive.
+    unmet_criteria: state.unmet_criteria,
+    iteration_cost_usd: state.iteration_cost_usd,
+    iteration_total_cost_usd: state.total_cost_usd
+  });
+}
+function run_result_from_state(config, state, status, completed_at) {
+  return {
+    run_id: config.run_id,
+    status,
+    started_at: config.started_at,
+    completed_at,
+    iterations_completed: state.iteration,
+    total_usage: state.total_usage,
+    total_cost_usd: state.total_cost_usd,
+    builder_cost_usd: state.builder_cost_usd,
+    critic_cost_usd: state.critic_cost_usd,
+    check_duration_ms: state.check_duration_ms,
+    final_verdict: state.verdict,
+    // The loop itself never salvages: the orchestrator re-stamps this after
+    // teardown when a converged `--worktree` run's work was kept on its branch,
+    // which is the only moment the branch's survival is known.
+    salvaged_branch: null
+  };
+}
+function load_resume_state(workspace, run_id) {
+  const config_path = volley_path(workspace, "config.json");
+  if (!existsSync4(config_path)) {
+    throw config_error(`no resumable run found: ${config_path} missing`);
+  }
+  const recorded = JSON.parse(readFileSync3(config_path, "utf8"));
+  if (recorded["run_id"] !== run_id) {
+    throw config_error(
+      `run ${run_id} not found in ${workspace} (recorded run: ${String(recorded["run_id"])})`
+    );
+  }
+  const iterations_root = volley_path(workspace, "iterations");
+  const dirs = existsSync4(iterations_root) ? readdirSync(iterations_root).filter((d) => /^\d{3}$/.test(d)).toSorted() : [];
+  let completed = 0;
+  for (const dir of dirs) {
+    const full = join3(iterations_root, dir);
+    if (existsSync4(join3(full, "summary.json"))) {
+      completed = Number(dir);
+    } else {
+      rmSync(full, { recursive: true, force: true });
+    }
+  }
+  const summary_path = volley_path(workspace, "summary.json");
+  const summary = existsSync4(summary_path) ? JSON.parse(readFileSync3(summary_path, "utf8")) : null;
+  const feedback_path = volley_path(workspace, "feedback.md");
+  const feedback = existsSync4(feedback_path) ? readFileSync3(feedback_path, "utf8") : null;
+  const raw_config = {
+    prompt: String(recorded["prompt"]),
+    workspace: String(recorded["workspace"]),
+    criteria: String(recorded["criteria"]),
+    check: String(recorded["check"]),
+    builder_model: String(recorded["builder_model"]),
+    builder_provider: recorded["builder_provider"] ?? "claude_cli",
+    ...recorded["builder_max_steps"] === void 0 ? {} : { builder_max_steps: Number(recorded["builder_max_steps"]) },
+    critic_model: String(recorded["critic_model"]),
+    critic_provider: recorded["critic_provider"] ?? "claude_cli",
+    builder_permission_mode: recorded["builder_permission_mode"],
+    critic: recorded["critic_preset"] === "custom" ? String(recorded["critic_prompt_path"]) : String(recorded["critic_preset"]),
+    max_iterations: Number(recorded["max_iterations"]),
+    max_cost_usd: recorded["max_cost_usd"],
+    git_checkpoints: recorded["git_checkpoints"] === true,
+    worktree: recorded["worktree"] === true,
+    discard_worktree: recorded["discard_worktree"] === true,
+    ...Array.isArray(recorded["gate_paths"]) ? { gate_paths: recorded["gate_paths"] } : {},
+    fail_on_gate_edit: recorded["fail_on_gate_edit"] === true,
+    ...recorded["sandbox_image"] === void 0 ? {} : { sandbox_image: recorded["sandbox_image"] }
+  };
+  const state = {
+    iteration: completed,
+    iteration_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    feedback,
+    verdict: null,
+    unmet_criteria: [],
+    check: null,
+    // Re-measured by the resumed run's first `build` step, against a baseline
+    // captured at resume — a resumed run reports what it changes from there.
+    changes: null,
+    builder: null,
+    critic: null,
+    total_usage: summary?.total_usage ?? EMPTY_USAGE,
+    total_cost_usd: summary?.total_cost_usd ?? 0,
+    builder_cost_usd: summary?.builder_cost_usd ?? 0,
+    critic_cost_usd: summary?.critic_cost_usd ?? 0,
+    check_duration_ms: summary?.check_duration_ms ?? 0,
+    iteration_cost_usd: 0,
+    halt: null,
+    cost_warned: false
+  };
+  return {
+    raw_config,
+    run_id,
+    started_at: String(recorded["started_at"]),
+    state,
+    iterations_completed: completed
+  };
+}
+
+// src/matrix.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
+
+// src/orchestrator.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { loop, run, sequence, step } from "fascicle";
+import { filesystem_logger } from "fascicle/adapters";
+
+// src/builder.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath } from "url";
+
+// src/builder/context_check.ts
+var MIN_RECOMMENDED_NUM_CTX = 16384;
+var PROBE_TIMEOUT_MS = 2e3;
+function context_warning(model, num_ctx) {
+  if (num_ctx === null || num_ctx >= MIN_RECOMMENDED_NUM_CTX) return null;
+  return `local builder model '${model}' is configured with num_ctx ${String(num_ctx)}, below the ~${String(MIN_RECOMMENDED_NUM_CTX)} volley recommends: a small context window silently truncates the tool schemas (the #1 local tool-calling failure). Raise it (e.g. a Modelfile \`PARAMETER num_ctx 16384\`) or expect the model to ignore its tools.`;
+}
+function parse_num_ctx(parameters) {
+  if (parameters === null) return null;
+  const match = /^\s*num_ctx\s+(\d+)\s*$/m.exec(parameters);
+  if (match === null) return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : null;
+}
+async function probe_ollama_num_ctx(base_url, model, abort) {
+  const signals = [AbortSignal.timeout(PROBE_TIMEOUT_MS)];
+  if (abort !== void 0) signals.push(abort);
+  try {
+    const res = await fetch(`${base_url.replace(/\/$/, "")}/api/show`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model }),
+      signal: AbortSignal.any(signals)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return parse_num_ctx(typeof body.parameters === "string" ? body.parameters : null);
+  } catch {
+    return null;
+  }
+}
+async function warn_small_local_context(provider, model, base_url, warn, abort) {
+  if (provider !== "ollama") return;
+  const warning = context_warning(model, await probe_ollama_num_ctx(base_url, model, abort));
+  if (warning !== null) warn(warning);
+}
+
+// src/builder/tools.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { lookup as dns_lookup } from "dns";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname } from "path";
+import { Readability } from "@mozilla/readability";
+import ipaddr from "ipaddr.js";
+import { parseHTML } from "linkedom";
+import TurndownService from "turndown";
+import { Agent, buildConnector, interceptors, request } from "undici";
+import { z as z2 } from "zod";
+
+// src/workspace_tools.ts
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve2, sep } from "path";
+import { z } from "zod";
+var READ_FILE_MAX_BYTES = 2e5;
+var SEARCH_MAX_MATCHES = 200;
+var LIST_MAX_ENTRIES = 2e3;
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".volley",
+  ".check",
+  "dist",
+  ".cache"
+]);
+function contain(workspace, rel) {
+  const root = resolve2(workspace);
+  const candidate = isAbsolute2(rel) ? resolve2(rel) : resolve2(root, rel);
+  const within = candidate === root || candidate.startsWith(`${root}${sep}`);
+  if (!within) {
+    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 = readdirSync2(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const abs = join4(dir, name);
+      let is_dir;
+      try {
+        is_dir = statSync2(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;
+}
+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}`);
+  }
+}
+var read_file_input = z.object({
+  path: z.string().describe("Workspace-relative path to the file to read.")
+});
+var 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 subdirectory to limit the search to."),
+  ignore_case: z.boolean().optional().describe("Case-insensitive match. Default false.")
+});
+var list_files_input = z.object({
+  path: z.string().optional().describe("Optional workspace-relative subdirectory. Default: the workspace root."),
+  contains: z.string().optional().describe("Optional substring filter applied to each relative path.")
+});
+function read_only_tools(workspace) {
+  const read_file = {
+    name: "read_file",
+    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 input = read_file_input.parse(raw);
+      const abs = contain(workspace, input.path);
+      const content = readFileSync4(abs, "utf8");
+      return content.length > READ_FILE_MAX_BYTES ? `${content.slice(0, READ_FILE_MAX_BYTES)}
+\u2026 [truncated at ${String(READ_FILE_MAX_BYTES)} bytes]` : content;
+    }
+  };
+  const search_files = {
+    name: "search_files",
+    description: `Search workspace files for lines matching a regular expression. Returns up to ${String(SEARCH_MAX_MATCHES)} "relative/path:line: text" hits.`,
+    input_schema: search_files_input,
+    execute: (raw) => {
+      const input = search_files_input.parse(raw);
+      const start = input.path !== void 0 ? contain(workspace, input.path) : resolve2(workspace);
+      const regex = build_regex(input.pattern, input.ignore_case === true ? "i" : "");
+      const files = walk(resolve2(workspace), start, LIST_MAX_ENTRIES);
+      const hits = [];
+      for (const file of files) {
+        if (hits.length >= SEARCH_MAX_MATCHES) break;
+        let content;
+        try {
+          content = readFileSync4(file.abs, "utf8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i += 1) {
+          if (hits.length >= SEARCH_MAX_MATCHES) 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 >= SEARCH_MAX_MATCHES ? `
+\u2026 [capped at ${String(SEARCH_MAX_MATCHES)} matches]` : "";
+      return `${hits.join("\n")}${capped}`;
+    }
+  };
+  const list_files = {
+    name: "list_files",
+    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);
+      const start = input.path !== void 0 ? contain(workspace, input.path) : resolve2(workspace);
+      let files = walk(resolve2(workspace), start, 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 ? `
+\u2026 [capped at ${String(LIST_MAX_ENTRIES)} entries]` : "";
+      return `${files.join("\n")}${capped}`;
+    }
+  };
+  return [read_file, search_files, list_files];
+}
+function workspace_inventory(root, limit = LIST_MAX_ENTRIES) {
+  const base = resolve2(root);
+  const files = walk(base, base, limit);
+  if (files.length === 0) return "no files";
+  const lines = files.map((file) => {
+    let size;
+    try {
+      size = statSync2(file.abs).size;
+    } catch {
+      size = 0;
+    }
+    return `${file.rel} (${String(size)} bytes)`;
+  });
+  const capped = files.length >= limit ? `
+\u2026 [capped at ${String(limit)} entries]` : "";
+  return `${lines.join("\n")}${capped}`;
+}
+
+// src/builder/tools.ts
+var WRITE_FILE_MAX_BYTES = 1e6;
+var BASH_TIMEOUT_MS = 6e5;
+var BASH_MAX_OUTPUT_BYTES = 1e5;
+var BASH_CAPTURE_MAX_BYTES = 1e7;
+var FETCH_MAX_BYTES = 2e5;
+var FETCH_MAX_CHARS = 5e3;
+var FETCH_MAX_REDIRECTS = 5;
+var FETCH_TIMEOUT_MS = 3e4;
+var FETCH_MIN_EXTRACT_CHARS = 200;
+var FETCH_USER_AGENT = "volley-local-builder";
+var write_file_input = z2.object({
+  path: z2.string().describe("Workspace-relative path to write. Parent directories are created."),
+  content: z2.string().describe("Full UTF-8 content of the file. Overwrites any existing content.")
+});
+var edit_file_input = z2.object({
+  path: z2.string().describe("Workspace-relative path of the file to edit."),
+  old_str: z2.string().min(1).describe("Exact text to replace. Must occur exactly once in the file."),
+  new_str: z2.string().describe("Replacement text.")
+});
+var bash_input = z2.object({
+  command: z2.string().describe("Shell command to run in the workspace directory.")
+});
+var finish_input = z2.object({
+  summary: z2.string().describe("Short summary of what was accomplished.")
+});
+var fetch_input = z2.object({
+  url: z2.string().describe("Absolute http(s) URL to fetch."),
+  max_chars: z2.number().int().positive().optional().describe(`Maximum characters of extracted markdown to return (default ${String(FETCH_MAX_CHARS)}).`),
+  start_index: z2.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;
+}
+function truncate_bytes(text, max) {
+  if (Buffer.byteLength(text, "utf8") <= max) return text;
+  const clipped = Buffer.from(text, "utf8").subarray(0, max).toString("utf8");
+  return `${clipped}
+\u2026 [truncated at ${String(max)} bytes]`;
+}
+function is_forbidden_address(address) {
+  let parsed;
+  try {
+    parsed = ipaddr.parse(address);
+  } catch {
+    return true;
+  }
+  const canonical = "isIPv4MappedAddress" in parsed && parsed.isIPv4MappedAddress() ? parsed.toIPv4Address() : parsed;
+  return canonical.range() !== "unicast";
+}
+var default_resolver = (hostname, options, callback) => {
+  dns_lookup(hostname, options, callback);
+};
+function guarded_lookup(is_forbidden, resolve5) {
+  return (hostname, options, callback) => {
+    resolve5(hostname, options, (err, address, family) => {
+      if (err !== null) {
+        callback(err, "", 0);
+        return;
+      }
+      const resolved = Array.isArray(address) ? address.map((entry) => entry.address) : [address];
+      const blocked = resolved.find((entry) => is_forbidden(entry));
+      if (blocked !== void 0) {
+        callback(ssrf_error(blocked, hostname), "", 0);
+        return;
+      }
+      callback(null, address, family);
+    });
+  };
+}
+function ssrf_error(address, hostname) {
+  const err = new Error(
+    `blocked non-unicast address ${address} for host "${hostname}"`
+  );
+  err.code = "ERR_SSRF_BLOCKED";
+  return err;
+}
+function create_ssrf_agent(is_forbidden, resolve5) {
+  const base = buildConnector({ lookup: guarded_lookup(is_forbidden, resolve5), timeout: FETCH_TIMEOUT_MS });
+  const connector = (options, callback) => {
+    base(options, (err, socket) => {
+      if (err !== null) {
+        callback(err, null);
+        return;
+      }
+      if (socket === null) {
+        callback(new Error("connection produced no socket"), null);
+        return;
+      }
+      const remote = socket.remoteAddress;
+      if (remote !== void 0 && is_forbidden(remote)) {
+        socket.destroy();
+        callback(ssrf_error(remote, options.hostname), null);
+        return;
+      }
+      callback(null, socket);
+    });
+  };
+  return new Agent({ connect: connector, headersTimeout: FETCH_TIMEOUT_MS, bodyTimeout: FETCH_TIMEOUT_MS });
+}
+async function read_body_capped(body, max_bytes) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of body) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const remaining = max_bytes - total;
+    if (buf.length >= remaining) {
+      chunks.push(buf.subarray(0, remaining));
+      break;
+    }
+    chunks.push(buf);
+    total += buf.length;
+  }
+  return Buffer.concat(chunks);
+}
+function header_value(value) {
+  if (Array.isArray(value)) return value[0] ?? "";
+  return value ?? "";
+}
+function content_kind(content_type, body) {
+  const ct = content_type.toLowerCase();
+  if (ct.includes("html") || ct.includes("xml")) return "html";
+  if (ct.startsWith("text/") || ct.includes("json") || ct.includes("javascript") || ct.includes("csv")) {
+    return "text";
+  }
+  if (ct === "") return body.trimStart().startsWith("<") ? "html" : "text";
+  return "binary";
+}
+function extract_markdown(html) {
+  const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+  turndown.remove(["script", "style", "noscript"]);
+  let body_markdown = "";
+  let title = "";
+  try {
+    const { document } = parseHTML(html);
+    const article = new Readability(document).parse();
+    if (article !== null) {
+      title = (article.title ?? "").trim();
+      if (article.content) {
+        body_markdown = turndown.turndown(article.content).trim();
+      }
+    }
+  } catch {
+    body_markdown = "";
+  }
+  if (body_markdown.length < FETCH_MIN_EXTRACT_CHARS) {
+    let fallback = "";
+    try {
+      fallback = turndown.turndown(html).trim();
+    } catch {
+      fallback = "";
+    }
+    if (fallback.length > body_markdown.length) body_markdown = fallback;
+  }
+  const prefix = title.length > 0 && !body_markdown.startsWith(`# ${title}`) ? `# ${title}
+
+` : "";
+  return `${prefix}${body_markdown}`.trim();
+}
+function paginate(full, max_chars, start_index) {
+  if (start_index >= full.length) {
+    return `(no more content: start_index ${String(start_index)} is at or past the end of the ${String(full.length)}-character document)`;
+  }
+  const slice = full.slice(start_index, start_index + max_chars);
+  const next = start_index + slice.length;
+  if (next >= full.length) return slice;
+  const remaining = full.length - next;
+  return `${slice}
+
+<truncated: ${String(remaining)} more characters. Call fetch again with start_index=${String(next)} to continue.>`;
+}
+function error_detail(err) {
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  while (current !== void 0 && current !== null && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof Error) {
+      const code = current.code;
+      parts.push(code !== void 0 ? `${current.message} [${code}]` : current.message);
+      current = current.cause;
+    } else {
+      parts.push(typeof current === "string" ? current : `non-error value (${typeof current})`);
+      break;
+    }
+  }
+  return parts.length > 0 ? parts.join(" <- ") : "unknown error";
+}
+async function run_fetch(raw, ctx, config) {
+  const input = fetch_input.parse(raw);
+  const max_chars = input.max_chars ?? FETCH_MAX_CHARS;
+  const start_index = input.start_index ?? 0;
+  let target;
+  try {
+    target = new URL(input.url);
+  } catch {
+    return `error: not a valid absolute URL: ${input.url}`;
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") {
+    return `error: unsupported URL scheme "${target.protocol}" \u2014 only http and https are fetched`;
+  }
+  const agent = create_ssrf_agent(config.is_forbidden, config.resolve);
+  const dispatcher = agent.compose(interceptors.redirect({ maxRedirections: FETCH_MAX_REDIRECTS }));
+  try {
+    const res = await request(target.href, {
+      dispatcher,
+      signal: ctx.abort,
+      headersTimeout: FETCH_TIMEOUT_MS,
+      bodyTimeout: FETCH_TIMEOUT_MS,
+      headers: {
+        "user-agent": FETCH_USER_AGENT,
+        accept: "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.8",
+        // No compression: keep the pipeline simple and the byte cap honest.
+        "accept-encoding": "identity"
+      }
+    });
+    if (res.statusCode >= 400) {
+      await res.body.dump();
+      return `error: HTTP ${String(res.statusCode)} fetching ${target.href}`;
+    }
+    const bytes = await read_body_capped(res.body, config.max_bytes);
+    const content_type = header_value(res.headers["content-type"]);
+    const text = bytes.toString("utf8");
+    if (text.trim().length === 0) {
+      return `error: empty response body from ${target.href}`;
+    }
+    const kind = content_kind(content_type, text);
+    if (kind === "binary") {
+      return `error: cannot extract non-text content (content-type: ${content_type}) from ${target.href}`;
+    }
+    const markdown = kind === "html" ? extract_markdown(text) : text.trim();
+    if (markdown.length === 0) {
+      return `error: no readable content extracted from ${target.href}`;
+    }
+    return paginate(markdown, max_chars, start_index);
+  } catch (err) {
+    return `error: could not fetch ${target.href}: ${error_detail(err)}`;
+  } finally {
+    await agent.close().catch(() => void 0);
+  }
+}
+function host_bash_executor(cwd) {
+  return (command, options) => {
+    const result = spawnSync3(command, {
+      shell: true,
+      cwd,
+      encoding: "utf8",
+      timeout: options.timeout_ms,
+      killSignal: "SIGKILL",
+      maxBuffer: options.max_capture_bytes
+    });
+    return {
+      status: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      timed_out: result.error?.code === "ETIMEDOUT"
+    };
+  };
+}
+function builder_tools(workspace, options = {}) {
+  const bash_timeout_ms = options.bash_timeout_ms ?? BASH_TIMEOUT_MS;
+  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 > WRITE_FILE_MAX_BYTES) {
+        throw new Error(
+          `content is ${String(bytes)} bytes, over the ${String(WRITE_FILE_MAX_BYTES)}-byte write cap`
+        );
+      }
+      mkdirSync3(dirname(abs), { recursive: true });
+      writeFileSync3(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 \u2014 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 = readFileSync5(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.`;
+      }
+      writeFileSync3(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 \u2014 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.`,
+    input_schema: bash_input,
+    // Stateless per command (the executor is injectable without touching
+    // this contract — under containment it is the local `spawnSync` running in-container),
+    // and never throws on the command's own failure — a non-zero exit or a
+    // timeout is *returned* as `{ exit_code, stdout, stderr }` for the model to
+    // read. The executor buffers up to `BASH_CAPTURE_MAX_BYTES` (OOM guard)
+    // before we truncate to the model-facing cap.
+    execute: (raw) => {
+      const input = bash_input.parse(raw);
+      const outcome = bash_executor(input.command, {
+        timeout_ms: bash_timeout_ms,
+        max_capture_bytes: BASH_CAPTURE_MAX_BYTES
+      });
+      let stderr = truncate_bytes(outcome.stderr, bash_max_output_bytes);
+      if (outcome.timed_out) {
+        const note = `[command timed out after ${String(bash_timeout_ms)}ms and was killed]`;
+        stderr = stderr.length > 0 ? `${stderr}
+${note}` : note;
+      }
+      return {
+        exit_code: outcome.status,
+        stdout: truncate_bytes(outcome.stdout, bash_max_output_bytes),
+        stderr
+      };
+    }
+  };
+  const fetch2 = {
+    name: "fetch",
+    description: `Fetch an http(s) URL and return its main content converted to Markdown. Returns at most max_chars characters (default ${String(FETCH_MAX_CHARS)}); when the page is longer, a trailer names the start_index to pass to read the next slice. Private, loopback, and link-local addresses are refused. A blocked, non-HTML, or failed request returns an error string you can read and act on.`,
+    input_schema: fetch_input,
+    // Native readability pipeline with connection-time SSRF protection; a
+    // blocked / non-HTML / HTTP error is returned as a tool result, not
+    // thrown. The classifier and resolver are overridable for tests only.
+    execute: (raw, ctx) => run_fetch(raw, ctx, {
+      is_forbidden: options.fetch_is_address_forbidden ?? is_forbidden_address,
+      resolve: options.fetch_lookup ?? default_resolver,
+      max_bytes: options.fetch_max_bytes ?? FETCH_MAX_BYTES
+    })
+  };
+  const finish = {
+    name: "finish",
+    description: "Declare the task complete. Calling this tool ends your turn \u2014 do not call it until the work is done and verified.",
+    input_schema: finish_input,
+    // A successful `finish` ends the loop deterministically. The summary
+    // is recorded in the trajectory like any tool call and otherwise ignored
+    // — the workspace, not the self-report, is truth.
+    ends_turn: true,
+    execute: (raw) => {
+      const input = finish_input.parse(raw);
+      return `finished: ${input.summary}`;
+    }
+  };
+  return [...read_only_tools(workspace), write_file, edit_file, bash, fetch2, finish];
+}
+
+// src/engine.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { create_engine } from "fascicle";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_LMSTUDIO_URL = "http://localhost:1234/v1";
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "0.0.0.0"]);
+function cross_to_host_gateway(base_url, env) {
+  const host = env["VOLLEY_MODEL_HOST"];
+  if (host === void 0 || host === "") return base_url;
+  let parsed;
+  try {
+    parsed = new URL(base_url);
+  } catch {
+    return base_url;
+  }
+  if (!LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase())) return base_url;
+  parsed.hostname = host;
+  return parsed.toString().replace(/\/$/, "");
+}
+function resolve_ollama_base_url(env) {
+  const raw = env["VOLLEY_OLLAMA_URL"] ?? DEFAULT_OLLAMA_URL;
+  const normalized = raw.replace(/\/+$/, "").replace(/\/api$/, "");
+  return cross_to_host_gateway(normalized, env);
+}
+function load_pricing_overrides(path) {
+  if (!existsSync5(path)) {
+    throw config_error(`VOLLEY_PRICING_PATH not found: ${path}`);
+  }
+  try {
+    return JSON.parse(readFileSync6(path, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw config_error(`VOLLEY_PRICING_PATH is not valid JSON: ${detail}`);
+  }
+}
+function is_local_provider(provider) {
+  return provider === "ollama" || provider === "lmstudio";
+}
+function local_provider_config(provider, env) {
+  if (provider === "ollama") {
+    return { ollama: { base_url: resolve_ollama_base_url(env) } };
+  }
+  const lmstudio_url = env["VOLLEY_LMSTUDIO_URL"] ?? DEFAULT_LMSTUDIO_URL;
+  return { lmstudio: { base_url: cross_to_host_gateway(lmstudio_url, env) } };
+}
+function create_volley_engine(options) {
+  const env = options.env ?? process.env;
+  const auth_mode = env["VOLLEY_AUTH_MODE"] ?? "auto";
+  if (auth_mode !== "auto" && auth_mode !== "oauth" && auth_mode !== "api_key") {
+    throw config_error(
+      `VOLLEY_AUTH_MODE must be auto, oauth, or api_key; got: ${auth_mode}`
+    );
+  }
+  const binary = env["VOLLEY_CLAUDE_BIN"];
+  const pricing_path = env["VOLLEY_PRICING_PATH"];
+  const local_providers = /* @__PURE__ */ new Set();
+  if (is_local_provider(options.builder_provider)) local_providers.add(options.builder_provider);
+  if (is_local_provider(options.critic_provider)) local_providers.add(options.critic_provider);
+  const providers = {
+    claude_cli: {
+      default_cwd: options.workspace,
+      setting_sources: ["project", "local"],
+      auth_mode,
+      ...binary !== void 0 && binary.length > 0 ? { binary } : {},
+      ...auth_mode === "api_key" && env["ANTHROPIC_API_KEY"] !== void 0 ? { api_key: env["ANTHROPIC_API_KEY"] } : {}
+    }
+  };
+  for (const provider of local_providers) {
+    Object.assign(providers, local_provider_config(provider, env));
+  }
+  return create_engine({
+    providers,
+    ...pricing_path !== void 0 && pricing_path.length > 0 ? { pricing: load_pricing_overrides(pricing_path) } : {}
+  });
+}
+
+// src/prewarm.ts
+var PREWARM_TIMEOUT_MS = 3e5;
+async function prewarm_ollama_model(base_url, model, abort) {
+  const signals = [AbortSignal.timeout(PREWARM_TIMEOUT_MS)];
+  if (abort !== void 0) signals.push(abort);
+  try {
+    await fetch(`${base_url.replace(/\/$/, "")}/api/generate`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model }),
+      signal: AbortSignal.any(signals)
+    });
+  } catch {
+  }
+}
+
+// src/worktree.ts
+import { existsSync as existsSync6, renameSync as renameSync2, rmSync as rmSync2, symlinkSync } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+function worktree_path(workspace) {
+  return `${resolve3(workspace)}.worktree`;
+}
+function worktree_branch(run_id) {
+  return `volley/${run_id}`;
+}
+function build_root(workspace, worktree) {
+  return worktree ? worktree_path(workspace) : workspace;
+}
+function worktree_fate(config) {
+  if (!config.worktree) return "none";
+  if (config.git_checkpoints) return "integrate";
+  if (config.discard_worktree) return "discard";
+  return "salvage";
+}
+var RUN_BRANCH_PATTERN = "volley/<run id>";
+function worktree_notice(config) {
+  const fate = worktree_fate(config);
+  if (fate === "none") return null;
+  if (fate === "integrate") {
+    return {
+      level: "info",
+      message: "worktree: --worktree --git \u2014 a successful run squash-merges its run branch onto the workspace branch at teardown; any other outcome is discarded."
+    };
+  }
+  if (fate === "discard") {
+    return {
+      level: "info",
+      message: "worktree: --discard-worktree \u2014 the run builds in an isolated worktree whose effects are thrown away at teardown, converged or not. Verdicts only; no branch is kept."
+    };
+  }
+  return {
+    level: "warn",
+    message: `worktree: --worktree without --git \u2014 a successful run will NOT be integrated into the workspace branch, and the builder writes only inside the sibling worktree, so your working tree stays as it is. The run's work is committed onto its own branch (${RUN_BRANCH_PATTERN}) at teardown and left there for \`git switch\` / \`git cherry-pick\`. Add --git to squash-merge it onto the workspace branch instead, or --discard-worktree to throw it away deliberately.`
+  };
+}
+function report_worktree_fate(config, sink) {
+  const notice = worktree_notice(config);
+  if (notice === null) return;
+  if (notice.level === "warn") {
+    sink.warn(notice.message);
+    return;
+  }
+  sink.info(notice.message);
+}
+function git2(cwd, args) {
+  const result = spawnSync4("git", args, { cwd, encoding: "utf8" });
+  if (result.error !== void 0) {
+    throw config_error(`git is required for --worktree but could not run: ${String(result.error)}`);
+  }
+  return { status: result.status ?? -1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+function git_ok(cwd, args) {
+  const result = git2(cwd, args);
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw check_error(`git ${args.join(" ")} failed: ${detail}`);
+  }
+  return result;
+}
+function git_quiet(cwd, args) {
+  try {
+    const result = spawnSync4("git", args, { cwd, encoding: "utf8" });
+    return { status: result.status ?? -1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+  } catch {
+    return { status: -1, stdout: "", stderr: "" };
+  }
+}
+function branch_exists(repo, branch) {
+  return git2(repo, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
+}
+function create_worktree(options) {
+  const repo = resolve3(options.workspace);
+  if (!existsSync6(join5(repo, ".git"))) {
+    throw config_error(`--worktree requires the workspace to be a git repository: ${repo}`);
+  }
+  const path = worktree_path(repo);
+  const base = options.base ?? "HEAD";
+  const log = options.log ?? (() => {
+  });
+  if (existsSync6(path)) {
+    const backup = `${path}.bak.${backup_stamp()}`;
+    renameSync2(path, backup);
+    git2(repo, ["worktree", "prune"]);
+    log(`worktree: rotated existing ${path} aside to ${backup}`);
+  }
+  if (branch_exists(repo, options.branch)) {
+    const backup_branch = `${options.branch}.bak.${backup_stamp()}`;
+    git_ok(repo, ["branch", "-m", options.branch, backup_branch]);
+    log(`worktree: rotated existing branch ${options.branch} aside to ${backup_branch}`);
+  }
+  git_ok(repo, ["worktree", "add", "-b", options.branch, path, base]);
+  const modules = join5(repo, "node_modules");
+  if (existsSync6(modules) && !existsSync6(join5(path, "node_modules"))) {
+    symlinkSync(modules, join5(path, "node_modules"), "dir");
+    log(`worktree: linked node_modules from ${repo}`);
+  }
+  return { path, branch: options.branch };
+}
+function teardown_worktree(options) {
+  const repo = resolve3(options.workspace);
+  const path = worktree_path(repo);
+  const outcome = options.salvage === true ? salvage_worktree(repo, path, options.branch) : { salvaged_branch: null, kept_path: null };
+  if (outcome.kept_path !== null) return outcome;
+  git_quiet(repo, ["worktree", "remove", "--force", path]);
+  if (outcome.salvaged_branch === null) {
+    git_quiet(repo, ["branch", "-D", options.branch]);
+  }
+  git_quiet(repo, ["worktree", "prune"]);
+  if (existsSync6(path)) {
+    try {
+      rmSync2(path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return outcome;
+}
+function salvage_worktree(repo, path, branch) {
+  if (existsSync6(path)) {
+    git_quiet(path, ["add", "-A"]);
+    git_quiet(path, [
+      "commit",
+      "-m",
+      `volley: salvage unintegrated worktree (${branch})`,
+      "--no-verify"
+    ]);
+    if (worktree_dirty(path)) return { salvaged_branch: null, kept_path: path };
+  }
+  return { salvaged_branch: branch_ahead(repo, branch) ? branch : null, kept_path: null };
+}
+function worktree_dirty(path) {
+  const status = git_quiet(path, ["status", "--porcelain"]);
+  return status.status === 0 && status.stdout.trim().length > 0;
+}
+function branch_ahead(repo, branch) {
+  const ahead = git_quiet(repo, ["rev-list", "--count", `HEAD..${branch}`]);
+  return ahead.status === 0 && Number(ahead.stdout.trim()) > 0;
+}
+async function with_worktree(options, body) {
+  if (!options.enabled) {
+    return { value: await body(), salvaged_branch: null, kept_path: null };
+  }
+  create_worktree({
+    workspace: options.workspace,
+    branch: options.branch,
+    ...options.log !== void 0 ? { log: options.log } : {}
+  });
+  let discard_on_exit = true;
+  try {
+    const value = await body();
+    if (options.salvage?.(value) !== true) {
+      return { value, salvaged_branch: null, kept_path: null };
+    }
+    discard_on_exit = false;
+    return {
+      value,
+      ...teardown_worktree({
+        workspace: options.workspace,
+        branch: options.branch,
+        salvage: true
+      })
+    };
+  } finally {
+    if (discard_on_exit) {
+      teardown_worktree({ workspace: options.workspace, branch: options.branch });
+    }
+  }
+}
+
+// src/builder.ts
+var BUILDER_ALLOWED_TOOLS = [
+  "Read",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "WebFetch"
+];
+function compose_builder_system() {
+  return [
+    "You are the builder inside the volley harness: an autonomous agent",
+    "iterating on a workspace until it satisfies a task and its acceptance",
+    "criteria. Work directly in the current working directory. Plan",
+    "internally, make the changes, and verify your own work before finishing."
+  ].join("\n");
+}
+function presets_dir() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidate = join6(dir, "src", "builder", "presets");
+    if (existsSync7(candidate)) return candidate;
+    dir = dirname2(dir);
+  }
+  throw config_error("builder presets directory not found");
+}
+function compose_builder_system_local() {
+  const identity = [
+    "You are the builder inside the volley harness: an autonomous agent",
+    "iterating on a workspace until it satisfies a task and its acceptance",
+    "criteria."
+  ].join("\n");
+  const append = readFileSync7(join6(presets_dir(), "harness_append_local.md"), "utf8");
+  return `${identity}
+
+${append.trimEnd()}`;
+}
+function resolve_builder_system(config) {
+  return config.builder_provider === "claude_cli" ? compose_builder_system() : compose_builder_system_local();
+}
+var BUILDER_TOOL_CALL_REPAIR_ATTEMPTS = 3;
+function builder_tool_options(config, bash_executor) {
+  if (config.builder_provider === "claude_cli") {
+    return {
+      provider_options: {
+        claude_cli: {
+          allowed_tools: [...BUILDER_ALLOWED_TOOLS],
+          extra_args: ["--permission-mode", config.builder_permission_mode]
+        }
+      }
+    };
+  }
+  return {
+    // Containment root re-points to the worktree under `--worktree`, so
+    // the model's writes, edits, and `bash` cwd land there and leave the
+    // workspace untouched. When the sandbox is active its `docker exec` executor
+    // runs `bash` in the container against the bind-mounted worktree; the
+    // host `spawnSync` default stands in otherwise.
+    tools: builder_tools(
+      build_root(config.workspace, config.worktree),
+      bash_executor !== null ? { bash_executor } : {}
+    ),
+    max_steps: config.builder_max_steps,
+    tool_error_policy: "feed_back",
+    tool_call_repair_attempts: BUILDER_TOOL_CALL_REPAIR_ATTEMPTS,
+    max_tool_calls_per_step: 1
+  };
+}
+function compose_builder_prompt(input) {
+  const parts = [
+    "TASK",
+    "----",
+    input.task,
+    "",
+    "ACCEPTANCE CRITERIA",
+    "-------------------",
+    input.criteria,
+    "",
+    `ITERATION: ${input.iteration}`
+  ];
+  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.checkride) {
+    parts.push(
+      "",
+      "The definition of done for this workspace includes `pnpm check` (checkride)",
+      "exiting 0. Run it yourself before finishing; on failure, read",
+      ".check/summary.json, then the failing slot's raw output, 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)`;
+}
+async function run_builder(deps, state, ctx) {
+  const { engine, config } = deps;
+  try {
+    if (config.builder_provider === "ollama") {
+      const base_url = resolve_ollama_base_url(process.env);
+      await warn_small_local_context(
+        config.builder_provider,
+        config.builder_model,
+        base_url,
+        deps.warn,
+        ctx.abort
+      );
+      await prewarm_ollama_model(base_url, config.builder_model, ctx.abort);
+    }
+    const result = await engine.generate({
+      provider: config.builder_provider,
+      model: config.builder_model,
+      system: resolve_builder_system(config),
+      prompt: compose_builder_prompt({
+        task: config.prompt,
+        criteria: config.criteria,
+        feedback: state.feedback,
+        iteration: state.iteration,
+        checkride: config.check_resolved === "checkride"
+      }),
+      abort: ctx.abort,
+      trajectory: ctx.trajectory,
+      on_chunk: deps.on_chunk,
+      ...builder_tool_options(config, deps.bash_executor ?? null)
+    });
+    if (result.finish_reason === "max_steps") {
+      deps.warn(builder_max_steps_warning(config.builder_max_steps));
+    }
+    return accumulate(state, "builder", result, config.builder_model);
+  } catch (err) {
+    throw phase_error("builder", state.iteration, err);
+  }
+}
+
+// src/check/checkride.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { join as join7 } from "path";
+import { spawn } from "child_process";
+import { aborted_error } from "fascicle";
+var CHECK_ARTIFACT_MAX_CHARS = 8e3;
+var CHECKRIDE_SCHEMA_VERSION = 1;
+function spawn_capture(cmd, args, options) {
+  return new Promise((resolve_promise, reject) => {
+    const proc = spawn(cmd, args, {
+      cwd: options.cwd,
+      ...options.abort !== void 0 ? { signal: options.abort } : {}
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", (err) => {
+      if (err.name === "AbortError") {
+        reject(new aborted_error("check aborted"));
+        return;
+      }
+      reject(check_error(`check command failed to start: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      resolve_promise({ exit_code: code, stdout, stderr });
+    });
+  });
+}
+function parse_checkride_summary(stdout) {
+  const start = stdout.indexOf("{");
+  const end = stdout.lastIndexOf("}");
+  let raw;
+  try {
+    if (start === -1 || end < start) throw new Error("no JSON object in stdout");
+    raw = JSON.parse(stdout.slice(start, end + 1));
+  } catch {
+    throw check_error("checkride --json produced unparseable stdout");
+  }
+  if (typeof raw !== "object" || raw === null || !Array.isArray(raw.checks)) {
+    throw check_error("checkride summary missing checks array");
+  }
+  const summary = raw;
+  const warning = summary.schema_version === CHECKRIDE_SCHEMA_VERSION ? null : `checkride summary schema_version ${String(summary.schema_version)} != ${String(CHECKRIDE_SCHEMA_VERSION)}; parsing best-effort`;
+  return { summary, warning };
+}
+function parse_summary_with_fallback(stdout, workspace) {
+  try {
+    return parse_checkride_summary(stdout);
+  } catch (err) {
+    const file = join7(workspace, ".check", "summary.json");
+    if (!existsSync8(file)) throw err;
+    return parse_checkride_summary(readFileSync8(file, "utf8"));
+  }
+}
+function failing_checks(summary) {
+  return summary.checks.filter((c) => !c.ok && c.skipped !== true);
+}
+function read_failing_artifacts(workspace, failing) {
+  return failing.map((check) => {
+    const file = check.output_file ?? `${check.name}.stdout.txt`;
+    const path = join7(workspace, ".check", file);
+    if (!existsSync8(path)) {
+      return { slot: check.name, path: null, content: "(no artifact found)", truncated: false };
+    }
+    const raw = readFileSync8(path, "utf8");
+    const truncated = raw.length > CHECK_ARTIFACT_MAX_CHARS;
+    return {
+      slot: check.name,
+      path,
+      content: truncated ? raw.slice(0, CHECK_ARTIFACT_MAX_CHARS) : raw,
+      truncated
+    };
+  });
+}
+async function run_checkride(opts) {
+  const proc = await spawn_capture("pnpm", ["exec", "checkride", "--json"], {
+    cwd: opts.workspace,
+    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
+  });
+  if (proc.exit_code === 2) {
+    throw check_error(`checkride harness error: ${proc.stderr.trim()}`);
+  }
+  const { summary } = parse_summary_with_fallback(proc.stdout, opts.workspace);
+  const failing = failing_checks(summary);
+  return {
+    ran: true,
+    runner: "checkride",
+    ok: summary.ok,
+    exit_code: proc.exit_code,
+    duration_ms: summary.total_duration_ms,
+    failing_slots: failing.map((c) => c.name),
+    detail: read_failing_artifacts(opts.workspace, failing),
+    summary
+  };
+}
+
+// src/check/command.ts
+async function run_command_check(opts) {
+  const started = Date.now();
+  const proc = await spawn_capture("sh", ["-c", opts.command], {
+    cwd: opts.workspace,
+    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
+  });
+  if (proc.exit_code === 127 || proc.exit_code === 126) {
+    throw check_error(
+      `check command failed to start (exit ${String(proc.exit_code)}): ${opts.command}`
+    );
+  }
+  const log = `${proc.stdout}${proc.stderr}`;
+  return {
+    ran: true,
+    runner: "command",
+    ok: proc.exit_code === 0,
+    exit_code: proc.exit_code,
+    duration_ms: Date.now() - started,
+    failing_slots: [],
+    detail: [],
+    log
+  };
+}
+function skipped_check(reason) {
+  return {
+    ran: false,
+    runner: "none",
+    // With no check configured the loop is critic-gated only, so the gate is
+    // open (`ok: true`). A cost-cap skip must not look like a passing gate.
+    ok: reason === "none",
+    exit_code: null,
+    duration_ms: 0,
+    failing_slots: [],
+    detail: []
+  };
+}
+
+// src/summary.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
+function transport_of(provider) {
+  return provider === "claude_cli" ? "claude_cli" : "ai_sdk";
+}
+function read_iteration_archives(workspace) {
+  const root = volley_path(workspace, "iterations");
+  if (!existsSync9(root)) return [];
+  const dirs = readdirSync3(root).filter((dir) => /^\d{3}$/.test(dir)).toSorted();
+  const archives = [];
+  for (const dir of dirs) {
+    const path = volley_path(workspace, "iterations", dir, "summary.json");
+    if (!existsSync9(path)) continue;
+    try {
+      archives.push(JSON.parse(readFileSync9(path, "utf8")));
+    } catch {
+    }
+  }
+  return archives;
+}
+function check_trajectory(archives) {
+  return archives.map((archive, index) => ({
+    iteration: typeof archive.iteration === "number" ? archive.iteration : index + 1,
+    ran: archive.check?.ran === true,
+    ok: archive.check?.ok === true,
+    failing_slots: archive.check?.failing_slots ?? []
+  }));
+}
+function any_critic_degraded(archives) {
+  return archives.some((archive) => archive.critic?.critic_degraded === true);
+}
+function all_gate_edits(archives) {
+  const edits = /* @__PURE__ */ new Set();
+  for (const archive of archives) {
+    for (const path of archive.changes?.gate_edits ?? []) edits.add(path);
+  }
+  return [...edits].toSorted();
+}
+function salvage_stats(archives) {
+  let tool_calls = 0;
+  let salvaged_tool_calls = 0;
+  for (const archive of archives) {
+    tool_calls += archive.builder?.tool_calls ?? 0;
+    salvaged_tool_calls += archive.builder?.salvaged_tool_calls ?? 0;
+  }
+  return {
+    tool_calls,
+    salvaged_tool_calls,
+    rate: tool_calls === 0 ? 0 : salvaged_tool_calls / tool_calls
+  };
+}
+function build_run_summary(config, result) {
+  const archives = read_iteration_archives(config.workspace);
+  const wall_clock_ms = result.completed_at === null ? null : Date.parse(result.completed_at) - Date.parse(result.started_at);
+  return {
+    ...result,
+    comparison: {
+      builder_transport: transport_of(config.builder_provider),
+      critic_transport: transport_of(config.critic_provider),
+      iterations_to_converge: result.status === "success" ? result.iterations_completed : null,
+      wall_clock_ms,
+      total_cost_usd: result.total_cost_usd,
+      builder_cost_usd: result.builder_cost_usd,
+      critic_cost_usd: result.critic_cost_usd,
+      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)
+    }
+  };
+}
+function write_run_summary(config, result) {
+  writeFileSync4(
+    volley_path(config.workspace, "summary.json"),
+    `${JSON.stringify(build_run_summary(config, result), null, 2)}
+`
+  );
+}
+
+// src/critic/run.ts
+import { z as z3 } from "zod";
+
+// src/critic/prompt.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function presets_dir2() {
+  let dir = dirname3(fileURLToPath2(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidate = join8(dir, "src", "critic", "presets");
+    if (existsSync10(candidate)) return candidate;
+    const local = join8(dir, "presets");
+    if (existsSync10(local)) return local;
+    dir = dirname3(dir);
+  }
+  throw config_error("critic presets directory not found");
+}
+function resolve_critic_prompt(config) {
+  const base = config.critic_prompt_path !== null ? readFileSync10(config.critic_prompt_path, "utf8") : readFileSync10(join8(presets_dir2(), `${config.critic_preset}.md`), "utf8");
+  const append_file = config.critic_provider === "claude_cli" ? "harness_append.md" : "harness_append_local.md";
+  const append = readFileSync10(join8(presets_dir2(), append_file), "utf8");
+  return `${base.trimEnd()}
+
+${append.trimEnd()}`;
+}
+var STATUS_MARKS = {
+  added: "A",
+  modified: "M",
+  deleted: "D",
+  renamed: "R",
+  unknown: "?"
+};
+function format_change(file) {
+  return `  ${STATUS_MARKS[file.status]} ${file.path}`;
+}
+function format_changes_section(changes) {
+  if (changes === null) return null;
+  const scope = changes.baseline === null ? "this run" : `baseline ${changes.baseline.slice(0, 8)}`;
+  if (changes.total === 0) {
+    return [
+      `BUILDER CHANGES (since ${scope})`,
+      "------------------------------",
+      "The builder changed no files. Unless the acceptance criteria were already",
+      "met before this run, that is itself grounds for changes_requested."
+    ].join("\n");
+  }
+  const lines = [
+    `BUILDER CHANGES (since ${scope})`,
+    "------------------------------",
+    "Review the work as a change, not just as a finished tree. Read the files",
+    "below with your tools as needed.",
+    "",
+    ...changes.files.map(format_change)
+  ];
+  if (changes.truncated) {
+    lines.push(
+      `  \u2026 showing ${String(changes.files.length)} of ${String(changes.total)} changed paths`
+    );
+  }
+  if (changes.gate_edits.length > 0) {
+    lines.push(
+      "",
+      `GATE EDITS (${String(changes.gate_edits.length)})`,
+      "-----------",
+      "These changed paths are part of the gate \u2014 the tests, fixtures, and check",
+      "configuration that decide whether this work passes. A check the builder can",
+      "edit proves less than one it cannot.",
+      "",
+      ...changes.gate_edits.map((path) => `  ! ${path}`),
+      "",
+      "Judge whether each of these edits was necessary and legitimate for the task",
+      "as specified. If any of them weakened the check, deleted a case, or moved a",
+      "target rather than meeting it, the work does not meet the criteria: return",
+      "changes_requested, name the file, and say what was weakened."
+    );
+  }
+  return lines.join("\n");
+}
+function format_check_section(check) {
+  if (!check.ran) {
+    return "No deterministic check ran for this iteration. Base your verdict on workspace inspection alone.";
+  }
+  const lines = [
+    `DETERMINISTIC CHECK (${check.runner})`,
+    "------------------------------------",
+    `result: ${check.ok ? "PASSED" : "FAILED"} (exit ${String(check.exit_code)})`
+  ];
+  if (check.failing_slots.length > 0) {
+    lines.push(`failing slots: ${check.failing_slots.join(", ")}`);
+  }
+  if (check.summary !== void 0) {
+    lines.push("", "summary.json:", "```json", JSON.stringify(check.summary, null, 2), "```");
+  }
+  for (const artifact of check.detail) {
+    lines.push(
+      "",
+      `--- raw output for failing slot "${artifact.slot}"${artifact.truncated ? ` (truncated; full output archived at ${artifact.path ?? "n/a"})` : ""} ---`,
+      artifact.content
+    );
+  }
+  if (check.log !== void 0 && check.log.length > 0) {
+    lines.push("", "check output:", "```", check.log, "```");
+  }
+  return lines.join("\n");
+}
+function compose_critic_prompt(input) {
+  const changes = format_changes_section(input.changes);
+  return [
+    "ACCEPTANCE CRITERIA",
+    "-------------------",
+    input.criteria,
+    "",
+    `ITERATION: ${input.iteration}`,
+    "",
+    format_check_section(input.check),
+    ...changes === null ? [] : ["", changes],
+    "",
+    "Review the workspace against the acceptance criteria and return your",
+    "structured verdict."
+  ].join("\n");
+}
+
+// src/critic/run.ts
+var CRITIC_ALLOWED_TOOLS = ["Read", "Grep", "Glob"];
+var CRITIC_DISALLOWED_TOOLS = "Write,Edit,MultiEdit,NotebookEdit,Bash";
+var verdict_schema = z3.object({
+  verdict: z3.enum(["approved", "changes_requested"]),
+  feedback: z3.string().describe(
+    "Free-form markdown for the builder. Concrete and actionable. Will be passed verbatim into the next iteration."
+  ),
+  unmet_criteria: z3.array(z3.string()).describe(
+    "The specific acceptance criteria judged unmet, verbatim. Empty when approved."
+  )
+});
+function critic_tool_options(config) {
+  if (config.critic_provider === "claude_cli") {
+    return {
+      provider_options: {
+        claude_cli: {
+          allowed_tools: [...CRITIC_ALLOWED_TOOLS],
+          extra_args: ["--disallowedTools", CRITIC_DISALLOWED_TOOLS]
+        }
+      }
+    };
+  }
+  return { tools: read_only_tools(build_root(config.workspace, config.worktree)) };
+}
+var MAX_CRITIC_RETRIES = 1;
+function is_retryable_critic_error(config, ctx, err) {
+  if (config.critic_provider === "claude_cli") return false;
+  if (ctx.abort.aborted) return false;
+  return error_kind(err) === "provider_error";
+}
+function retry_cause_kind_of(err) {
+  const cause = err.cause_kind;
+  return cause === "provider_5xx" || cause === "network" ? cause : "unknown";
+}
+function finalize_critic(state, result, model, mark) {
+  const next = accumulate(state, "critic", result, model);
+  return {
+    ...next,
+    critic: next.critic === null ? null : {
+      ...next.critic,
+      retries: mark.retries,
+      ...mark.retry_cause_kind !== void 0 ? { retry_cause_kind: mark.retry_cause_kind } : {},
+      ...mark.critic_degraded === true ? { critic_degraded: true } : {}
+    },
+    verdict: result.content.verdict,
+    feedback: result.content.feedback,
+    unmet_criteria: result.content.unmet_criteria
+  };
+}
+function toolless_critic_prompt(config, tool_prompt) {
+  return [
+    tool_prompt,
+    "",
+    "NOTE: file-read tools are unavailable for this review. Judge from the",
+    "acceptance criteria, the deterministic check output above, and the workspace",
+    "file inventory below (paths and sizes only \u2014 file contents are not shown).",
+    "",
+    "WORKSPACE FILE INVENTORY",
+    "------------------------",
+    workspace_inventory(build_root(config.workspace, config.worktree))
+  ].join("\n");
+}
+var CANARY_PROMPT = [
+  "CANARY CHECK \u2014 a tiny wiring probe, not a real review.",
+  'First, call the read_file tool on the path "package.json".',
+  "Whatever the tool returns (content or an error), immediately answer with",
+  'verdict "approved", feedback exactly "canary", and empty unmet_criteria.'
+].join("\n");
+var CANARY_TOOLLESS_PROMPT = [
+  "CANARY CHECK \u2014 a tiny wiring probe, not a real review.",
+  'Answer with verdict "approved", feedback exactly "canary", and empty',
+  "unmet_criteria."
+].join("\n");
+function canary_detail(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function critic_canary(engine, config, env = process.env) {
+  if (config.critic_provider === "ollama") {
+    await prewarm_ollama_model(resolve_ollama_base_url(env), config.critic_model);
+  }
+  const base = {
+    provider: config.critic_provider,
+    model: config.critic_model,
+    system: resolve_critic_prompt(config),
+    schema: verdict_schema
+  };
+  try {
+    await engine.generate({
+      ...base,
+      prompt: CANARY_PROMPT,
+      ...critic_tool_options(config)
+    });
+    return { outcome: "ok" };
+  } catch (err) {
+    if (error_kind(err) !== "provider_error") {
+      return { outcome: "failed", detail: canary_detail(err) };
+    }
+    const tool_death = canary_detail(err);
+    try {
+      await engine.generate({ ...base, prompt: CANARY_TOOLLESS_PROMPT });
+      return { outcome: "degraded", detail: tool_death };
+    } catch (fallback_err) {
+      return { outcome: "failed", detail: canary_detail(fallback_err) };
+    }
+  }
+}
+async function run_critic(deps, state, ctx) {
+  const { engine, config } = deps;
+  if (state.check === null) {
+    throw phase_error("critic", state.iteration, new Error("check phase did not run"));
+  }
+  const check = state.check;
+  try {
+    if (config.critic_provider === "ollama") {
+      await prewarm_ollama_model(
+        resolve_ollama_base_url(process.env),
+        config.critic_model,
+        ctx.abort
+      );
+    }
+    const base = {
+      provider: config.critic_provider,
+      model: config.critic_model,
+      system: resolve_critic_prompt(config),
+      schema: verdict_schema,
+      abort: ctx.abort,
+      trajectory: ctx.trajectory,
+      on_chunk: deps.on_chunk
+    };
+    const tool_prompt = compose_critic_prompt({
+      criteria: config.criteria,
+      iteration: state.iteration,
+      check,
+      changes: state.changes
+    });
+    let retry_cause_kind;
+    for (let attempt = 0; attempt <= MAX_CRITIC_RETRIES; attempt += 1) {
+      try {
+        const result2 = await engine.generate({
+          ...base,
+          prompt: tool_prompt,
+          ...critic_tool_options(config)
+        });
+        return finalize_critic(state, result2, config.critic_model, {
+          retries: attempt,
+          retry_cause_kind
+        });
+      } catch (err) {
+        if (!is_retryable_critic_error(config, ctx, err)) throw err;
+        retry_cause_kind = retry_cause_kind_of(err);
+      }
+    }
+    const result = await engine.generate({
+      ...base,
+      prompt: toolless_critic_prompt(config, tool_prompt)
+    });
+    return finalize_critic(state, result, config.critic_model, {
+      retries: MAX_CRITIC_RETRIES,
+      retry_cause_kind,
+      critic_degraded: true
+    });
+  } catch (err) {
+    throw phase_error("critic", state.iteration, err);
+  }
+}
+
+// src/orchestrator.ts
+function initial_state() {
+  return {
+    iteration: 0,
+    iteration_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    feedback: null,
+    verdict: null,
+    unmet_criteria: [],
+    check: null,
+    changes: null,
+    builder: null,
+    critic: null,
+    total_usage: EMPTY_USAGE,
+    total_cost_usd: 0,
+    builder_cost_usd: 0,
+    critic_cost_usd: 0,
+    check_duration_ms: 0,
+    iteration_cost_usd: 0,
+    halt: null,
+    cost_warned: false
+  };
+}
+function gate_edit_halt(config, state) {
+  return config.fail_on_gate_edit && (state.changes?.gate_edits.length ?? 0) > 0;
+}
+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;
+  return {
+    stop: success || cap || gate_edit,
+    state: { ...state, halt }
+  };
+}
+function status_of(value, converged) {
+  if (value.halt === "gate_edit") return "gate_edit_blocked";
+  if (value.halt === "cost_cap") return "cost_cap_reached";
+  return converged ? "success" : "budget_exhausted";
+}
+var LISTED_GATE_EDITS = 5;
+function report_changes(config, renderer, changes) {
+  if (changes === null) return;
+  renderer.info(
+    `changes: ${String(changes.total)} file(s) changed since the run baseline` + (changes.truncated ? ` (listing the first ${String(changes.files.length)})` : "")
+  );
+  if (changes.gate_edits.length === 0) return;
+  const hidden = changes.gate_edits.length - LISTED_GATE_EDITS;
+  const listed = changes.gate_edits.slice(0, LISTED_GATE_EDITS).join(", ");
+  renderer.warn(
+    `gate edit: the builder changed ${String(changes.gate_edits.length)} file(s) that decide whether its work passes \u2014 ${listed}${hidden > 0 ? ` (+${String(hidden)} more)` : ""}. A green check proves less when the builder can edit the gate; the critic is told about this and the run summary records it.` + // The halt lands at the loop guard, after this iteration's check and
+    // critic have had their say — so promise the outcome, not the timing.
+    (config.fail_on_gate_edit ? " This run will end without success (--fail-on-gate-edit, exit 8)." : "")
+  );
+}
+async function execute_check(config, abort) {
+  const root = build_root(config.workspace, config.worktree);
+  if (config.check_resolved === "checkride") {
+    return run_checkride({ workspace: root, abort });
+  }
+  if (config.check_resolved === "command") {
+    return run_command_check({ command: config.check, workspace: root, abort });
+  }
+  return skipped_check("none");
+}
+async function run_volley(config, deps, resume_from = null) {
+  const { renderer } = deps;
+  if (resume_from === null) {
+    initialize_workspace(config.workspace);
+    write_resolved_config(config);
+  } else {
+    initialize_workspace(config.workspace, { preserve: true });
+  }
+  report_worktree_fate(config, renderer);
+  const branch = worktree_branch(config.run_id);
+  const fate = worktree_fate(config);
+  const outcome = await with_worktree(
+    {
+      enabled: config.worktree,
+      workspace: config.workspace,
+      branch,
+      log: (message) => renderer.info(message),
+      // The one case teardown must keep rather than force-delete: a converged run
+      // that integrated nothing, whose only copy of its work is the worktree.
+      salvage: (result) => fate === "salvage" && result.status === "success"
+    },
+    async () => {
+      const baseline = capture_baseline(build_root(config.workspace, config.worktree));
+      const result = await run_loop(config, deps, resume_from, null, baseline);
+      if (fate === "integrate" && result.status === "success") {
+        integrate_worktree(config.workspace, branch, `volley run ${config.run_id}: integrate worktree (squash)`);
+        renderer.info(`worktree: squash-merged ${branch} onto the workspace branch`);
+      }
+      return result;
+    }
+  );
+  if (outcome.kept_path !== null) {
+    renderer.warn(
+      `worktree: could not commit this run's work onto ${branch}, so the checkout at ${outcome.kept_path} was left standing rather than deleted \u2014 its files are intact, and the next --worktree run rotates the directory aside instead of destroying it.`
+    );
+  }
+  if (outcome.salvaged_branch === null) return outcome.value;
+  renderer.info(
+    `worktree: this run was not integrated; its work is preserved on branch ${outcome.salvaged_branch} (git switch ${outcome.salvaged_branch}, or cherry-pick it).`
+  );
+  const salvaged = { ...outcome.value, salvaged_branch: outcome.salvaged_branch };
+  write_run_summary(config, salvaged);
+  return salvaged;
+}
+async function run_loop(config, deps, resume_from, bash_executor, baseline) {
+  const { renderer } = deps;
+  const engine = deps.engine ?? create_volley_engine({
+    workspace: config.workspace,
+    builder_provider: config.builder_provider,
+    critic_provider: config.critic_provider
+  });
+  const build = step("build", async (s, ctx) => {
+    const next = {
+      ...s,
+      iteration: s.iteration + 1,
+      iteration_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+      iteration_cost_usd: 0,
+      builder: null,
+      critic: null,
+      check: null,
+      verdict: null,
+      unmet_criteria: []
+    };
+    renderer.phase_start(next.iteration, "builder");
+    const built = await run_builder(
+      { engine, config, on_chunk: renderer.builder_chunk, warn: renderer.warn, bash_executor },
+      next,
+      ctx
+    );
+    renderer.phase_end(built.iteration, "builder", true);
+    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 changes = collect_changes({
+      root: build_root(config.workspace, config.worktree),
+      baseline,
+      gate_patterns: config.gate_paths
+    });
+    report_changes(config, renderer, changes);
+    if (config.git_checkpoints) {
+      git_checkpoint(
+        build_root(config.workspace, config.worktree),
+        `volley iter ${String(built.iteration)}: build`
+      );
+    }
+    return { ...built, changes };
+  });
+  const check = step("check", async (s, ctx) => {
+    if (cost_cap_hit(config, s)) {
+      renderer.warn("cost cap crossed during build; skipping check and critic");
+      return { ...s, check: skipped_check("cost_cap") };
+    }
+    renderer.phase_start(s.iteration, "check");
+    try {
+      const result = await execute_check(config, ctx.abort);
+      if (result.ran) {
+        renderer.phase_end(
+          s.iteration,
+          "check",
+          result.ok,
+          result.failing_slots.length > 0 ? `failing: ${result.failing_slots.join(", ")}` : void 0
+        );
+      } else {
+        renderer.info("no deterministic check configured; loop is critic-gated only");
+      }
+      return {
+        ...s,
+        check: result,
+        check_duration_ms: s.check_duration_ms + result.duration_ms
+      };
+    } catch (err) {
+      if (error_kind(err) === "check_error") throw err;
+      throw phase_error("check", s.iteration, err);
+    }
+  });
+  const critique = step("critique", async (s, ctx) => {
+    if (s.check !== null && !s.check.ran && cost_cap_hit(config, s)) {
+      return s;
+    }
+    renderer.phase_start(s.iteration, "critic");
+    const critiqued = await run_critic(
+      { engine, config, on_chunk: renderer.critic_chunk },
+      s,
+      ctx
+    );
+    renderer.phase_end(
+      critiqued.iteration,
+      "critic",
+      critiqued.verdict === "approved",
+      critiqued.verdict ?? void 0
+    );
+    renderer.cost_line(
+      critiqued.iteration,
+      "critic",
+      critiqued.critic?.cost_usd ?? null,
+      critiqued.total_cost_usd
+    );
+    return critiqued;
+  });
+  const record = step("record", (s) => {
+    archive_iteration(config, s);
+    write_run_summary(config, run_result_from_state(config, s, "running", null));
+    if (config.git_checkpoints) {
+      git_checkpoint(
+        build_root(config.workspace, config.worktree),
+        `volley iter ${String(s.iteration)}: critique (${s.verdict ?? "skipped"})`
+      );
+    }
+    return s;
+  });
+  const flow = loop({
+    name: "volley",
+    init: (input) => input.resume_from ?? initial_state(),
+    body: sequence([build, check, critique, record]),
+    guard: step("gate", (s) => gate(config, s)),
+    finish: (s) => s,
+    max_rounds: config.max_iterations - (resume_from?.iteration ?? 0)
+  });
+  try {
+    const { value, converged } = await run(
+      flow,
+      { resume_from },
+      {
+        trajectory: filesystem_logger({
+          output_path: volley_path(config.workspace, "trajectory.jsonl")
+        }),
+        ...deps.abort !== void 0 ? { abort: deps.abort } : {},
+        ...deps.install_signal_handlers !== void 0 ? { install_signal_handlers: deps.install_signal_handlers } : {}
+      }
+    );
+    const status = status_of(value, converged);
+    const result = run_result_from_state(config, value, status, (/* @__PURE__ */ new Date()).toISOString());
+    write_run_summary(config, result);
+    return result;
+  } catch (err) {
+    finalize_failed_run(config, err);
+    throw err;
+  } finally {
+    await engine.dispose();
+  }
+}
+function finalize_failed_run(config, err) {
+  const kind = error_kind(err);
+  const cause = kind === "phase_error" ? error_kind(err.cause) : null;
+  const status = kind === "aborted_error" || cause === "aborted_error" ? "interrupted" : "error";
+  try {
+    const summary_path = volley_path(config.workspace, "summary.json");
+    const prior = existsSync11(summary_path) ? JSON.parse(readFileSync11(summary_path, "utf8")) : run_result_from_state(config, initial_state(), status, null);
+    write_run_summary(config, {
+      ...prior,
+      status,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch {
+  }
+}
+
+// src/matrix.ts
+var EXIT_MATRIX_INCOMPLETE = 1;
+var DEFAULT_REPEAT = 1;
+function parse_model_list(value, flag) {
+  const items = (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  if (items.length === 0) {
+    throw config_error(`${flag} must be a comma-separated list of at least one model`);
+  }
+  return items;
+}
+function parse_repeat(value) {
+  if (value === void 0) return DEFAULT_REPEAT;
+  const repeat = Number(value);
+  if (!Number.isInteger(repeat) || repeat < 1) {
+    throw config_error(`--repeat must be a positive integer; got: ${String(value)}`);
+  }
+  return repeat;
+}
+function combo_config(base, combo) {
+  return {
+    ...base,
+    builder_model: combo.builder,
+    critic_model: combo.critic,
+    worktree: true,
+    discard_worktree: true
+  };
+}
+var default_run_combo = async (base, combo, renderer) => {
+  const config = resolve_config(combo_config(base, combo));
+  config.check_resolved = resolve_check_runner(config.check, config.workspace);
+  try {
+    const result = await run_volley(config, { renderer });
+    return build_run_summary(config, result);
+  } catch (err) {
+    const recovered = read_run_summary(config.workspace);
+    if (recovered === null) throw err;
+    return recovered;
+  }
+};
+function read_run_summary(workspace) {
+  const path = volley_path(workspace, "summary.json");
+  if (!existsSync12(path)) return null;
+  try {
+    return JSON.parse(readFileSync12(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var REASON_MAX = 44;
+function clip(text) {
+  const flat = text.replaceAll(/\s+/g, " ").trim();
+  return flat.length > REASON_MAX ? `${flat.slice(0, REASON_MAX - 1)}\u2026` : flat;
+}
+function last_failing_slots(summary) {
+  const ran = summary.comparison.check_trajectory.filter((point) => point.ran);
+  return ran.at(-1)?.failing_slots ?? [];
+}
+function failure_reason(summary) {
+  if (summary.status === "success") return null;
+  if (summary.status === "cost_cap_reached") return "cost cap";
+  if (summary.status === "interrupted") return "interrupted";
+  if (summary.status === "gate_edit_blocked") {
+    return clip(`gate edit: ${summary.comparison.gate_edits.join(", ")}`);
+  }
+  const failing = last_failing_slots(summary);
+  if (failing.length > 0) return clip(`check: ${failing.join(", ")}`);
+  const unmet = summary.comparison.unmet_criteria;
+  if (unmet.length === 1) return clip(`unmet: ${unmet[0] ?? ""}`);
+  if (unmet.length > 1) return clip(`unmet: ${String(unmet.length)} criteria`);
+  return summary.status === "error" ? "run error" : String(summary.status);
+}
+function attempt_from_summary(attempt, summary) {
+  const c = summary.comparison;
+  return {
+    attempt,
+    status: summary.status,
+    converged: summary.status === "success",
+    iterations_to_converge: c.iterations_to_converge,
+    wall_clock_ms: c.wall_clock_ms,
+    total_cost_usd: c.total_cost_usd,
+    final_verdict: c.final_verdict,
+    failing_slots: last_failing_slots(summary),
+    unmet_criteria: c.unmet_criteria,
+    gate_edits: c.gate_edits,
+    critic_degraded: c.critic_degraded,
+    tool_calls: c.local_salvage.tool_calls,
+    salvaged_tool_calls: c.local_salvage.salvaged_tool_calls,
+    error: null,
+    reason: failure_reason(summary)
+  };
+}
+function broke_attempt(attempt, message) {
+  return {
+    attempt,
+    status: "broke",
+    converged: false,
+    iterations_to_converge: null,
+    wall_clock_ms: null,
+    total_cost_usd: null,
+    final_verdict: null,
+    failing_slots: [],
+    unmet_criteria: [],
+    gate_edits: [],
+    critic_degraded: false,
+    tool_calls: 0,
+    salvaged_tool_calls: 0,
+    error: message,
+    reason: clip(`broke: ${message}`)
+  };
+}
+function mean(values) {
+  if (values.length === 0) return null;
+  return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function defined_numbers(values) {
+  return values.filter((value) => value !== null);
+}
+function aggregate_row(combo, attempts) {
+  const converged = attempts.filter((attempt) => attempt.converged);
+  const tool_calls = attempts.reduce((total, attempt) => total + attempt.tool_calls, 0);
+  const salvaged = attempts.reduce((total, attempt) => total + attempt.salvaged_tool_calls, 0);
+  const gate_edits = new Set(attempts.flatMap((attempt) => attempt.gate_edits));
+  return {
+    builder: combo.builder,
+    critic: combo.critic,
+    runs: attempts.length,
+    converged: converged.length,
+    mean_iterations: mean(defined_numbers(converged.map((a) => a.iterations_to_converge))),
+    mean_wall_clock_ms: mean(defined_numbers(attempts.map((a) => a.wall_clock_ms))),
+    mean_cost_usd: mean(defined_numbers(attempts.map((a) => a.total_cost_usd))),
+    salvage_rate: tool_calls === 0 ? null : salvaged / tool_calls,
+    critic_degraded: attempts.some((attempt) => attempt.critic_degraded),
+    gate_edits: [...gate_edits].toSorted(),
+    reason: attempts.findLast((attempt) => !attempt.converged)?.reason ?? null,
+    attempts
+  };
+}
+function cross_product(builders, critics) {
+  return builders.flatMap((builder) => critics.map((critic) => ({ builder, critic })));
+}
+function combo_dir(matrix_dir, combo) {
+  return join9(matrix_dir, `${slug(combo.builder)}__${slug(combo.critic)}`);
+}
+function slug(model) {
+  return model.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function persist_attempt(matrix_dir, combo, attempt, summary) {
+  const dir = join9(combo_dir(matrix_dir, combo), `run-${String(attempt).padStart(2, "0")}`);
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync5(join9(dir, "summary.json"), `${JSON.stringify(summary, null, 2)}
+`);
+}
+function persist_matrix(matrix_dir, rows) {
+  mkdirSync4(matrix_dir, { recursive: true });
+  const path = join9(matrix_dir, "matrix.json");
+  writeFileSync5(path, `${JSON.stringify({ combos: rows }, null, 2)}
+`);
+  return path;
+}
+async function run_combo_attempts(options) {
+  const { combo, renderer, repeat, tag } = options;
+  const attempts = [];
+  let ok = true;
+  for (let attempt = 1; attempt <= repeat; attempt += 1) {
+    const label = repeat === 1 ? tag : `${tag} run ${String(attempt)}/${String(repeat)}`;
+    renderer.info(`${label}: builder=${combo.builder} critic=${combo.critic}`);
+    try {
+      const summary = await options.run_combo(options.base, combo, renderer, attempt);
+      persist_attempt(options.matrix_dir, combo, attempt, summary);
+      const result = attempt_from_summary(attempt, summary);
+      attempts.push(result);
+      renderer.info(`${label}: \u2192 ${result.status}${result.reason === null ? "" : ` (${result.reason})`}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      attempts.push(broke_attempt(attempt, message));
+      ok = false;
+      renderer.warn(`${label}: produced no summary: ${message}`);
+    }
+  }
+  return { attempts, ok };
+}
+async function run_matrix(options) {
+  const { base, matrix_dir, renderer } = options;
+  const run_combo = options.run_combo ?? default_run_combo;
+  const repeat = options.repeat ?? DEFAULT_REPEAT;
+  const combos = cross_product(options.builders, options.critics);
+  renderer.info(
+    `matrix: ${String(combos.length)} seat(s) \xD7 ${String(repeat)} run(s) = ${String(combos.length * repeat)} run(s), serially`
+  );
+  const rows = [];
+  let ok = true;
+  let index = 0;
+  for (const combo of combos) {
+    index += 1;
+    const outcome = await run_combo_attempts({
+      base,
+      matrix_dir,
+      renderer,
+      combo,
+      repeat,
+      run_combo,
+      tag: `matrix [${String(index)}/${String(combos.length)}]`
+    });
+    ok = ok && outcome.ok;
+    rows.push(aggregate_row(combo, outcome.attempts));
+  }
+  renderer.info(render_matrix_table(rows));
+  renderer.info(`matrix: wrote ${persist_matrix(matrix_dir, rows)}`);
+  return { rows, ok };
+}
+var MATRIX_COLUMNS = [
+  "builder",
+  "critic",
+  "pass",
+  "iters",
+  "wall",
+  "cost",
+  "salvage",
+  "flags",
+  "why"
+];
+function format_wall(ms) {
+  return ms === null ? "\u2014" : `${(ms / 1e3).toFixed(1)}s`;
+}
+function format_rate(rate) {
+  return rate === null ? "\u2014" : `${String(Math.round(rate * 100))}%`;
+}
+function format_cost(usd) {
+  return usd === null ? "\u2014" : `$${usd.toFixed(2)}`;
+}
+function format_iterations(iterations) {
+  return iterations === null ? "\u2014" : iterations.toFixed(1);
+}
+function format_flags(row) {
+  const flags = [
+    row.critic_degraded ? "deg" : null,
+    row.gate_edits.length > 0 ? "gate" : null
+  ].filter((flag) => flag !== null);
+  return flags.length === 0 ? "\u2014" : flags.join(",");
+}
+function cell_values(row) {
+  return [
+    row.builder,
+    row.critic,
+    `${String(row.converged)}/${String(row.runs)}`,
+    format_iterations(row.mean_iterations),
+    format_wall(row.mean_wall_clock_ms),
+    format_cost(row.mean_cost_usd),
+    format_rate(row.salvage_rate),
+    format_flags(row),
+    row.reason ?? "\u2014"
+  ];
+}
+function render_matrix_table(rows) {
+  const header = [...MATRIX_COLUMNS];
+  const body = rows.map(cell_values);
+  const widths = header.map(
+    (title, col) => Math.max(title.length, ...body.map((cells) => (cells[col] ?? "").length))
+  );
+  const render_line = (cells) => cells.map((cell, col) => cell.padEnd(widths[col] ?? 0)).join("  ").trimEnd();
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  return [render_line(header), separator, ...body.map(render_line)].join("\n");
+}
+
+// src/preflight.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { existsSync as existsSync13 } from "fs";
+import { join as join10, resolve as resolve4 } from "path";
+var REQUIRED_TOOLCHAIN = ["node", "pnpm", "git"];
+var ENDPOINT_PROBE_TIMEOUT_MS = 3e3;
+function is_local_builder(provider) {
+  return provider === "ollama" || provider === "lmstudio";
+}
+function is_local_critic(provider) {
+  return provider === "ollama" || provider === "lmstudio";
+}
+function model_endpoint(provider, env) {
+  if (provider === "ollama") return resolve_ollama_base_url(env);
+  const lmstudio_url = env["VOLLEY_LMSTUDIO_URL"] ?? DEFAULT_LMSTUDIO_URL;
+  return cross_to_host_gateway(lmstudio_url, env);
+}
+function toolchain_missing(tools = REQUIRED_TOOLCHAIN) {
+  return tools.filter((tool) => {
+    const result = spawnSync5(tool, ["--version"], { stdio: "ignore" });
+    return result.error !== void 0 || result.status !== 0;
+  });
+}
+function worktree_creatable(workspace) {
+  const repo = resolve4(workspace);
+  const version = spawnSync5("git", ["--version"], { stdio: "ignore" });
+  if (version.error !== void 0 || version.status !== 0) {
+    return { ok: false, detail: "git is not available" };
+  }
+  if (!existsSync13(resolve4(repo, ".git"))) {
+    return { ok: false, detail: `${repo} is not a git repository` };
+  }
+  const inside = spawnSync5("git", ["-C", repo, "rev-parse", "--is-inside-work-tree"], {
+    encoding: "utf8"
+  });
+  if (inside.status !== 0 || (inside.stdout ?? "").trim() !== "true") {
+    return { ok: false, detail: `${repo} is not a git work tree` };
+  }
+  return { ok: true, detail: repo };
+}
+async function endpoint_reachable(url, timeout_ms = ENDPOINT_PROBE_TIMEOUT_MS) {
+  try {
+    await fetch(url, { method: "GET", signal: AbortSignal.timeout(timeout_ms) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function default_canary_engine(config, env) {
+  return create_volley_engine({
+    workspace: config.workspace,
+    critic_provider: config.critic_provider,
+    env
+  });
+}
+function report_gate_posture(config, renderer) {
+  const root = build_root(config.workspace, config.worktree);
+  const detectable = capture_baseline(root) !== null || existsSync13(join10(root, ".git"));
+  if (config.fail_on_gate_edit && !detectable) {
+    renderer.warn(
+      "--fail-on-gate-edit is set, but the build root is not a git repository, so there is no baseline to diff against and gate edits cannot be detected. The flag will not fire: run against a git workspace to get the refusal you asked for."
+    );
+    return;
+  }
+  if (config.gate_paths.length === 0) {
+    renderer.info("gate: no gate paths configured; builder edits to tests and check config are not flagged.");
+    return;
+  }
+  renderer.info(
+    `gate: watching ${String(config.gate_paths.length)} path pattern(s)` + (config.fail_on_gate_edit ? " \u2014 a builder edit to any of them halts the run (--fail-on-gate-edit, exit 8)." : " \u2014 edits are reported to the critic and recorded in the summary, not refused.")
+  );
+}
+function run_checkride_doctor(workspace) {
+  const doctor = spawnSync5("pnpm", ["exec", "checkride", "doctor"], {
+    cwd: workspace,
+    stdio: ["ignore", "ignore", "inherit"]
+  });
+  return doctor.error === void 0 && doctor.status === 0;
+}
+async function preflight(config, renderer, env, probes = {}) {
+  const provider = config.builder_provider;
+  const local_builder = is_local_builder(provider);
+  renderer.info(`dry run: config valid (run ${config.run_id})`);
+  renderer.info(`workspace: ${config.workspace}`);
+  renderer.info(`check: ${config.check} (resolved: ${config.check_resolved})`);
+  renderer.info(`builder model: ${config.builder_model} (provider: ${config.builder_provider})`);
+  renderer.info(`builder max steps: ${config.builder_max_steps}`);
+  if (local_builder) {
+    const contained = env["VOLLEY_CONTAINED"] === "1" || env["VOLLEY_CONTAINED"] === "true";
+    renderer.info(
+      contained ? "containment: inside the sandbox container (VOLLEY_CONTAINED)" : "containment: uncontained on the host (--allow-unsandboxed-builder)"
+    );
+    renderer.info(`sandbox image: ${config.sandbox_image}`);
+  }
+  renderer.info(
+    `critic: ${config.critic_preset}${config.critic_prompt_path !== null ? ` (${config.critic_prompt_path})` : ""}`
+  );
+  renderer.info(`critic model: ${config.critic_model} (provider: ${config.critic_provider})`);
+  report_worktree_fate(config, renderer);
+  report_gate_posture(config, renderer);
+  if (config.check_resolved === "checkride") {
+    const doctor = probes.checkride_doctor ?? run_checkride_doctor;
+    if (!doctor(config.workspace)) {
+      renderer.error("checkride doctor failed; fix the workspace check pipeline before running");
+      return EXIT_CONFIG_ERROR;
+    }
+    renderer.info("checkride doctor: ok");
+  }
+  if (is_local_builder(provider)) {
+    const missing = (probes.toolchain_missing ?? toolchain_missing)(REQUIRED_TOOLCHAIN);
+    if (missing.length > 0) {
+      renderer.error(`preflight: missing toolchain in the sandbox: ${missing.join(", ")}`);
+      return EXIT_CONFIG_ERROR;
+    }
+    renderer.info(`toolchain: ${REQUIRED_TOOLCHAIN.join(", ")} present`);
+    if (config.worktree) {
+      const worktree = (probes.worktree_creatable ?? worktree_creatable)(config.workspace);
+      if (!worktree.ok) {
+        renderer.error(`preflight: worktree not creatable: ${worktree.detail}`);
+        return EXIT_CONFIG_ERROR;
+      }
+      renderer.info(`worktree: creatable (${worktree.detail})`);
+    }
+    const endpoint = model_endpoint(provider, env);
+    const reachable = await (probes.endpoint_reachable ?? endpoint_reachable)(endpoint);
+    if (!reachable) {
+      renderer.error(`preflight: host LLM endpoint unreachable: ${endpoint}`);
+      return EXIT_CONFIG_ERROR;
+    }
+    renderer.info(`host LLM endpoint: reachable (${endpoint})`);
+  }
+  if (is_local_critic(config.critic_provider)) {
+    const engine = (probes.canary_engine ?? default_canary_engine)(config, env);
+    const seat = `model '${config.critic_model}' in the critic seat (provider: ${config.critic_provider})`;
+    try {
+      const canary = await critic_canary(engine, config, env);
+      if (canary.outcome === "failed") {
+        renderer.error(`preflight: critic canary failed \u2014 ${seat}: ${canary.detail}`);
+        return EXIT_CONFIG_ERROR;
+      }
+      if (canary.outcome === "degraded") {
+        renderer.warn(
+          `critic canary: ${seat} died on the tool-bearing call (${canary.detail}) but survived tool-less; a real run will likely degrade to the tool-less fallback and be marked critic_degraded`
+        );
+      } else {
+        renderer.info(`critic canary: ok (${seat} answered through the real tool wiring)`);
+      }
+    } finally {
+      await engine.dispose();
+    }
+  }
+  return EXIT_SUCCESS;
+}
+
+// src/render/format.ts
+import pc from "picocolors";
+var GLYPH_TOOL = "\u{1F527}";
+var GLYPH_OK = "\u2705";
+var GLYPH_ERR = "\u274C";
+var GLYPH_COST = "\u{1F4B0}";
+var GLYPH_PHASE_START = "\u25B6";
+var GLYPH_PHASE_OK = "\u2713";
+var GLYPH_PHASE_FAIL = "\u2717";
+var VERBOSE_TRUNCATE_CHARS = 4e3;
+function colors_enabled(env = process.env, is_tty = process.stderr.isTTY === true) {
+  if (env["NO_COLOR"] !== void 0 || env["VOLLEY_NO_COLOR"] !== void 0) {
+    return false;
+  }
+  return is_tty;
+}
+function paint(role, text, color) {
+  if (!color) return text;
+  switch (role) {
+    case "builder":
+      return pc.cyan(text);
+    case "critic":
+      return pc.yellow(text);
+    case "check":
+      return pc.green(text);
+    case "cost":
+      return pc.magenta(text);
+    case "error":
+      return pc.bold(pc.red(text));
+  }
+}
+function dim(text, color) {
+  return color ? pc.dim(text) : text;
+}
+function truncate(text, max, pointer) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}
+\u2026 [truncated at ${String(max)} chars; ${pointer}]`;
+}
+function format_usd(value) {
+  return value === null ? "$?" : `$${value.toFixed(3)}`;
+}
+function summarize_value(value, max = 120) {
+  let text;
+  try {
+    text = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+  } catch {
+    text = String(value);
+  }
+  const flat = text.replace(/\s+/g, " ");
+  return flat.length > max ? `${flat.slice(0, max)}\u2026` : flat;
+}
+
+// src/render/renderer.ts
+function create_renderer(options) {
+  const write = options.write ?? ((text) => process.stderr.write(text));
+  const { mode, color } = options;
+  const silent = mode === "json";
+  const streaming = mode === "default" || mode === "verbose";
+  let mid_line = false;
+  const line = (text) => {
+    if (silent) return;
+    write(`${mid_line ? "\n" : ""}${text}
+`);
+    mid_line = false;
+  };
+  const chunk_renderer = (role) => (chunk) => {
+    if (!streaming) return;
+    switch (chunk.kind) {
+      case "text": {
+        write(paint(role, chunk.text, color));
+        mid_line = !chunk.text.endsWith("\n");
+        return;
+      }
+      case "reasoning": {
+        if (!options.show_thinking) return;
+        write(dim(chunk.text, color));
+        mid_line = !chunk.text.endsWith("\n");
+        return;
+      }
+      case "tool_call_end": {
+        const summary = mode === "verbose" ? truncate(
+          JSON.stringify(chunk.input, null, 2) ?? "",
+          VERBOSE_TRUNCATE_CHARS,
+          "see .volley/trajectory.jsonl"
+        ) : summarize_value(chunk.input);
+        line(`${GLYPH_TOOL} ${paint(role, chunk.id, color)} ${summary}`);
+        return;
+      }
+      case "tool_result": {
+        const ok = chunk.error === void 0;
+        if (mode === "verbose") {
+          const body = ok ? summarize_output(chunk.output) : chunk.error?.message ?? "";
+          line(`${ok ? GLYPH_OK : GLYPH_ERR} ${truncate(body, VERBOSE_TRUNCATE_CHARS, "see .volley/trajectory.jsonl")}`);
+        } else {
+          line(`${ok ? GLYPH_OK : GLYPH_ERR} ${ok ? "" : summarize_value(chunk.error?.message)}`);
+        }
+        return;
+      }
+      case "tool_call_start": {
+        line(`${GLYPH_TOOL} ${paint(role, chunk.name, color)} \u2026`);
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  return {
+    builder_chunk: chunk_renderer("builder"),
+    critic_chunk: chunk_renderer("critic"),
+    phase_start: (iteration, phase) => {
+      if (mode === "json") return;
+      line(paint(phase, `${GLYPH_PHASE_START} [iter ${String(iteration)}] ${phase}`, color));
+    },
+    phase_end: (iteration, phase, ok, detail) => {
+      if (mode === "json") return;
+      const glyph = ok ? GLYPH_PHASE_OK : GLYPH_PHASE_FAIL;
+      const suffix = detail !== void 0 ? ` \u2014 ${detail}` : "";
+      line(paint(phase, `${glyph} [iter ${String(iteration)}] ${phase}${suffix}`, color));
+    },
+    cost_line: (iteration, phase, phase_cost, run_total) => {
+      if (mode === "json") 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
+        )
+      );
+    },
+    info: (message) => {
+      line(message);
+    },
+    warn: (message) => {
+      line(paint("critic", `warning: ${message}`, color));
+    },
+    error: (message) => {
+      if (silent) {
+        write(`error: ${message}
+`);
+        return;
+      }
+      line(paint("error", `error: ${message}`, color));
+    },
+    final_summary: (result) => {
+      if (silent) return;
+      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(
+        `tokens: ${String(result.total_usage.input_tokens)} in / ${String(result.total_usage.output_tokens)} out`
+      );
+    }
+  };
+}
+function summarize_output(output) {
+  if (typeof output === "string") return output;
+  try {
+    return JSON.stringify(output) ?? "";
+  } catch {
+    return String(output);
+  }
+}
+
+// src/cli.ts
+function package_version() {
+  let dir = dirname4(fileURLToPath3(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const manifest = join11(dir, "package.json");
+    if (existsSync14(manifest)) {
+      try {
+        const version = JSON.parse(readFileSync13(manifest, "utf8")).version;
+        if (typeof version === "string") return version;
+      } catch {
+      }
+    }
+    dir = dirname4(dir);
+  }
+  return "unknown";
+}
+function parse_glob_list(value) {
+  return value.split(",").map((glob) => glob.trim()).filter((glob) => glob.length > 0);
+}
+function render_mode(config) {
+  if (config.json) return "json";
+  if (config.quiet) return "quiet";
+  if (config.verbose) return "verbose";
+  return "default";
+}
+function make_renderer(config) {
+  return create_renderer({
+    mode: render_mode(config),
+    show_thinking: config.show_thinking,
+    color: colors_enabled(),
+    max_cost_usd: config.max_cost_usd
+  });
+}
+function warn_api_key_meter(renderer) {
+  if (process.env["ANTHROPIC_API_KEY"] !== void 0) {
+    renderer.warn(
+      "ANTHROPIC_API_KEY is set: the claude CLI will bill this run against the API key, not a subscription. Know which meter you are on."
+    );
+  }
+}
+function warn_unsandboxed_builder(config, renderer) {
+  if (config.builder_provider !== "claude_cli" && config.allow_unsandboxed_builder) {
+    renderer.warn(
+      `UNSANDBOXED BUILDER: '${config.builder_provider}' runs a local model with a real bash (write + exec) directly on this machine in ${config.workspace} \u2014 no container isolation. Proceeding because --allow-unsandboxed-builder / VOLLEY_ALLOW_UNSANDBOXED_BUILDER is set; run volley inside its sandbox container for blast-radius containment instead.`
+    );
+  }
+}
+function merge_flags(base, flags) {
+  return {
+    ...base,
+    ...flags.prompt !== void 0 ? { prompt: flags.prompt } : {},
+    ...flags.workspace !== void 0 ? { workspace: flags.workspace } : {},
+    ...flags.criteria !== void 0 ? { criteria: flags.criteria } : {},
+    ...flags.check !== void 0 ? { check: flags.check } : {},
+    ...flags.builderModel !== void 0 ? { builder_model: flags.builderModel } : {},
+    ...flags.builderProvider !== void 0 ? { builder_provider: flags.builderProvider } : {},
+    ...flags.builderMaxSteps !== void 0 ? { builder_max_steps: Number(flags.builderMaxSteps) } : {},
+    ...flags.allowUnsandboxedBuilder === true ? { allow_unsandboxed_builder: true } : {},
+    ...flags.criticModel !== void 0 ? { critic_model: flags.criticModel } : {},
+    ...flags.criticProvider !== void 0 ? { critic_provider: flags.criticProvider } : {},
+    ...flags.builderPermissionMode !== void 0 ? { builder_permission_mode: flags.builderPermissionMode } : {},
+    ...flags.critic !== void 0 ? { critic: flags.critic } : {},
+    ...flags.maxIterations !== void 0 ? { max_iterations: Number(flags.maxIterations) } : {},
+    ...flags.maxCostUsd !== void 0 ? { max_cost_usd: Number(flags.maxCostUsd) } : {},
+    ...flags.git === true ? { git_checkpoints: true } : {},
+    ...flags.worktree === true ? { worktree: true } : {},
+    ...flags.discardWorktree === true ? { discard_worktree: true } : {},
+    ...flags.gatePaths !== void 0 ? { gate_paths: parse_glob_list(flags.gatePaths) } : {},
+    ...flags.failOnGateEdit === true ? { fail_on_gate_edit: true } : {},
+    ...flags.sandboxImage !== void 0 ? { sandbox_image: flags.sandboxImage } : {},
+    ...flags.dryRun === true ? { dry_run: true } : {},
+    ...flags.json === true ? { json: true } : {},
+    ...flags.verbose === true ? { verbose: true } : {},
+    ...flags.quiet === true ? { quiet: true } : {},
+    ...flags.thinking === false ? { show_thinking: false } : {}
+  };
+}
+function emit_result(config, result, renderer) {
+  renderer.final_summary(result);
+  if (config.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  }
+  return exit_code_for_status(result.status);
+}
+function report_error(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`volley: ${message}
+`);
+  if (error_kind(err) === "phase_error") {
+    const cause = err.cause;
+    if (cause instanceof Error && cause.message !== message) {
+      process.stderr.write(`  cause: ${cause.message}
+`);
+    }
+  }
+  return exit_code_for_error(err);
+}
+async function main(argv) {
+  const cli = cac("volley");
+  let exit_code = EXIT_SUCCESS;
+  cli.command("", "Run the builder/critic loop").option("--prompt <prompt>", "Task prompt (string or @file)").option("--workspace <path>", "Workspace directory (must exist and be writable)").option("--criteria <criteria>", "Acceptance criteria (string or @file)").option("--check <check>", `auto | none | shell command (default: ${DEFAULT_CHECK})`).option("--builder-model <model>", "Builder model").option("--builder-provider <name>", "claude_cli | ollama | lmstudio (default: claude_cli)").option("--builder-max-steps <n>", "Local builder tool-loop step cap per iteration (default: 50)").option("--allow-unsandboxed-builder", "Permit a local builder to run without a sandbox (real host bash + write)").option("--critic-model <model>", "Critic model").option("--critic-provider <name>", "claude_cli | ollama | lmstudio (default: claude_cli)").option("--builder-permission-mode <mode>", "acceptEdits | bypassPermissions").option("--critic <critic>", "reviewer | optimizer | researcher | path to prompt file").option("--max-iterations <n>", "Iteration cap").option("--max-cost-usd <usd>", "Hard USD ceiling, enforced in the loop guard").option("--git", "Auto-commit after each phase (workspace must be a git repo)").option("--worktree", "Isolate the builder run in a per-run git worktree (workspace must be a git repo)").option("--discard-worktree", "Throw a --worktree run's effects away at teardown instead of keeping them on the run branch").option("--gate-paths <globs>", "Comma-separated globs naming the gate (tests, fixtures, check config); replaces the defaults").option("--fail-on-gate-edit", "Halt the run if the builder edits a gate path (exit 8) instead of reporting it").option("--sandbox-image <tag>", `Container image for the local-builder sandbox (default: ${DEFAULT_SANDBOX_IMAGE})`).option("--dry-run", "Validate config (and checkride doctor) without running").option("--config <path>", "TypeScript config file exporting a VolleyConfig").option("--json", "Machine mode: final summary JSON on stdout, no streaming").option("--verbose", "Show full tool inputs/outputs (truncated at 4000 chars)").option("--quiet", "Only phase transitions, cost updates, and the final summary").option("--no-thinking", "Hide reasoning chunks (still recorded in the trajectory)").action(async (flags) => {
+    const base = flags.config !== void 0 ? await load_config_file(flags.config) : {};
+    const merged = merge_flags(base, flags);
+    const config = resolve_config(merged);
+    config.check_resolved = resolve_check_runner(config.check, config.workspace);
+    const renderer = make_renderer(config);
+    warn_api_key_meter(renderer);
+    warn_unsandboxed_builder(config, renderer);
+    if (merged.dry_run === true) {
+      exit_code = await preflight(config, renderer, process.env);
+      return;
+    }
+    const result = await run_volley(config, { renderer });
+    exit_code = emit_result(config, result, renderer);
+  });
+  cli.command("resume <run_id>", "Resume a run from its last completed iteration").option("--workspace <path>", "Workspace containing the .volley run state", {
+    default: "."
+  }).option("--json", "Machine mode: final summary JSON on stdout, no streaming").option("--verbose", "Show full tool inputs/outputs").option("--quiet", "Only phase transitions, cost updates, and the final summary").option("--no-thinking", "Hide reasoning chunks").action(async (run_id, flags) => {
+    const workspace = flags.workspace ?? ".";
+    const resume = load_resume_state(workspace, run_id);
+    const merged = merge_flags(resume.raw_config, {
+      ...flags.json === true ? { json: true } : {},
+      ...flags.verbose === true ? { verbose: true } : {},
+      ...flags.quiet === true ? { quiet: true } : {},
+      ...flags.thinking === false ? { thinking: false } : {}
+    });
+    const config = resolve_config(merged, {
+      run_id: resume.run_id,
+      started_at: resume.started_at
+    });
+    config.check_resolved = resolve_check_runner(config.check, config.workspace);
+    if (resume.iterations_completed >= config.max_iterations) {
+      throw config_error(
+        `run already completed ${String(resume.iterations_completed)} of ${String(config.max_iterations)} iterations`
+      );
+    }
+    const renderer = make_renderer(config);
+    warn_api_key_meter(renderer);
+    warn_unsandboxed_builder(config, renderer);
+    renderer.info(
+      `resuming run ${run_id} at iteration ${String(resume.iterations_completed + 1)}`
+    );
+    const result = await run_volley(config, { renderer }, resume.state);
+    exit_code = emit_result(config, result, renderer);
+  });
+  cli.command("matrix", "Sweep builder\xD7critic model combos serially over one config").option("--config <path>", "Base VolleyConfig (TS/JS): the task, workspace, providers, and caps held fixed").option("--builders <models>", "Comma-separated builder models to sweep").option("--critics <models>", "Comma-separated critic models to sweep").option("--workspace <path>", "Override the base config workspace").option("--repeat <n>", "Attempts per seat (default: 1); a pass rate needs more than one").option("--json", "Machine mode: aggregate JSON on stdout, no table").option("--verbose", "Show full builder/critic streams per combo").option("--quiet", "Per-combo phase transitions and the final table only").action(async (flags) => {
+    if (flags.config === void 0) {
+      throw config_error("volley matrix requires --config <path> (the base task to sweep)");
+    }
+    const builders = parse_model_list(flags.builders, "--builders");
+    const critics = parse_model_list(flags.critics, "--critics");
+    const repeat = parse_repeat(flags.repeat);
+    const base = await load_config_file(flags.config);
+    const merged = merge_flags(base, {
+      ...flags.workspace !== void 0 ? { workspace: flags.workspace } : {},
+      ...flags.json === true ? { json: true } : {},
+      ...flags.verbose === true ? { verbose: true } : {},
+      ...flags.quiet === true ? { quiet: true } : {}
+    });
+    const base_config = resolve_config({ ...merged, worktree: true, discard_worktree: true });
+    const renderer = make_renderer(base_config);
+    warn_api_key_meter(renderer);
+    warn_unsandboxed_builder(base_config, renderer);
+    const outcome = await run_matrix({
+      base: merged,
+      builders,
+      critics,
+      matrix_dir: join11(base_config.workspace, ".volley-matrix"),
+      renderer,
+      repeat
+    });
+    if (base_config.json) {
+      process.stdout.write(`${JSON.stringify({ combos: outcome.rows }, null, 2)}
+`);
+    }
+    exit_code = outcome.ok ? EXIT_SUCCESS : EXIT_MATRIX_INCOMPLETE;
+  });
+  cli.help();
+  cli.version(package_version());
+  try {
+    cli.parse(argv, { run: false });
+    await cli.runMatchedCommand();
+  } catch (err) {
+    return report_error(err);
+  }
+  return exit_code;
+}
+if (import.meta.main) {
+  const code = await main(process.argv);
+  process.exitCode = code;
+}
+export {
+  package_version,
+  warn_unsandboxed_builder
+};
+//# sourceMappingURL=cli.js.map