@robmclarty/volley 0.10.1 → 0.11.0

package/dist/index.d.ts

@@ -51,6 +51,7 @@ type VolleyConfig = {
   builder_max_steps?: number;
   builder_max_tool_calls?: number;
   builder_max_output_tokens?: number;
+  builder_trim_history?: number;
   allow_unsandboxed_builder?: boolean;
   critic_model?: string;
   critic_provider?: CriticProvider;
@@ -114,6 +115,11 @@ type ResolvedConfig = {
    * one step, not the session: fascicle feeds back that it hit the limit and
    * the loop goes on. Ignored by the `claude_cli` builder. */
   builder_max_output_tokens: number | null;
+  /** The estimated request size, in tokens, above which a tool-loop builder's
+   * turns send older tool results as one-line stubs (#7), or null to send
+   * every turn whole. Null by default, until a long local session is shown
+   * to run faster with it on. Ignored by the `claude_cli` builder. */
+  builder_trim_history: number | null;
   /** Operator opt-out permitting a non-`claude_cli` builder to run without a
    * sandbox — it gets a real host bash. Refused by default. */
   allow_unsandboxed_builder: boolean;
@@ -285,6 +291,40 @@ type PhaseRecord = {
    * another way. A thinking seat needs ai-sdk-ollama 4.3.0 or later, which
    * streams the reasoning even though volley never sets `think`. */
   throughput?: Throughput;
+  /** Each turn of a builder session, in order, so a long session's growth
+   * and where its time went can be read off the archive (#7). Set on a builder
+   * record whose provider reported steps (every tool-loop builder); absent on
+   * the critic and on a session with none. Additive. */
+  steps?: BuilderStepRecord[];
+};
+/** Where a builder turn's prefill and decode times came from.
+ * `ollama_reported`: Ollama's own `prompt_eval_duration` and `eval_duration`
+ * (native transport). `ollama_derived`: prefill as `total_duration` less
+ * `load_duration` and `eval_duration`, the ai_sdk transport's metadata, which
+ * leaves `prompt_eval_duration` out; slightly high, since the total includes
+ * Ollama's own overhead. `first_chunk`: prefill as the time to the first
+ * streamed chunk, decode as the rest of the round trip. `none`: no split. */
+type StepTimingBasis = 'ollama_reported' | 'ollama_derived' | 'first_chunk' | 'none';
+/** One turn of a builder session. */
+type BuilderStepRecord = {
+  index: number;
+  /** The whole request this turn sent, so the session's growth reads as the
+   * sequence of these. */
+  input_tokens: number;
+  output_tokens: number;
+  /** The turn's provider round trip, tool execution excluded. */
+  duration_ms: number;
+  prefill_ms?: number;
+  decode_ms?: number;
+  timing_basis: StepTimingBasis;
+  finish_reason: FinishReason;
+  truncated?: true;
+  /** Each tool call the turn made, and how many characters its result put
+   * into the transcript every later turn resends. */
+  tool_calls: Array<{
+    name: string;
+    output_chars: number;
+  }>;
 };
 type HaltReason = 'cost_cap' | 'gate_edit' | null;
 /** Carry-state threaded through the fascicle loop. */

package/dist/index.js

@@ -1,5 +1,5 @@
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createHmac, randomBytes, randomUUID } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
@@ -223,6 +223,7 @@ function create_volley_engine(options) {
 		default_cwd: options.workspace,
 		setting_sources: ["project", "local"],
 		auth_mode,
+		omit_env: SEAT_CREDENTIAL_VARS,
 		...binary !== void 0 && binary.length > 0 ? { binary } : {},
 		...auth_mode === "api_key" && env[ANTHROPIC_KEY_VAR] !== void 0 ? { api_key: env[ANTHROPIC_KEY_VAR] } : {}
 	} };
