@robmclarty/volley 0.5.1 → 0.5.2

package/dist/cli.js

@@ -501,6 +501,7 @@ import {
 import { basename, join as join3 } from "path";
 
 // 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 = {
@@ -518,30 +519,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,
@@ -630,11 +625,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 = spawnSync2("git", ["merge", "--squash", branch], {
+  const squash = spawnSync2("git", ["merge", "--squash", branch2], {
     cwd: workspace,
     encoding: "utf8"
   });
@@ -643,7 +638,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 = spawnSync2("git", ["commit", "-m", message, "--no-verify"], {
@@ -695,7 +690,10 @@ 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) {
@@ -856,13 +854,93 @@ import { join as join9 } from "path";
 
 // src/orchestrator.ts
 import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
-import { loop, run, sequence, step } from "fascicle";
+import { run } from "fascicle";
 import { filesystem_logger } from "fascicle/adapters";
 
+// src/engine.ts
+import { existsSync as existsSync5, 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 (!existsSync5(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/flow.ts
+import { branch, fallback, loop, pipe, retry, sequence, step } from "fascicle";
+
 // src/builder.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname2, join as join6 } from "path";
 import { fileURLToPath } from "url";
+import { model_call } from "fascicle";
 
 // src/builder/context_check.ts
 var MIN_RECOMMENDED_NUM_CTX = 16384;
@@ -904,7 +982,7 @@ async function warn_small_local_context(provider, model, base_url, warn, abort)
 // src/builder/tools.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { lookup as dns_lookup } from "dns";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { dirname } from "path";
 import { Readability } from "@mozilla/readability";
 import ipaddr from "ipaddr.js";
@@ -914,7 +992,7 @@ import { Agent, buildConnector, interceptors, request } from "undici";
 import { z as z2 } from "zod";
 
 // src/workspace_tools.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve2, sep } from "path";
 import { z } from "zod";
 var READ_FILE_MAX_BYTES = 2e5;
@@ -994,7 +1072,7 @@ function read_only_tools(workspace) {
     execute: (raw) => {
       const input = read_file_input.parse(raw);
       const abs = contain(workspace, input.path);
-      const content = readFileSync4(abs, "utf8");
+      const content = readFileSync5(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;
     }
@@ -1013,7 +1091,7 @@ function read_only_tools(workspace) {
         if (hits.length >= SEARCH_MAX_MATCHES) break;
         let content;
         try {
-          content = readFileSync4(file.abs, "utf8");
+          content = readFileSync5(file.abs, "utf8");
         } catch {
           continue;
         }
@@ -1214,13 +1292,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}
 
@@ -1356,7 +1434,7 @@ function builder_tools(workspace, options = {}) {
     execute: (raw) => {
       const input = edit_file_input.parse(raw);
       const abs = contain(workspace, input.path);
-      const content = readFileSync5(abs, "utf8");
+      const content = readFileSync6(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.`;
@@ -1426,82 +1504,6 @@ ${note}` : note;
   return [...read_only_tools(workspace), write_file, edit_file, bash, fetch2, finish];
 }
 
-// src/engine.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { create_engine } from "fascicle";
-var DEFAULT_OLLAMA_URL = "http://localhost:11434";
-var DEFAULT_LMSTUDIO_URL = "http://localhost:1234/v1";
-var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "0.0.0.0"]);
-function cross_to_host_gateway(base_url, env) {
-  const host = env["VOLLEY_MODEL_HOST"];
-  if (host === void 0 || host === "") return base_url;
-  let parsed;
-  try {
-    parsed = new URL(base_url);
-  } catch {
-    return base_url;
-  }
-  if (!LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase())) return base_url;
-  parsed.hostname = host;
-  return parsed.toString().replace(/\/$/, "");
-}
-function resolve_ollama_base_url(env) {
-  const raw = env["VOLLEY_OLLAMA_URL"] ?? DEFAULT_OLLAMA_URL;
-  const normalized = raw.replace(/\/+$/, "").replace(/\/api$/, "");
-  return cross_to_host_gateway(normalized, env);
-}
-function load_pricing_overrides(path) {
-  if (!existsSync5(path)) {
-    throw config_error(`VOLLEY_PRICING_PATH not found: ${path}`);
-  }
-  try {
-    return JSON.parse(readFileSync6(path, "utf8"));
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    throw config_error(`VOLLEY_PRICING_PATH is not valid JSON: ${detail}`);
-  }
-}
-function is_local_provider(provider) {
-  return provider === "ollama" || provider === "lmstudio";
-}
-function local_provider_config(provider, env) {
-  if (provider === "ollama") {
-    return { ollama: { base_url: resolve_ollama_base_url(env) } };
-  }
-  const lmstudio_url = env["VOLLEY_LMSTUDIO_URL"] ?? DEFAULT_LMSTUDIO_URL;
-  return { lmstudio: { base_url: cross_to_host_gateway(lmstudio_url, env) } };
-}
-function create_volley_engine(options) {
-  const env = options.env ?? process.env;
-  const auth_mode = env["VOLLEY_AUTH_MODE"] ?? "auto";
-  if (auth_mode !== "auto" && auth_mode !== "oauth" && auth_mode !== "api_key") {
-    throw config_error(
-      `VOLLEY_AUTH_MODE must be auto, oauth, or api_key; got: ${auth_mode}`
-    );
-  }
-  const binary = env["VOLLEY_CLAUDE_BIN"];
-  const pricing_path = env["VOLLEY_PRICING_PATH"];
-  const local_providers = /* @__PURE__ */ new Set();
-  if (is_local_provider(options.builder_provider)) local_providers.add(options.builder_provider);
-  if (is_local_provider(options.critic_provider)) local_providers.add(options.critic_provider);
-  const providers = {
-    claude_cli: {
-      default_cwd: options.workspace,
-      setting_sources: ["project", "local"],
-      auth_mode,
-      ...binary !== void 0 && binary.length > 0 ? { binary } : {},
-      ...auth_mode === "api_key" && env["ANTHROPIC_API_KEY"] !== void 0 ? { api_key: env["ANTHROPIC_API_KEY"] } : {}
-    }
-  };
-  for (const provider of local_providers) {
-    Object.assign(providers, local_provider_config(provider, env));
-  }
-  return create_engine({
-    providers,
-    ...pricing_path !== void 0 && pricing_path.length > 0 ? { pricing: load_pricing_overrides(pricing_path) } : {}
-  });
-}
-
 // src/prewarm.ts
 var PREWARM_TIMEOUT_MS = 3e5;
 async function prewarm_ollama_model(base_url, model, abort) {
@@ -1590,8 +1592,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);
@@ -1639,25 +1641,25 @@ function teardown_worktree(options) {
   }
   return outcome;
 }
-function salvage_worktree(repo, path, branch) {
+function salvage_worktree(repo, path, branch2) {
   if (existsSync6(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) {
@@ -1797,8 +1799,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);
@@ -1811,22 +1825,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));
     }
@@ -1836,261 +1844,42 @@ 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 existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join7 } from "path";
-import { spawn } from "child_process";
-import { aborted_error } from "fascicle";
-var CHECK_ARTIFACT_MAX_CHARS = 8e3;
-var CHECKRIDE_SCHEMA_VERSION = 1;
-function spawn_capture(cmd, args, options) {
-  return new Promise((resolve_promise, reject) => {
-    const proc = spawn(cmd, args, {
-      cwd: options.cwd,
-      ...options.abort !== void 0 ? { signal: options.abort } : {}
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    proc.on("error", (err) => {
-      if (err.name === "AbortError") {
-        reject(new aborted_error("check aborted"));
-        return;
-      }
-      reject(check_error(`check command failed to start: ${err.message}`));
-    });
-    proc.on("close", (code) => {
-      resolve_promise({ exit_code: code, stdout, stderr });
-    });
-  });
-}
-function parse_checkride_summary(stdout) {
-  const start = stdout.indexOf("{");
-  const end = stdout.lastIndexOf("}");
-  let raw;
-  try {
-    if (start === -1 || end < start) throw new Error("no JSON object in stdout");
-    raw = JSON.parse(stdout.slice(start, end + 1));
-  } catch {
-    throw check_error("checkride --json produced unparseable stdout");
-  }
-  if (typeof raw !== "object" || raw === null || !Array.isArray(raw.checks)) {
-    throw check_error("checkride summary missing checks array");
-  }
-  const summary = raw;
-  const warning = summary.schema_version === CHECKRIDE_SCHEMA_VERSION ? null : `checkride summary schema_version ${String(summary.schema_version)} != ${String(CHECKRIDE_SCHEMA_VERSION)}; parsing best-effort`;
-  return { summary, warning };
-}
-function parse_summary_with_fallback(stdout, workspace) {
-  try {
-    return parse_checkride_summary(stdout);
-  } catch (err) {
-    const file = join7(workspace, ".check", "summary.json");
-    if (!existsSync8(file)) throw err;
-    return parse_checkride_summary(readFileSync8(file, "utf8"));
+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 (existsSync8(candidate)) return candidate;
+    const local = join7(dir, "presets");
+    if (existsSync8(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 ? readFileSync8(config.critic_prompt_path, "utf8") : readFileSync8(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 = readFileSync8(join7(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 = join7(workspace, ".check", file);
-    if (!existsSync8(path)) {
-      return { slot: check.name, path: null, content: "(no artifact found)", truncated: false };
-    }
-    const raw = readFileSync8(path, "utf8");
-    const truncated = raw.length > CHECK_ARTIFACT_MAX_CHARS;
-    return {
-      slot: check.name,
-      path,
-      content: truncated ? raw.slice(0, CHECK_ARTIFACT_MAX_CHARS) : raw,
-      truncated
-    };
-  });
-}
-async function run_checkride(opts) {
-  const proc = await spawn_capture("pnpm", ["exec", "checkride", "--json"], {
-    cwd: opts.workspace,
-    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
-  });
-  if (proc.exit_code === 2) {
-    throw check_error(`checkride harness error: ${proc.stderr.trim()}`);
-  }
-  const { summary } = parse_summary_with_fallback(proc.stdout, opts.workspace);
-  const failing = failing_checks(summary);
-  return {
-    ran: true,
-    runner: "checkride",
-    ok: summary.ok,
-    exit_code: proc.exit_code,
-    duration_ms: summary.total_duration_ms,
-    failing_slots: failing.map((c) => c.name),
-    detail: read_failing_artifacts(opts.workspace, failing),
-    summary
-  };
-}
-
-// src/check/command.ts
-async function run_command_check(opts) {
-  const started = Date.now();
-  const proc = await spawn_capture("sh", ["-c", opts.command], {
-    cwd: opts.workspace,
-    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
-  });
-  if (proc.exit_code === 127 || proc.exit_code === 126) {
-    throw check_error(
-      `check command failed to start (exit ${String(proc.exit_code)}): ${opts.command}`
-    );
-  }
-  const log = `${proc.stdout}${proc.stderr}`;
-  return {
-    ran: true,
-    runner: "command",
-    ok: proc.exit_code === 0,
-    exit_code: proc.exit_code,
-    duration_ms: Date.now() - started,
-    failing_slots: [],
-    detail: [],
-    log
-  };
-}
-function skipped_check(reason) {
-  return {
-    ran: false,
-    runner: "none",
-    // With no check configured the loop is critic-gated only, so the gate is
-    // open (`ok: true`). A cost-cap skip must not look like a passing gate.
-    ok: reason === "none",
-    exit_code: null,
-    duration_ms: 0,
-    failing_slots: [],
-    detail: []
-  };
-}
-
-// src/summary.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
-function transport_of(provider) {
-  return provider === "claude_cli" ? "claude_cli" : "ai_sdk";
-}
-function read_iteration_archives(workspace) {
-  const root = volley_path(workspace, "iterations");
-  if (!existsSync9(root)) return [];
-  const dirs = readdirSync3(root).filter((dir) => /^\d{3}$/.test(dir)).toSorted();
-  const archives = [];
-  for (const dir of dirs) {
-    const path = volley_path(workspace, "iterations", dir, "summary.json");
-    if (!existsSync9(path)) continue;
-    try {
-      archives.push(JSON.parse(readFileSync9(path, "utf8")));
-    } catch {
-    }
-  }
-  return archives;
-}
-function check_trajectory(archives) {
-  return archives.map((archive, index) => ({
-    iteration: typeof archive.iteration === "number" ? archive.iteration : index + 1,
-    ran: archive.check?.ran === true,
-    ok: archive.check?.ok === true,
-    failing_slots: archive.check?.failing_slots ?? []
-  }));
-}
-function any_critic_degraded(archives) {
-  return archives.some((archive) => archive.critic?.critic_degraded === true);
-}
-function all_gate_edits(archives) {
-  const edits = /* @__PURE__ */ new Set();
-  for (const archive of archives) {
-    for (const path of archive.changes?.gate_edits ?? []) edits.add(path);
-  }
-  return [...edits].toSorted();
-}
-function salvage_stats(archives) {
-  let tool_calls = 0;
-  let salvaged_tool_calls = 0;
-  for (const archive of archives) {
-    tool_calls += archive.builder?.tool_calls ?? 0;
-    salvaged_tool_calls += archive.builder?.salvaged_tool_calls ?? 0;
-  }
-  return {
-    tool_calls,
-    salvaged_tool_calls,
-    rate: tool_calls === 0 ? 0 : salvaged_tool_calls / tool_calls
-  };
-}
-function build_run_summary(config, result) {
-  const archives = read_iteration_archives(config.workspace);
-  const wall_clock_ms = result.completed_at === null ? null : Date.parse(result.completed_at) - Date.parse(result.started_at);
-  return {
-    ...result,
-    comparison: {
-      builder_transport: transport_of(config.builder_provider),
-      critic_transport: transport_of(config.critic_provider),
-      iterations_to_converge: result.status === "success" ? result.iterations_completed : null,
-      wall_clock_ms,
-      total_cost_usd: result.total_cost_usd,
-      builder_cost_usd: result.builder_cost_usd,
-      critic_cost_usd: result.critic_cost_usd,
-      final_verdict: result.final_verdict,
-      check_trajectory: check_trajectory(archives),
-      gate_edits: all_gate_edits(archives),
-      unmet_criteria: archives.at(-1)?.unmet_criteria ?? [],
-      local_salvage: salvage_stats(archives),
-      critic_degraded: any_critic_degraded(archives)
-    }
-  };
-}
-function write_run_summary(config, result) {
-  writeFileSync4(
-    volley_path(config.workspace, "summary.json"),
-    `${JSON.stringify(build_run_summary(config, result), null, 2)}
-`
-  );
-}
-
-// src/critic/run.ts
-import { z as z3 } from "zod";
-
-// src/critic/prompt.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function presets_dir2() {
-  let dir = dirname3(fileURLToPath2(import.meta.url));
-  for (let depth = 0; depth < 6; depth += 1) {
-    const candidate = join8(dir, "src", "critic", "presets");
-    if (existsSync10(candidate)) return candidate;
-    const local = join8(dir, "presets");
-    if (existsSync10(local)) return local;
-    dir = dirname3(dir);
-  }
-  throw config_error("critic presets directory not found");
-}
-function resolve_critic_prompt(config) {
-  const base = config.critic_prompt_path !== null ? readFileSync10(config.critic_prompt_path, "utf8") : readFileSync10(join8(presets_dir2(), `${config.critic_preset}.md`), "utf8");
-  const append_file = config.critic_provider === "claude_cli" ? "harness_append.md" : "harness_append_local.md";
-  const append = readFileSync10(join8(presets_dir2(), append_file), "utf8");
-  return `${base.trimEnd()}
-
-${append.trimEnd()}`;
-}
-var STATUS_MARKS = {
-  added: "A",
-  modified: "M",
-  deleted: "D",
-  renamed: "R",
-  unknown: "?"
-};
-function format_change(file) {
-  return `  ${STATUS_MARKS[file.status]} ${file.path}`;
+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;
@@ -2205,17 +1994,16 @@ function critic_tool_options(config) {
   return { tools: read_only_tools(build_root(config.workspace, config.worktree)) };
 }
 var MAX_CRITIC_RETRIES = 1;
-function is_retryable_critic_error(config, ctx, err) {
+function is_retryable_critic_error(config, 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);
+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 : {
@@ -2242,6 +2030,53 @@ function toolless_critic_prompt(config, tool_prompt) {
     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".',
@@ -2287,7 +2122,7 @@ async function critic_canary(engine, config, env = process.env) {
   }
 }
 async function run_critic(deps, state, ctx) {
-  const { engine, config } = deps;
+  const { config } = deps;
   if (state.check === null) {
     throw phase_error("critic", state.iteration, new Error("check phase did not run"));
   }
@@ -2300,53 +2135,21 @@ async function run_critic(deps, state, ctx) {
         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({
+    const 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
-    });
+    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/orchestrator.ts
+// src/loop_state.ts
 function initial_state() {
   return {
     iteration: 0,
@@ -2368,6 +2171,9 @@ function initial_state() {
     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;
 }
@@ -2386,6 +2192,228 @@ function status_of(value, converged) {
   if (value.halt === "cost_cap") return "cost_cap_reached";
   return converged ? "success" : "budget_exhausted";
 }
+
+// src/check/checkride.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } 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 = join8(workspace, ".check", "summary.json");
+    if (!existsSync9(file)) throw err;
+    return parse_checkride_summary(readFileSync9(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 = join8(workspace, ".check", file);
+    if (!existsSync9(path)) {
+      return { slot: check.name, path: null, content: "(no artifact found)", truncated: false };
+    }
+    const raw = readFileSync9(path, "utf8");
+    const truncated = raw.length > CHECK_ARTIFACT_MAX_CHARS;
+    return {
+      slot: check.name,
+      path,
+      content: truncated ? raw.slice(0, CHECK_ARTIFACT_MAX_CHARS) : raw,
+      truncated
+    };
+  });
+}
+async function run_checkride(opts) {
+  const proc = await spawn_capture("pnpm", ["exec", "checkride", "--json"], {
+    cwd: opts.workspace,
+    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
+  });
+  if (proc.exit_code === 2) {
+    throw check_error(`checkride harness error: ${proc.stderr.trim()}`);
+  }
+  const { summary } = parse_summary_with_fallback(proc.stdout, opts.workspace);
+  const failing = failing_checks(summary);
+  return {
+    ran: true,
+    runner: "checkride",
+    ok: summary.ok,
+    exit_code: proc.exit_code,
+    duration_ms: summary.total_duration_ms,
+    failing_slots: failing.map((c) => c.name),
+    detail: read_failing_artifacts(opts.workspace, failing),
+    summary
+  };
+}
+
+// src/check/command.ts
+async function run_command_check(opts) {
+  const started = Date.now();
+  const proc = await spawn_capture("sh", ["-c", opts.command], {
+    cwd: opts.workspace,
+    ...opts.abort !== void 0 ? { abort: opts.abort } : {}
+  });
+  if (proc.exit_code === 127 || proc.exit_code === 126) {
+    throw check_error(
+      `check command failed to start (exit ${String(proc.exit_code)}): ${opts.command}`
+    );
+  }
+  const log = `${proc.stdout}${proc.stderr}`;
+  return {
+    ran: true,
+    runner: "command",
+    ok: proc.exit_code === 0,
+    exit_code: proc.exit_code,
+    duration_ms: Date.now() - started,
+    failing_slots: [],
+    detail: [],
+    log
+  };
+}
+function skipped_check(reason) {
+  return {
+    ran: false,
+    runner: "none",
+    // With no check configured the loop is critic-gated only, so the gate is
+    // open (`ok: true`). A cost-cap skip must not look like a passing gate.
+    ok: reason === "none",
+    exit_code: null,
+    duration_ms: 0,
+    failing_slots: [],
+    detail: []
+  };
+}
+
+// src/summary.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10, 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 (!existsSync10(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 (!existsSync10(path)) continue;
+    try {
+      archives.push(JSON.parse(readFileSync10(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/phases.ts
 var LISTED_GATE_EDITS = 5;
 function report_changes(config, renderer, changes) {
   if (changes === null) return;
@@ -2411,6 +2439,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) {
@@ -2420,13 +2606,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.
@@ -2436,15 +2622,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;
@@ -2462,119 +2648,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,