@robmclarty/volley 0.5.1 → 0.5.3

package/dist/index.js

@@ -400,13 +400,93 @@ function resolve_config(raw, options = {}) {
 
 // src/orchestrator.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { loop, run, sequence, step } from "fascicle";
+import { run } from "fascicle";
 import { filesystem_logger } from "fascicle/adapters";
 
+// src/engine.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } 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(readFileSync2(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/flow.ts
+import { branch, fallback, loop, pipe, retry, sequence, step } from "fascicle";
+
 // 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";
+import { model_call } from "fascicle";
 
 // src/builder/context_check.ts
 var MIN_RECOMMENDED_NUM_CTX = 16384;
@@ -448,7 +528,7 @@ async function warn_small_local_context(provider, model, base_url, warn, abort)
 // 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 { mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { dirname } from "path";
 import { Readability } from "@mozilla/readability";
 import ipaddr from "ipaddr.js";
@@ -458,7 +538,7 @@ 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 { readFileSync as readFileSync3, 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;
@@ -538,7 +618,7 @@ function read_only_tools(workspace) {
     execute: (raw) => {
       const input = read_file_input.parse(raw);
       const abs = contain(workspace, input.path);
-      const content = readFileSync2(abs, "utf8");
+      const content = readFileSync3(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;
     }
@@ -557,7 +637,7 @@ function read_only_tools(workspace) {
         if (hits.length >= SEARCH_MAX_MATCHES) break;
         let content;
         try {
-          content = readFileSync2(file.abs, "utf8");
+          content = readFileSync3(file.abs, "utf8");
         } catch {
           continue;
         }
@@ -758,13 +838,13 @@ function extract_markdown(html) {
     body_markdown = "";
   }
   if (body_markdown.length < FETCH_MIN_EXTRACT_CHARS) {
-    let fallback = "";
+    let fallback2 = "";
     try {
-      fallback = turndown.turndown(html).trim();
+      fallback2 = turndown.turndown(html).trim();
     } catch {
-      fallback = "";
+      fallback2 = "";
     }
-    if (fallback.length > body_markdown.length) body_markdown = fallback;
+    if (fallback2.length > body_markdown.length) body_markdown = fallback2;
   }
   const prefix = title.length > 0 && !body_markdown.startsWith(`# ${title}`) ? `# ${title}
 
@@ -900,7 +980,7 @@ function builder_tools(workspace, options = {}) {
     execute: (raw) => {
       const input = edit_file_input.parse(raw);
       const abs = contain(workspace, input.path);
-      const content = readFileSync3(abs, "utf8");
+      const content = readFileSync4(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.`;
@@ -971,6 +1051,7 @@ ${note}` : note;
 }
 
 // src/cost.ts
+import { claude_cli_reported, throughput } from "fascicle";
 var EMPTY_USAGE = { input_tokens: 0, output_tokens: 0 };
 function add_usage(a, b) {
   const sum = {
@@ -988,30 +1069,24 @@ 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);
+function phase_record(result, model, duration_ms = result.timing?.duration_ms ?? 0) {
+  const rate = throughput(result);
   return {
     provider: result.model_resolved.provider,
     model,
-    session_id,
+    session_id: claude_cli_reported(result)?.session_id ?? null,
     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
+    salvaged_tool_calls: result.tool_calls.filter((call) => call.salvaged === true).length,
+    ...rate !== void 0 ? { throughput: rate } : {}
   };
 }
-function accumulate(state, role, result, model) {
-  const record = phase_record(result, model);
+function accumulate(state, role, result, model, duration_ms) {
+  const record = phase_record(result, model, duration_ms);
   const cost = record.cost_usd ?? 0;
   return {
     ...state,
@@ -1028,82 +1103,6 @@ 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) {
@@ -1197,11 +1196,11 @@ function git_checkpoint(root, message) {
     throw check_error(`git commit failed: ${out.trim()}`);
   }
 }
-function integrate_worktree(workspace, branch, message) {
+function integrate_worktree(workspace, branch2, message) {
   if (!existsSync3(join2(workspace, ".git"))) {
     throw config_error(`--worktree integration requires a git repository: ${workspace}`);
   }
-  const squash = spawnSync3("git", ["merge", "--squash", branch], {
+  const squash = spawnSync3("git", ["merge", "--squash", branch2], {
     cwd: workspace,
     encoding: "utf8"
   });
@@ -1210,7 +1209,7 @@ function integrate_worktree(workspace, branch, message) {
   }
   if (squash.status !== 0) {
     throw check_error(
-      `git merge --squash ${branch} failed: ${(squash.stderr || squash.stdout).trim()}`
+      `git merge --squash ${branch2} failed: ${(squash.stderr || squash.stdout).trim()}`
     );
   }
   const commit = spawnSync3("git", ["commit", "-m", message, "--no-verify"], {
@@ -1295,8 +1294,8 @@ function git_quiet(cwd, args) {
     return { status: -1, stdout: "", stderr: "" };
   }
 }
-function branch_exists(repo, branch) {
-  return git2(repo, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
+function branch_exists(repo, branch2) {
+  return git2(repo, ["show-ref", "--verify", "--quiet", `refs/heads/${branch2}`]).status === 0;
 }
 function create_worktree(options) {
   const repo = resolve3(options.workspace);
@@ -1344,25 +1343,25 @@ function teardown_worktree(options) {
   }
   return outcome;
 }
-function salvage_worktree(repo, path, branch) {
+function salvage_worktree(repo, path, branch2) {
   if (existsSync4(path)) {
     git_quiet(path, ["add", "-A"]);
     git_quiet(path, [
       "commit",
       "-m",
-      `volley: salvage unintegrated worktree (${branch})`,
+      `volley: salvage unintegrated worktree (${branch2})`,
       "--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 };
+  return { salvaged_branch: branch_ahead(repo, branch2) ? branch2 : 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}`]);
+function branch_ahead(repo, branch2) {
+  const ahead = git_quiet(repo, ["rev-list", "--count", `HEAD..${branch2}`]);
   return ahead.status === 0 && Number(ahead.stdout.trim()) > 0;
 }
 async function with_worktree(options, body) {
@@ -1502,8 +1501,20 @@ function compose_builder_prompt(input) {
 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)`;
 }
+function make_builder_step(deps) {
+  const { config } = deps;
+  return model_call({
+    engine: deps.engine,
+    id: "builder",
+    provider: config.builder_provider,
+    model: config.builder_model,
+    system: resolve_builder_system(config),
+    on_chunk: deps.on_chunk,
+    ...builder_tool_options(config, deps.bash_executor ?? null)
+  });
+}
 async function run_builder(deps, state, ctx) {
-  const { engine, config } = deps;
+  const { config } = deps;
   try {
     if (config.builder_provider === "ollama") {
       const base_url = resolve_ollama_base_url(process.env);
@@ -1516,22 +1527,16 @@ async function run_builder(deps, state, ctx) {
       );
       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({
+    const result = await ctx.call(
+      deps.builder,
+      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));
     }
@@ -1541,91 +1546,407 @@ async function run_builder(deps, state, ctx) {
   }
 }
 
-// src/check/checkride.ts
+// src/critic/run.ts
+import { z as z3 } from "zod";
+import { model_call as model_call2 } from "fascicle";
+
+// src/critic/prompt.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"));
+import { dirname as dirname3, join as join5 } 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 = join5(dir, "src", "critic", "presets");
+    if (existsSync6(candidate)) return candidate;
+    const local = join5(dir, "presets");
+    if (existsSync6(local)) return local;
+    dir = dirname3(dir);
   }
+  throw config_error("critic presets directory not found");
 }
-function failing_checks(summary) {
-  return summary.checks.filter((c) => !c.ok && c.skipped !== true);
+function resolve_critic_prompt(config) {
+  const base = config.critic_prompt_path !== null ? readFileSync6(config.critic_prompt_path, "utf8") : readFileSync6(join5(presets_dir2(), `${config.critic_preset}.md`), "utf8");
+  const append_file = config.critic_provider === "claude_cli" ? "harness_append.md" : "harness_append_local.md";
+  const append = readFileSync6(join5(presets_dir2(), append_file), "utf8");
+  return `${base.trimEnd()}
+
+${append.trimEnd()}`;
 }
-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
-    };
-  });
+var STATUS_MARKS = {
+  added: "A",
+  modified: "M",
+  deleted: "D",
+  renamed: "R",
+  unknown: "?"
+};
+function format_change(file) {
+  return `  ${STATUS_MARKS[file.status]} ${file.path}`;
 }
-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) {
+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, err) {
+  if (config.critic_provider === "claude_cli") 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, duration_ms) {
+  const next = accumulate(state, "critic", result, model, duration_ms);
+  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");
+}
+function critic_call_config(deps) {
+  const { config } = deps;
+  return {
+    engine: deps.engine,
+    provider: config.critic_provider,
+    model: config.critic_model,
+    system: resolve_critic_prompt(config),
+    schema: verdict_schema,
+    on_chunk: deps.on_chunk
+  };
+}
+function make_critic_tools_step(deps) {
+  return model_call2({
+    ...critic_call_config(deps),
+    id: "critic_tools",
+    ...critic_tool_options(deps.config)
+  });
+}
+function make_critic_toolless_step(deps) {
+  return model_call2({ ...critic_call_config(deps), id: "critic_toolless" });
+}
+function critic_retryable(config) {
+  return (err) => is_retryable_critic_error(config, err);
+}
+function with_retries(outcome) {
+  const last = outcome.errors.at(-1);
+  return {
+    result: outcome.value,
+    mark: {
+      retries: outcome.attempts - 1,
+      retry_cause_kind: last === void 0 ? void 0 : retry_cause_kind_of(last)
+    }
+  };
+}
+function as_degraded(result) {
+  return {
+    result,
+    mark: { retries: MAX_CRITIC_RETRIES, retry_cause_kind: void 0, critic_degraded: true }
+  };
+}
+function with_fallback_cause(outcome) {
+  if (outcome.source === "primary") return outcome.value;
+  return {
+    ...outcome.value,
+    mark: { ...outcome.value.mark, retry_cause_kind: retry_cause_kind_of(outcome.primary_error) }
+  };
+}
+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 { 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 prompt = compose_critic_prompt({
+      criteria: config.criteria,
+      iteration: state.iteration,
+      check,
+      changes: state.changes
+    });
+    const started = Date.now();
+    const { result, mark } = await ctx.call(deps.critic, prompt);
+    return finalize_critic(state, result, config.critic_model, mark, Date.now() - started);
+  } catch (err) {
+    throw phase_error("critic", state.iteration, err);
+  }
+}
+
+// src/loop_state.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 remaining_iterations(config, resume_from) {
+  return config.max_iterations - (resume_from?.iteration ?? 0);
+}
+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";
+}
+
+// src/check/checkride.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join6 } 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 = join6(workspace, ".check", "summary.json");
+    if (!existsSync7(file)) throw err;
+    return parse_checkride_summary(readFileSync7(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 = join6(workspace, ".check", file);
+    if (!existsSync7(path)) {
+      return { slot: check.name, path: null, content: "(no artifact found)", truncated: false };
+    }
+    const raw = readFileSync7(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);
@@ -1682,14 +2003,14 @@ function skipped_check(reason) {
 
 // src/iteration.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename, join as join6 } from "path";
+import { basename, join as join7 } from "path";
 function write_json(path, value) {
   writeFileSync3(path, `${JSON.stringify(value, null, 2)}
 `);
@@ -1725,37 +2046,40 @@ function phase_summary(record) {
     // 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 } : {}
+    ...record.critic_degraded === true ? { critic_degraded: true } : {},
+    // Model speed, where fascicle could time the turns (never `claude_cli`).
+    // Emitted only when measured. Additive.
+    ...record.throughput !== void 0 ? { throughput: record.throughput } : {}
   };
 }
 function archive_iteration(config, state) {
   const dir = iteration_dir(config.workspace, state.iteration);
-  mkdirSync3(join6(dir, "check"), { recursive: true });
+  mkdirSync3(join7(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}
+    writeFileSync3(join7(dir, "feedback.md"), readFileSync8(volley_path(config.workspace, "feedback.md")));
+    writeFileSync3(join7(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);
+        write_json(join7(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));
+        if (artifact.path !== null && existsSync8(artifact.path)) {
+          writeFileSync3(join7(dir, "check", basename(artifact.path)), readFileSync8(artifact.path));
         }
       }
     } else {
-      writeFileSync3(join6(dir, "check", "check.log"), check.log ?? "");
-      writeFileSync3(join6(dir, "check", "check.exit"), `${String(check.exit_code)}
+      writeFileSync3(join7(dir, "check", "check.log"), check.log ?? "");
+      writeFileSync3(join7(dir, "check", "check.exit"), `${String(check.exit_code)}
 `);
     }
   }
   const completed_at = (/* @__PURE__ */ new Date()).toISOString();
-  write_json(join6(dir, "summary.json"), {
+  write_json(join7(dir, "summary.json"), {
     iteration: state.iteration,
     started_at: state.iteration_started_at,
     completed_at,
@@ -1780,408 +2104,112 @@ function archive_iteration(config, state) {
     // 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";
+    iteration_cost_usd: state.iteration_cost_usd,
+    iteration_total_cost_usd: state.total_cost_usd
+  });
 }
-function finalize_critic(state, result, model, mark) {
-  const next = accumulate(state, "critic", result, model);
+function run_result_from_state(config, state, status, completed_at) {
   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
+    run_id: config.run_id,
+    status,
+    started_at: config.started_at,
+    completed_at,
+    iterations_completed: state.iteration,
+    total_usage: state.total_usage,
+    total_cost_usd: state.total_cost_usd,
+    builder_cost_usd: state.builder_cost_usd,
+    critic_cost_usd: state.critic_cost_usd,
+    check_duration_ms: state.check_duration_ms,
+    final_verdict: state.verdict,
+    // The loop itself never salvages: the orchestrator re-stamps this after
+    // teardown when a converged `--worktree` run's work was kept on its branch,
+    // which is the only moment the branch's survival is known.
+    salvaged_branch: null
   };
 }
-function 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");
+
+// src/summary.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
+function transport_of(provider) {
+  return provider === "claude_cli" ? "claude_cli" : "ai_sdk";
 }
-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);
-      }
+function read_iteration_archives(workspace) {
+  const root = volley_path(workspace, "iterations");
+  if (!existsSync9(root)) return [];
+  const dirs = readdirSync3(root).filter((dir) => /^\d{3}$/.test(dir)).toSorted();
+  const archives = [];
+  for (const dir of dirs) {
+    const path = volley_path(workspace, "iterations", dir, "summary.json");
+    if (!existsSync9(path)) continue;
+    try {
+      archives.push(JSON.parse(readFileSync9(path, "utf8")));
+    } catch {
     }
-    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);
   }
+  return archives;
 }
-
-// src/orchestrator.ts
-function initial_state() {
+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 {
-    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
+    tool_calls,
+    salvaged_tool_calls,
+    rate: tool_calls === 0 ? 0 : salvaged_tool_calls / tool_calls
   };
 }
-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;
+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 {
-    stop: success || cap || gate_edit,
-    state: { ...state, halt }
+    ...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 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";
+function write_run_summary(config, result) {
+  writeFileSync4(
+    volley_path(config.workspace, "summary.json"),
+    `${JSON.stringify(build_run_summary(config, result), null, 2)}
+`
+  );
 }
+
+// src/phases.ts
 var LISTED_GATE_EDITS = 5;
 function report_changes(config, renderer, changes) {
   if (changes === null) return;
@@ -2207,6 +2235,164 @@ async function execute_check(config, abort) {
   }
   return skipped_check("none");
 }
+function next_iteration(s) {
+  return {
+    ...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: []
+  };
+}
+async function build_phase(deps, builder, s, ctx) {
+  const { config, renderer } = deps;
+  const next = next_iteration(s);
+  renderer.phase_start(next.iteration, "builder");
+  const built = await run_builder({ builder, config, warn: renderer.warn }, 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: deps.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 };
+}
+function skip_verify_phase(deps, s) {
+  deps.renderer.warn("cost cap crossed during build; skipping check and critic");
+  return { ...s, check: skipped_check("cost_cap") };
+}
+async function check_phase(deps, s, ctx) {
+  const { config, renderer } = deps;
+  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);
+  }
+}
+async function critique_phase(deps, critic, s, ctx) {
+  const { renderer } = deps;
+  renderer.phase_start(s.iteration, "critic");
+  const critiqued = await run_critic({ critic, config: deps.config }, 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;
+}
+function record_phase(deps, s) {
+  const { config } = deps;
+  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;
+}
+
+// src/flow.ts
+function build_critic(deps) {
+  const retryable = critic_retryable(deps.config);
+  return fallback(
+    retry(make_critic_tools_step(deps), {
+      max_attempts: MAX_CRITIC_RETRIES + 1,
+      backoff_ms: 0,
+      when: retryable,
+      project: with_retries
+    }),
+    pipe(make_critic_toolless_step(deps), as_degraded),
+    {
+      name: "critic",
+      when: retryable,
+      handoff: (prompt) => toolless_critic_prompt(deps.config, prompt),
+      project: with_fallback_cause
+    }
+  );
+}
+function build_flow(deps, resume_from) {
+  const { config, renderer } = deps;
+  const builder = make_builder_step({
+    engine: deps.engine,
+    config,
+    on_chunk: renderer.builder_chunk,
+    bash_executor: deps.bash_executor
+  });
+  const critic = build_critic({ engine: deps.engine, config, on_chunk: renderer.critic_chunk });
+  const build = step("build", (s, ctx) => build_phase(deps, builder, s, ctx));
+  const skip_verify = step("skip_verify", (s) => skip_verify_phase(deps, s));
+  const check = step("check", (s, ctx) => check_phase(deps, s, ctx));
+  const critique = step("critique", (s, ctx) => critique_phase(deps, critic, s, ctx));
+  const record = step("record", (s) => record_phase(deps, s));
+  const verify = branch({
+    name: "verify",
+    when: (s) => cost_cap_hit(config, s),
+    // fascicle names this arm `then`. It holds a Step object, never a function,
+    // so nothing can mistake the config for a thenable.
+    // oxlint-disable-next-line unicorn/no-thenable
+    then: skip_verify,
+    otherwise: sequence([check, critique])
+  });
+  const iteration = sequence([build, verify, record], {
+    name: "iteration"
+  });
+  return loop({
+    name: "volley",
+    init: (input) => input.resume_from ?? initial_state(),
+    body: iteration,
+    guard: step("gate", (s) => gate(config, s)),
+    finish: (s, { converged }) => ({ value: s, converged }),
+    max_rounds: remaining_iterations(config, resume_from)
+  });
+}
+
+// src/orchestrator.ts
 async function run_volley(config, deps, resume_from = null) {
   const { renderer } = deps;
   if (resume_from === null) {
@@ -2216,13 +2402,13 @@ async function run_volley(config, deps, resume_from = null) {
     initialize_workspace(config.workspace, { preserve: true });
   }
   report_worktree_fate(config, renderer);
-  const branch = worktree_branch(config.run_id);
+  const branch2 = worktree_branch(config.run_id);
   const fate = worktree_fate(config);
   const outcome = await with_worktree(
     {
       enabled: config.worktree,
       workspace: config.workspace,
-      branch,
+      branch: branch2,
       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.
@@ -2232,15 +2418,15 @@ async function run_volley(config, deps, resume_from = null) {
       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`);
+        integrate_worktree(config.workspace, branch2, `volley run ${config.run_id}: integrate worktree (squash)`);
+        renderer.info(`worktree: squash-merged ${branch2} 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.`
+      `worktree: could not commit this run's work onto ${branch2}, 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;
@@ -2258,119 +2444,7 @@ async function run_loop(config, deps, resume_from, bash_executor, baseline) {
     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)
-  });
+  const flow = build_flow({ engine, config, renderer, bash_executor, baseline }, resume_from);
   try {
     const { value, converged } = await run(
       flow,