@@ -735,6 +736,7 @@ function write_resolved_config(config, env = process.env) {
 		builder_max_steps: config.builder_max_steps,
 		builder_max_tool_calls: config.builder_max_tool_calls,
 		builder_max_output_tokens: config.builder_max_output_tokens,
+		builder_trim_history: config.builder_trim_history,
 		critic_model: config.critic_model,
 		critic_provider: config.critic_provider,
 		critic_url: config.critic_url,
@@ -959,6 +961,7 @@ const CRITIQUE_REFUSED = [
 	["builder_max_steps", "--builder-max-steps"],
 	["builder_max_tool_calls", "--builder-max-tool-calls"],
 	["builder_max_output_tokens", "--builder-max-output-tokens"],
+	["builder_trim_history", "--builder-trim-history"],
 	["builder_permission_mode", "--builder-permission-mode"],
 	["allow_unsandboxed_builder", "--allow-unsandboxed-builder"],
 	["sandbox_image", "--sandbox-image"],
@@ -998,6 +1001,12 @@ function builder_max_output_tokens_count(provider) {
 		fallback: CAPPED_BY_DEFAULT.includes(provider) ? DEFAULT_BUILDER_MAX_OUTPUT_TOKENS : null
 	};
 }
+/** The history trim's size: off unless something sets it. */
+const BUILDER_TRIM_HISTORY = {
+	flag: "--builder-trim-history",
+	env_var: "VOLLEY_BUILDER_TRIM_HISTORY",
+	fallback: null
+};
 /** A builder count's flag or config value wins over its env var, which wins
 * over the default, and either must be a positive integer. Local builder
 * only; ignored by the `claude_cli` arm. */
@@ -1132,6 +1141,7 @@ function resolve_config(raw, options = {}) {
 	const builder_max_steps = resolve_builder_count(raw.builder_max_steps, builder_env, BUILDER_MAX_STEPS);
 	const builder_max_tool_calls = resolve_builder_count(raw.builder_max_tool_calls, builder_env, BUILDER_MAX_TOOL_CALLS);
 	const builder_max_output_tokens = resolve_builder_count(raw.builder_max_output_tokens, builder_env, builder_max_output_tokens_count(builder_provider));
+	const builder_trim_history = resolve_builder_count(raw.builder_trim_history, builder_env, BUILDER_TRIM_HISTORY);
 	const critic_provider = raw.critic_provider ?? DEFAULT_CRITIC_PROVIDER;
 	if (!CRITIC_PROVIDERS.includes(critic_provider)) throw config_error(`--critic-provider must be one of ${CRITIC_PROVIDERS.join(", ")}; got: ${String(raw.critic_provider)}`);
 	const builder_url = resolve_seat_url("builder", raw.builder_url, builder_provider);
@@ -1170,6 +1180,7 @@ function resolve_config(raw, options = {}) {
 		builder_max_steps,
 		builder_max_tool_calls,
 		builder_max_output_tokens,
+		builder_trim_history,
 		allow_unsandboxed_builder,
 		critic_model: raw.critic_model ?? DEFAULT_CRITIC_MODEL,
 		critic_provider,
@@ -1277,6 +1288,187 @@ function step_countdown(max_steps, check) {
 	};
 }
 //#endregion
+//#region src/builder/prepare_step.ts
+/** One hook that runs `hooks` in order, each on the request the one before it
+* made, and reports no change when none of them made one. */
+function compose_prepare_steps(hooks) {
+	return async ({ step_index, messages }) => {
+		let request = messages;
+		let changed = false;
+		for (const hook of hooks) {
+			const prepared = await hook({
+				step_index,
+				messages: request
+			});
+			if (prepared?.messages !== void 0) {
+				request = prepared.messages;
+				changed = true;
+			}
+		}
+		return changed ? { messages: request } : void 0;
+	};
+}
+//#endregion
+//#region src/builder/trim.ts
+/**
+* Trimming a long tool-loop session's history (#7). Every turn resends the
+* whole session, every earlier `read_file` result included, even for files the
+* builder has rewritten since, so a long local session's requests grow
+* linearly and each turn's latency grows with them: volley-41806476's input
+* went from 2.6k to 57k tokens over 50 steps, and its turns from 3 s to as
+* much as 120 s.
+*
+* Above a size the operator sets (`--builder-trim-history`), each turn's
+* request replaces the older tool results with one-line stubs: a read of a
+* file a later call wrote, edited, or read whole says so, and any other result
+* names its call and size. The last `TRIM_KEEP_TURNS` turns, every assistant
+* and user message, every failed call's result, and anything short stay as
+* they are. It goes in through fascicle's `prepare_step`, which reshapes only
+* what one turn sends, so the transcript stays as the model wrote it.
+*
+* A local runtime reuses the KV cache for the prefix a request shares with
+* the last one, and rewriting an earlier message breaks that prefix, so the
+* window is prefilled again. So the trim moves in coarse steps: it stubs
+* everything before a turn boundary, boundaries fall every
+* `TRIM_STRIDE_TURNS` turns, and the boundary moves on only when the trimmed
+* request has grown past the size again. Between moves each request starts
+* with the same bytes as the last, since a stub depends only on what came
+* before its boundary and never on the step. The trim keeps no state:
+* `trim_cutoff` works the boundary out again from the transcript each turn.
+*/
+/** A rough token count per character: the hook sees no token counts, so a
+* request's size is estimated from its text. */
+const CHARS_PER_TOKEN = 4;
+/** What a message costs beyond its text: its role and framing. */
+const MESSAGE_OVERHEAD_TOKENS = 8;
+/** The calls that change a file, whose success makes an earlier read of it
+* stale. Both volley's tools and fascicle's ACP tools use these names and a
+* `path` input. */
+const FILE_WRITERS = /* @__PURE__ */ new Set(["write_file", "edit_file"]);
+const COMMAND_TOOLS = /* @__PURE__ */ new Set(["bash", "run_command"]);
+function message_chars(message) {
+	if (typeof message.content === "string") return message.content.length;
+	let chars = 0;
+	for (const part of message.content) if (part.type === "text" || part.type === "reasoning") chars += part.text.length;
+	else if (part.type === "tool_call") chars += part.name.length + (JSON.stringify(part.input) ?? "").length;
+	return chars;
+}
+/** A request's size in tokens, estimated from its characters. */
+function estimate_tokens(messages) {
+	let tokens = 0;
+	for (const message of messages) tokens += Math.ceil(message_chars(message) / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD_TOKENS;
+	return tokens;
+}
+function call_input(input) {
+	if (typeof input !== "object" || input === null) return {
+		path: null,
+		whole: true
+	};
+	const fields = input;
+	return {
+		path: typeof fields["path"] === "string" ? posix.normalize(fields["path"]) : null,
+		whole: fields["offset"] === void 0 && fields["limit"] === void 0
+	};
+}
+/** Each tool call's input, by call id, from the assistant messages in
+* `messages`. */
+function call_inputs(messages) {
+	const inputs = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant" || typeof message.content === "string") continue;
+		for (const part of message.content) if (part.type === "tool_call") inputs.set(part.id, call_input(part.input));
+	}
+	return inputs;
+}
+/** Whether this result is one whose call changed its file or read it whole. */
+function supersession_of(message, input) {
+	if (input === void 0 || input.path === null || message.is_error === true) return null;
+	if (FILE_WRITERS.has(message.name)) return message.content.startsWith("error:") ? null : {
+		tool: message.name,
+		changed: true
+	};
+	if (message.name === "read_file" && input.whole) return {
+		tool: "read_file",
+		changed: false
+	};
+	return null;
+}
+function exit_code_of(content) {
+	try {
+		const parsed = JSON.parse(content);
+		if (typeof parsed === "object" && parsed !== null) {
+			const code = parsed["exit_code"];
+			if (typeof code === "number") return code;
+		}
+	} catch {}
+	return null;
+}
+function stub(message, input, later) {
+	const size = `${String(message.content.length)} chars`;
+	if (later !== void 0 && input !== void 0 && input.path !== null) return later.changed ? `[volley] read_file ${input.path} (${size}) elided: a later ${later.tool} changed this file. Read it again for its current content.` : `[volley] read_file ${input.path} (${size}) elided: it was read again later in this session.`;
+	const exit_code = COMMAND_TOOLS.has(message.name) ? exit_code_of(message.content) : null;
+	const detail = exit_code === null ? size : `${size}, exit ${String(exit_code)}`;
+	return `[volley] ${message.name} output (${detail}) elided from an earlier turn. Run it again if you need it.`;
+}
+/**
+* The request with every tool result before `cutoff` that is long enough to
+* matter and didn't fail replaced by a stub. Every message keeps its place,
+* role, id, and name. A stub reads only what comes before `cutoff`, so the
+* same transcript prefix always gives the same bytes.
+*/
+function trim_view(messages, cutoff) {
+	const window = messages.slice(0, cutoff);
+	const inputs = call_inputs(window);
+	const next_on_path = /* @__PURE__ */ new Map();
+	const later_for = /* @__PURE__ */ new Map();
+	for (let i = window.length - 1; i >= 0; i -= 1) {
+		const message = window[i];
+		if (message?.role !== "tool") continue;
+		const input = inputs.get(message.tool_call_id);
+		const path = input?.path ?? null;
+		if (path === null) continue;
+		if (message.name === "read_file") {
+			const later = next_on_path.get(path);
+			if (later !== void 0) later_for.set(i, later);
+		}
+		const supersedes = supersession_of(message, input);
+		if (supersedes !== null) next_on_path.set(path, supersedes);
+	}
+	return messages.map((message, i) => {
+		if (i >= cutoff || message.role !== "tool" || message.is_error === true) return message;
+		if (message.content.length <= 200) return message;
+		return {
+			...message,
+			content: stub(message, inputs.get(message.tool_call_id), later_for.get(i))
+		};
+	});
+}
+/**
+* Where to cut this turn's request, as a message index, or null to send it
+* whole. Boundaries are the starts of turns `TRIM_STRIDE_TURNS`,
+* `2 * TRIM_STRIDE_TURNS`, and so on, short of the last `TRIM_KEEP_TURNS`.
+* The cut moves to the next boundary only while the request, trimmed at the
+* last one, is still over `threshold`. A trimmed request only grows as the
+* session goes on, so a boundary once taken is kept.
+*/
+function trim_cutoff(messages, threshold) {
+	const turn_starts = messages.flatMap((message, i) => message.role === "assistant" ? [i] : []);
+	let cutoff = null;
+	for (let turn = 8; turn <= turn_starts.length - 6; turn += 8) {
+		if (estimate_tokens(cutoff === null ? messages : trim_view(messages, cutoff)) <= threshold) break;
+		cutoff = turn_starts[turn] ?? null;
+	}
+	return cutoff;
+}
+/** The `prepare_step` hook that trims a request estimated above `threshold`
+* tokens. */
+function step_trim(threshold) {
+	return ({ messages }) => {
+		const cutoff = trim_cutoff(messages, threshold);
+		return cutoff === null ? void 0 : { messages: trim_view(messages, cutoff) };
+	};
+}
+//#endregion
 //#region src/workspace_tools.ts
 /**
 * Shared workspace tools: `contain()` path confinement plus the read-only
@@ -2094,6 +2286,24 @@ function rejected_check(runner) {
 	};
 }
 //#endregion
+//#region src/claude_cli_permissions.ts
+const BUILDER_ALLOWED_TOOLS = [
+	"Read(/**)",
+	"Edit(/**)",
+	"Bash",
+	"WebFetch"
+];
+const CRITIC_ALLOWED_TOOLS = ["Read(/**)"];
+const CRITIC_DISALLOWED_TOOLS = "Write,Edit,MultiEdit,NotebookEdit,Bash";
+const PERMISSION_BLOCKS = { permissions: {
+	blockWritesOutsideWorkingDirectories: true,
+	blockReadsOutsideWorkingDirectories: true
+} };
+/** The CLI flags that turn on `PERMISSION_BLOCKS`. */
+function settings_args() {
+	return ["--settings", JSON.stringify(PERMISSION_BLOCKS)];
+}
+//#endregion
 //#region src/cost.ts
 /**
 * Cost and usage accumulation. All pricing knowledge lives in
@@ -2149,14 +2359,77 @@ function phase_record(result, model, duration_ms = result.timing?.duration_ms ??
 		...rate !== void 0 ? { throughput: rate } : {}
 	};
 }
+const NS_PER_MS = 1e6;
+function ns_field(payload, name) {
+	const value = payload[name];
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/** A turn's prefill and decode times: Ollama's own durations when it reported
+* them (in ns), else the time to the first streamed chunk, else none. */
+function step_split(step) {
+	const reported = step.provider_reported?.["ollama"];
+	if (typeof reported === "object" && reported !== null) {
+		const ollama = reported;
+		const evaluated = ns_field(ollama, "eval_duration");
+		const prompt = ns_field(ollama, "prompt_eval_duration");
+		if (evaluated !== void 0 && prompt !== void 0) return {
+			prefill_ms: Math.round(prompt / NS_PER_MS),
+			decode_ms: Math.round(evaluated / NS_PER_MS),
+			timing_basis: "ollama_reported"
+		};
+		const total = ns_field(ollama, "total_duration");
+		const load = ns_field(ollama, "load_duration");
+		if (evaluated !== void 0 && total !== void 0 && load !== void 0 && total >= load + evaluated) return {
+			prefill_ms: Math.round((total - load - evaluated) / NS_PER_MS),
+			decode_ms: Math.round(evaluated / NS_PER_MS),
+			timing_basis: "ollama_derived"
+		};
+	}
+	const timing = step.timing;
+	if (timing?.first_chunk_ms !== void 0 && timing.whole_tool_call !== true) return {
+		prefill_ms: timing.first_chunk_ms,
+		decode_ms: Math.max(0, timing.duration_ms - timing.first_chunk_ms),
+		timing_basis: "first_chunk"
+	};
+	return { timing_basis: "none" };
+}
+/** How much a tool call's result put into the transcript: its output as the
+* loop serializes it, or the error text it fed back. */
+function output_chars(call) {
+	if (call.output === void 0) return call.error?.message.length ?? 0;
+	return typeof call.output === "string" ? call.output.length : (JSON.stringify(call.output) ?? "").length;
+}
+/** Each turn of a session as the archive records it, or undefined when the
+* result has none. */
+function step_records(result) {
+	if (result.steps.length === 0) return void 0;
+	return result.steps.map((step) => ({
+		index: step.index,
+		input_tokens: step.usage.input_tokens,
+		output_tokens: step.usage.output_tokens,
+		duration_ms: step.timing?.duration_ms ?? 0,
+		...step_split(step),
+		finish_reason: step.finish_reason,
+		...step.truncated === true ? { truncated: true } : {},
+		tool_calls: step.tool_calls.map((call) => ({
+			name: call.name,
+			output_chars: output_chars(call)
+		}))
+	}));
+}
 /** Fold one phase's result into the loop state. Unknown cost records `null`
-* for the phase and warns once per run — a run never fails over pricing. */
+* for the phase and warns once per run — a run never fails over pricing. The
+* builder's record also carries its session's turns. */
 function accumulate(state, role, result, model, duration_ms) {
 	const record = phase_record(result, model, duration_ms);
+	const steps = role === "builder" ? step_records(result) : void 0;
 	const cost = record.cost_usd ?? 0;
 	return {
 		...state,
-		[role]: record,
+		[role]: steps !== void 0 ? {
+			...record,
+			steps
+		} : record,
 		total_usage: add_usage(state.total_usage, result.usage),
 		total_cost_usd: state.total_cost_usd + cost,
 		iteration_cost_usd: state.iteration_cost_usd + cost,
@@ -2555,16 +2828,6 @@ async function with_worktree(options, body) {
 * complete agentic session in the workspace — Claude Code under `claude_cli`,
 * or a model driving volley's tools on any other provider, local or hosted.
 */
-const BUILDER_ALLOWED_TOOLS = [
-	"Read",
-	"Write",
-	"Edit",
-	"MultiEdit",
-	"Bash",
-	"Grep",
-	"Glob",
-	"WebFetch"
-];
 function compose_builder_system() {
 	return [
 		"You are the builder inside the volley harness: an autonomous agent",
@@ -2626,6 +2889,14 @@ function check_hint(config) {
 	if (config.check_resolved === "command") return `the check (\`${config.check}\`)`;
 	return "the project's tests";
 }
+/** The builder's `prepare_step`: the countdown, after the history trim when
+* `--builder-trim-history` turns it on, so the countdown's note still goes
+* last. */
+function builder_prepare_step(config) {
+	const countdown = step_countdown(config.builder_max_steps, check_hint(config));
+	if (config.builder_trim_history === null) return countdown;
+	return compose_prepare_steps([step_trim(config.builder_trim_history), countdown]);
+}
 /** Per-provider tool wiring for the builder, mirroring `critic_tool_options`.
 * The `claude_cli` builder is confined at the CLI permission layer (allowlist +
 * permission mode) and brings its own built-in tools — this arm is unchanged
@@ -2633,7 +2904,8 @@ function check_hint(config) {
 * builder, local or `openrouter`, brings none, so volley supplies its whole
 * workspace tool surface (or the set the caller injected in its place, with
 * the handler that answers its approvals), the per-call loop knobs, the step
-* countdown (`./builder/countdown.ts`), the output cap when one is set, and
+* countdown (`./builder/countdown.ts`) and the history trim when it's on
+* (`./builder/trim.ts`), the output cap when one is set, and
 * **no** schema (it produces a workspace, not a verdict); per-call values win
 * over engine defaults. */
 function builder_tool_options(deps) {
@@ -2641,7 +2913,11 @@ function builder_tool_options(deps) {
 	const bash_executor = deps.bash_executor ?? null;
 	if (config.builder_provider === "claude_cli") return { provider_options: { claude_cli: {
 		allowed_tools: [...BUILDER_ALLOWED_TOOLS],
-		extra_args: ["--permission-mode", config.builder_permission_mode]
+		extra_args: [
+			"--permission-mode",
+			config.builder_permission_mode,
+			...settings_args()
+		]
 	} } };
 	return {
 		tools: deps.tools === void 0 ? builder_tools(build_root(config.workspace, config.worktree), bash_executor !== null ? { bash_executor } : {}) : [...deps.tools],
@@ -2650,7 +2926,7 @@ function builder_tool_options(deps) {
 		tool_error_policy: "feed_back",
 		tool_call_repair_attempts: BUILDER_TOOL_CALL_REPAIR_ATTEMPTS,
 		max_tool_calls_per_step: config.builder_max_tool_calls,
-		prepare_step: step_countdown(config.builder_max_steps, check_hint(config)),
+		prepare_step: builder_prepare_step(config),
 		...config.builder_max_output_tokens !== null ? {
 			max_tokens: config.builder_max_output_tokens,
 			truncated_turn_policy: "continue"
@@ -2911,12 +3187,6 @@ function compose_critic_prompt(input) {
 * structured verdict. The
 * harness — not the critic — writes the run's `feedback.md` and `verdict`.
 */
-const CRITIC_ALLOWED_TOOLS = [
-	"Read",
-	"Grep",
-	"Glob"
-];
-const CRITIC_DISALLOWED_TOOLS = "Write,Edit,MultiEdit,NotebookEdit,Bash";
 /** A critic that holds tools isn't constrain-decoded, so nothing stops it
 * answering null for the feedback or the unmet list, as GLM did on approving.
 * Both fields allow null and read it as empty, so that answer is a verdict
@@ -2929,7 +3199,8 @@ const verdict_schema = z.object({
 	unmet_criteria: z.array(z.string()).nullable().transform((unmet) => unmet ?? []).describe("The specific acceptance criteria judged unmet, verbatim. Empty when approved.")
 });
 /** Read-only tool wiring per provider. The claude_cli critic is confined at
-* the CLI permission layer (allowlist + explicit disallow); every other critic,
+* the CLI permission layer (allowlist + explicit disallow, and the settings
+* blocks that keep its reads in the build root); every other critic,
 * local or `openrouter`, gets volley's own workspace-scoped read-only tools (or
 * the set the caller injected in their place) and no write path at all.
 *
@@ -2951,7 +3222,11 @@ const verdict_schema = z.object({
 function critic_tool_options(config, tools) {
 	if (config.critic_provider === "claude_cli") return { provider_options: { claude_cli: {
 		allowed_tools: [...CRITIC_ALLOWED_TOOLS],
-		extra_args: ["--disallowedTools", CRITIC_DISALLOWED_TOOLS]
+		extra_args: [
+			"--disallowedTools",
+			CRITIC_DISALLOWED_TOOLS,
+			...settings_args()
+		]
 	} } };
 	return {
 		tools: tools === void 0 ? read_only_tools(build_root(config.workspace, config.worktree)) : [...tools],
@@ -3303,7 +3578,8 @@ function phase_summary(record) {
 		...record.retry_cause_kind !== void 0 ? { retry_cause_kind: record.retry_cause_kind } : {},
 		...record.critic_degraded === true ? { critic_degraded: true } : {},
 		...record.degrade_cause !== void 0 ? { degrade_cause: record.degrade_cause } : {},
-		...record.throughput !== void 0 ? { throughput: record.throughput } : {}
+		...record.throughput !== void 0 ? { throughput: record.throughput } : {},
+		...record.steps !== void 0 ? { steps: record.steps } : {}
 	};
 }
 /** Archive one completed iteration: verdict files, check artifacts, and the