@robmclarty/volley 0.5.1

package/dist/index.js

@@ -0,0 +1,2659 @@
+// 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/orchestrator.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { loop, run, sequence, step } from "fascicle";
+import { filesystem_logger } from "fascicle/adapters";
+
+// src/builder.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join4 } 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 spawnSync2 } from "child_process";
+import { lookup as dns_lookup } from "dns";
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync } 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 readFileSync2, readdirSync, statSync as statSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join, 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 = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const abs = join(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 = readFileSync2(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 = readFileSync2(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, resolve4) {
+  return (hostname, options, callback) => {
+    resolve4(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, resolve4) {
+  const base = buildConnector({ lookup: guarded_lookup(is_forbidden, resolve4), 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 = spawnSync2(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`
+        );
+      }
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, input.content, "utf8");
+      return `wrote ${String(bytes)} bytes to ${input.path}`;
+    }
+  };
+  const edit_file = {
+    name: "edit_file",
+    description: "Replace one exact occurrence of old_str with new_str in a workspace file. old_str must match the file content exactly once \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 = readFileSync3(abs, "utf8");
+      const matches = count_occurrences(content, input.old_str);
+      if (matches === 0) {
+        return `error: old_str not found in ${input.path} (0 matches). No change made. Read the file and retry with an exact excerpt of its current content.`;
+      }
+      if (matches > 1) {
+        return `error: old_str matches ${String(matches)} times in ${input.path}. No change made. Include more surrounding context to make old_str unique.`;
+      }
+      writeFileSync(abs, content.replace(input.old_str, input.new_str), "utf8");
+      return `edit applied to ${input.path}`;
+    }
+  };
+  const bash = {
+    name: "bash",
+    description: `Run a shell command in the workspace and return its exit code, stdout, and stderr. Each call is independent \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/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/engine.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } 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 (!existsSync2(path)) {
+    throw config_error(`VOLLEY_PRICING_PATH not found: ${path}`);
+  }
+  try {
+    return JSON.parse(readFileSync4(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 existsSync4, renameSync as renameSync2, rmSync, symlinkSync } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+
+// src/workspace.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { spawnSync as spawnSync3 } 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()}`));
+  }
+  mkdirSync2(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
+  };
+  writeFileSync2(
+    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 = spawnSync3("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 = spawnSync3("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 = spawnSync3("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 = spawnSync3("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/worktree.ts
+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 (!existsSync4(join3(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 (existsSync4(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 = join3(repo, "node_modules");
+  if (existsSync4(modules) && !existsSync4(join3(path, "node_modules"))) {
+    symlinkSync(modules, join3(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 (existsSync4(path)) {
+    try {
+      rmSync(path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return outcome;
+}
+function salvage_worktree(repo, path, branch) {
+  if (existsSync4(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 = join4(dir, "src", "builder", "presets");
+    if (existsSync5(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 = readFileSync5(join4(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 existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join5 } 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 = join5(workspace, ".check", "summary.json");
+    if (!existsSync6(file)) throw err;
+    return parse_checkride_summary(readFileSync6(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 = join5(workspace, ".check", file);
+    if (!existsSync6(path)) {
+      return { slot: check.name, path: null, content: "(no artifact found)", truncated: false };
+    }
+    const raw = readFileSync6(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/iteration.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { basename, join as join6 } from "path";
+function write_json(path, value) {
+  writeFileSync3(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function persist_verdict_files(workspace, feedback, verdict) {
+  writeFileSync3(volley_path(workspace, "feedback.md"), feedback.endsWith("\n") ? feedback : `${feedback}
+`);
+  writeFileSync3(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);
+  mkdirSync3(join6(dir, "check"), { recursive: true });
+  if (state.verdict !== null && state.feedback !== null) {
+    persist_verdict_files(config.workspace, state.feedback, state.verdict);
+    writeFileSync3(join6(dir, "feedback.md"), readFileSync7(volley_path(config.workspace, "feedback.md")));
+    writeFileSync3(join6(dir, "verdict"), `${state.verdict}
+`);
+  }
+  const check = state.check;
+  if (check !== null && check.ran) {
+    if (check.runner === "checkride") {
+      if (check.summary !== void 0) {
+        write_json(join6(dir, "check", "summary.json"), check.summary);
+      }
+      for (const artifact of check.detail) {
+        if (artifact.path !== null && existsSync7(artifact.path)) {
+          writeFileSync3(join6(dir, "check", basename(artifact.path)), readFileSync7(artifact.path));
+        }
+      }
+    } else {
+      writeFileSync3(join6(dir, "check", "check.log"), check.log ?? "");
+      writeFileSync3(join6(dir, "check", "check.exit"), `${String(check.exit_code)}
+`);
+    }
+  }
+  const completed_at = (/* @__PURE__ */ new Date()).toISOString();
+  write_json(join6(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
+  };
+}
+
+// src/summary.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8, 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 (!existsSync8(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 (!existsSync8(path)) continue;
+    try {
+      archives.push(JSON.parse(readFileSync8(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 existsSync9, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname3, join as join7 } 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 = join7(dir, "src", "critic", "presets");
+    if (existsSync9(candidate)) return candidate;
+    const local = join7(dir, "presets");
+    if (existsSync9(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 ? readFileSync9(config.critic_prompt_path, "utf8") : readFileSync9(join7(presets_dir2(), `${config.critic_preset}.md`), "utf8");
+  const append_file = config.critic_provider === "claude_cli" ? "harness_append.md" : "harness_append_local.md";
+  const append = readFileSync9(join7(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");
+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 = existsSync10(summary_path) ? JSON.parse(readFileSync10(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/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 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/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;
+}
+export {
+  EXIT_BUDGET_EXHAUSTED,
+  EXIT_BUILDER_ERROR,
+  EXIT_CHECK_ERROR,
+  EXIT_CONFIG_ERROR,
+  EXIT_COST_CAP,
+  EXIT_CRITIC_ERROR,
+  EXIT_INTERRUPTED,
+  EXIT_SUCCESS,
+  create_renderer,
+  exit_code_for_error,
+  exit_code_for_status,
+  expand_at_file,
+  gate,
+  initial_state,
+  load_config_file,
+  resolve_config,
+  run_volley,
+  status_of,
+  verdict_schema
+};
+//# sourceMappingURL=index.js.map