@tangle-network/agent-bench 0.8.32 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.8.34
+
+The dependency range requires Knowledge 14.0.3 for the compatible Eval cohort.
+
+## 0.8.33
+
+Requires Eval `>=0.175.0 <0.176.0`, following Runtime 0.197.0.
+No behavior change.
+
 ## 0.8.32
 
 The dependency ranges now require Runtime 0.195.0, Eval 0.174, and Knowledge 14.

package/HARNESS.md

@@ -18,7 +18,7 @@ Use these labels literally. Do not promote one level into another in prose.
 
 | Level | What it establishes | Canonical path |
 |---|---|---|
-| **contract proof** | packages install; identities, budgets, callbacks, resume, and receipts have the expected shape | root `pnpm verify:official-optimizers`, `pnpm verify:primeintellect`, `pnpm verify:bench` |
+| **contract proof** | packages install; identities, budgets, callbacks, resume, and receipts have the expected shape | root `pnpm verify:official-optimizers`, `pnpm verify:bench` |
 | **evaluator proof** | the benchmark's own evaluator can distinguish known fail/pass artifacts in the exact environment | adapter preflight and gold/self-check |
 | **reproduction proof** | an upstream method is run at a pinned revision on its claimed benchmark under a matched protocol | Discovery Lab reproduction manifest and runner |
 | **value proof** | the integrated method beats the preregistered baseline on frozen evidence with uncertainty and complete cost accounting | Discovery Lab result receipt |
@@ -35,7 +35,6 @@ From the repository root:
 ```bash
 pnpm verify:bench
 pnpm verify:official-optimizers
-pnpm verify:primeintellect
 ```
 
 `verify:official-optimizers` exercises the official Optimize Anything bridge, engine identities, equal input budgets, resume compatibility, candidate callbacks, accounting, and package provenance. Its deterministic candidate improvement is deliberately a fixture. It does **not** reproduce the published GEPA or Omni benchmark numbers.
@@ -52,6 +51,14 @@ pnpm run run-benchmarks
 
 Use `LOOP_ATTEMPTS=N` only when the benchmark's own visible feedback is allowed to enter later attempts. Hidden or gold material must remain outside the agent context.
 
+`runBenchmarks()` returns each judged artifact, worker events, and observed usage in `perTask`.
+Retry usage includes every attempt; missing receipts leave the measured subtotal explicitly incomplete.
+Judge failures retain completed worker evidence.
+Errors propagated by `close()` remain in `detail` beside the settled task outcome.
+The current Runtime lineage suppresses sandbox deletion errors, so a returned result does not confirm resource deletion.
+The caller's abort signal stops queued shots and reaches active sandbox turns.
+`modelApiKey` supplies sandbox inference authorization separately from the `routerKey` used for sandbox control.
+
 ### Full-fidelity improvement fixture
 
 ```bash

package/dist/index.d.ts

@@ -8,8 +8,9 @@ import { FINAL_ANSWER_SENTINEL, RagAnswerScore, RagContext, answerScoreToBenchSc
 import { createRagBenchAdapter } from "./benchmarks/ragbench.js";
 import { SweBenchAdapterOptions, SweBenchArtifactCaptureContext, SweBenchCacheLevel, createSweBenchAdapter, scoreSweReport, sweEvaluationArgv, swePatchOutput } from "./benchmarks/swe-bench.js";
 import { createT2RagBenchAdapter } from "./benchmarks/t2-ragbench.js";
-import { AgentProfile, SandboxClient } from "@tangle-network/agent-runtime/kernel";
-import { AgentCandidateBenchmarkGraderPort, AgentCandidateExecutionClaimStore, AgentCandidateExecutorPort, AgentCandidateExecutorRequest, AgentCandidateExecutorStopRequest, AgentCandidateOutputArtifactPort, AgentCandidateRunFinalization, PreparedAgentCandidateExecution } from "@tangle-network/agent-runtime";
+import { AgentProfile, SandboxClient, sumSandboxUsage } from "@tangle-network/agent-runtime/kernel";
+import { SandboxEvent } from "@tangle-network/sandbox";
+import { AgentCandidateBenchmarkGraderPort, AgentCandidateExecutionClaimStore, AgentCandidateExecutorPort, AgentCandidateExecutorRequest, AgentCandidateExecutorStopRequest, AgentCandidateOutputArtifactPort, AgentCandidateRunFinalization, PreparedAgentCandidateExecution } from "@tangle-network/agent-runtime/candidate-execution";
 import { TraceStore } from "@tangle-network/agent-eval";
 //#region src/resolve-client.d.ts
 interface ResolveBenchClientOptions {
@@ -47,8 +48,16 @@ interface BenchCell {
   /** The agent under test. Defaults to a minimal `{ name, metadata.backendType }` profile. */
   readonly profile?: AgentProfile;
 }
-/** Runs one (adapter, task, cell) shot and returns the deliverable text. The default uses
- *  `openSandboxRun`; tests inject a deterministic stub so the matrix runs offline. */
+/** A worker's artifact and observed execution evidence, before external grading. */
+interface BenchShotResult {
+  readonly artifact: string;
+  readonly ok: boolean;
+  readonly detail?: string;
+  /** Provider observations, including explicit unknown counters. Omitted when the shot reports none. */
+  readonly usage?: ReturnType<typeof sumSandboxUsage>;
+  readonly events?: readonly SandboxEvent[];
+}
+/** Runs one (adapter, task, cell) shot. Defaults to `openSandboxRun`. */
 type BenchShot = (input: {
   readonly adapter: BenchmarkAdapter;
   readonly task: BenchTask;
@@ -59,16 +68,15 @@ type BenchShot = (input: {
   readonly attempt?: number;
   readonly routerBaseUrl: string;
   readonly routerKey: string;
+  /** Optional inference credential for the box; routerKey continues to authorize sandbox control. */
+  readonly modelApiKey?: string;
   readonly bridgeUrl?: string;
   readonly bridgeBearer?: string;
   readonly sandboxBaseUrl?: string;
   readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
   readonly resolveClient?: typeof resolveBenchClient;
-}) => Promise<{
-  artifact: string;
-  ok: boolean;
-  detail?: string;
-}>;
+}) => Promise<BenchShotResult>;
 interface RunBenchmarksOptions {
   /** Registry keys (`resolveAdapter`) — the benchmark subset to run. */
   readonly benchmarks: readonly string[];
@@ -76,6 +84,8 @@ interface RunBenchmarksOptions {
   readonly cells: readonly BenchCell[];
   readonly routerBaseUrl: string;
   readonly routerKey: string;
+  /** Optional inference credential for the box; never used for sandbox creation or deletion. */
+  readonly modelApiKey?: string;
   readonly bridgeUrl?: string;
   readonly bridgeBearer?: string;
   readonly sandboxBaseUrl?: string;
@@ -89,6 +99,8 @@ interface RunBenchmarksOptions {
   readonly concurrency?: number;
   /** Per-shot wall-clock (ms). */
   readonly timeoutMs?: number;
+  /** Cancels active shots and prevents queued shots from starting. */
+  readonly signal?: AbortSignal;
   /** Test seam: resolve the runtime transport. Defaults to `resolveBenchClient`. */
   readonly resolveClient?: typeof resolveBenchClient;
   /** Max attempts per (benchmark × cell × task). Default 1. Attempts after the first receive
@@ -115,6 +127,11 @@ interface BenchCellTaskResult {
   readonly ok: boolean;
   readonly detail?: string;
   readonly wallMs: number;
+  /** Exact bytes given to the benchmark judge, retained even when judging fails. */
+  readonly artifact?: string;
+  readonly usage?: ReturnType<typeof sumSandboxUsage>;
+  /** Worker events only; benchmark grading remains outside this trace. */
+  readonly events?: readonly SandboxEvent[];
 }
 interface BenchLeaderboardRow {
   readonly benchmark: string;
@@ -302,5 +319,5 @@ declare class FilePierCandidateTrialController implements PierCandidateTrialCont
 //#region src/pier-result-grader.d.ts
 declare function createPierResultGrader(descriptor: Pick<PierCandidateGraderPort, 'name' | 'version' | 'artifact'>): PierCandidateGraderPort;
 //#endregion
-export { ADAPTERS, type BenchCell, type BenchCellTaskResult, type BenchLeaderboardRow, type BenchScore, type BenchShot, type BenchTask, type BenchmarkAdapter, type ExecutePreparedPierCandidateOptions, FINAL_ANSWER_SENTINEL, FilePierCandidateTrialController, type FilePierCandidateTrialControllerOptions, type JudgeArtifactFileReceipt, type JudgeArtifactReceipt, type LoadOptions, type PierCandidateGraderPort, type PierCandidateOfficialResult, type PierCandidateProcessSpec, type PierCandidateTerminationAcknowledgement, type PierCandidateTrialController, type PierCandidateTrialHandle, type PierCandidateTrialIdentity, type PierCandidateTrialResult, type PierDockerConnection, type RagAnswerScore, type RagContext, type RunBenchmarksOptions, type RunBenchmarksReport, StagedJudgeError, type StagedPierCandidateExecution, type StagedRunCaptureSpec, type StagedRunSpec, type SweBenchAdapterOptions, type SweBenchArtifactCaptureContext, type SweBenchCacheLevel, answerScoreToBenchScore, contextBlock, contextsFrom, createCragAdapter, createNoMiraclAdapter, createOpenRagBenchAdapter, createPierCandidateRecoveryExecutor, createPierResultGrader, createRagBenchAdapter, createSweBenchAdapter, createT2RagBenchAdapter, executePreparedPierCandidate, normalizeAnswer, parseCitations, parseFinalAnswer, printBenchmarksReport, ragAnswerOutput, resolveAdapter, runBenchmarks, runStagedJudge, scoreAnswerArtifact, scoreSweReport, sweEvaluationArgv, swePatchOutput, tokenF1 };
+export { ADAPTERS, type BenchCell, type BenchCellTaskResult, type BenchLeaderboardRow, type BenchScore, type BenchShot, type BenchShotResult, type BenchTask, type BenchmarkAdapter, type ExecutePreparedPierCandidateOptions, FINAL_ANSWER_SENTINEL, FilePierCandidateTrialController, type FilePierCandidateTrialControllerOptions, type JudgeArtifactFileReceipt, type JudgeArtifactReceipt, type LoadOptions, type PierCandidateGraderPort, type PierCandidateOfficialResult, type PierCandidateProcessSpec, type PierCandidateTerminationAcknowledgement, type PierCandidateTrialController, type PierCandidateTrialHandle, type PierCandidateTrialIdentity, type PierCandidateTrialResult, type PierDockerConnection, type RagAnswerScore, type RagContext, type RunBenchmarksOptions, type RunBenchmarksReport, StagedJudgeError, type StagedPierCandidateExecution, type StagedRunCaptureSpec, type StagedRunSpec, type SweBenchAdapterOptions, type SweBenchArtifactCaptureContext, type SweBenchCacheLevel, answerScoreToBenchScore, contextBlock, contextsFrom, createCragAdapter, createNoMiraclAdapter, createOpenRagBenchAdapter, createPierCandidateRecoveryExecutor, createPierResultGrader, createRagBenchAdapter, createSweBenchAdapter, createT2RagBenchAdapter, executePreparedPierCandidate, normalizeAnswer, parseCitations, parseFinalAnswer, printBenchmarksReport, ragAnswerOutput, resolveAdapter, runBenchmarks, runStagedJudge, scoreAnswerArtifact, scoreSweReport, sweEvaluationArgv, swePatchOutput, tokenF1 };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -14,12 +14,11 @@ import { createHash } from "node:crypto";
 import { accessSync, closeSync, constants, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { createExecutor, inlineSandboxClient, openSandboxRun, resolveSandboxClient } from "@tangle-network/agent-runtime/kernel";
+import { SandboxRunAbortError, createExecutor, inlineSandboxClient, openSandboxRun, resolveSandboxClient, sumSandboxUsage } from "@tangle-network/agent-runtime/kernel";
 import { Sandbox } from "@tangle-network/sandbox";
 import assert from "node:assert/strict";
-import { executePreparedAgentCandidate } from "@tangle-network/agent-runtime";
+import { captureAgentCandidateWorkspaceFiles, executePreparedAgentCandidate } from "@tangle-network/agent-runtime/candidate-execution";
 import { canonicalJson } from "@tangle-network/agent-eval";
-import { captureAgentCandidateWorkspaceFiles } from "@tangle-network/agent-runtime/candidate-execution";
 //#region src/refine-loop.ts
 const defaultDecide = (history) => history[history.length - 1]?.verdict?.valid === true;
 async function runRefineLoop(spec) {
@@ -253,7 +252,8 @@ function finalText(events) {
 }
 /** The default real-agent shot: one `openSandboxRun` over the cell's harness+model, deliverable
 *  extracted by the adapter's parser (or final text), abortable on `timeoutMs`. */
-const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, routerKey, bridgeUrl, bridgeBearer, sandboxBaseUrl, timeoutMs, resolveClient }) => {
+const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, routerKey, modelApiKey, bridgeUrl, bridgeBearer, sandboxBaseUrl, timeoutMs, signal, resolveClient }) => {
+	signal?.throwIfAborted();
 	const client = (resolveClient ?? resolveBenchClient)({
 		backend: cell.backend ?? "router",
 		routerBaseUrl,
@@ -292,7 +292,8 @@ const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, rou
 				model: {
 					provider: profileProvider,
 					model: cell.model,
-					baseUrl: routerBaseUrl
+					baseUrl: routerBaseUrl,
+					...modelApiKey === void 0 ? {} : { apiKey: modelApiKey }
 				}
 			}
 		}
@@ -305,7 +306,7 @@ const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, rou
 	const timer = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
 	const runOptions = {
 		agentRun,
-		signal: controller.signal,
+		signal: signal ? AbortSignal.any([controller.signal, signal]) : controller.signal,
 		runId: `bench:${adapter.name}:${task.id}:${uniq}`,
 		scenarioId: task.id
 	};
@@ -319,9 +320,20 @@ const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, rou
 		});
 		if (sres.exitCode !== 0) throw new Error(`boxSetup failed (exit ${sres.exitCode}): ${(sres.stderr ?? "").slice(0, 200)}`);
 	};
-	const run = await openSandboxRun(client, runOptions, deliverable);
+	let run;
+	let result = {
+		artifact: "",
+		ok: false
+	};
 	try {
+		run = await openSandboxRun(client, runOptions, deliverable);
 		const turn = await run.start(prompt ?? task.prompt);
+		result = {
+			artifact: "",
+			ok: false,
+			usage: sumSandboxUsage(turn.events),
+			events: turn.events
+		};
 		let artifact = (turn.out ?? "").trim();
 		let boxExtractError;
 		if (adapter.boxExtract) try {
@@ -358,21 +370,42 @@ const openSandboxShot = async ({ adapter, task, cell, prompt, routerBaseUrl, rou
 		} catch (err) {
 			boxExtractError = err instanceof Error ? err.message.slice(0, 160) : String(err);
 		}
-		const detail = turn.readError !== void 0 ? `read: ${turn.readError.slice(0, 160)}` : boxExtractError !== void 0 ? `boxExtract: ${boxExtractError}` : void 0;
+		const detail = !turn.outcome.success ? turn.outcome.error ?? `agent ended with status ${turn.outcome.status}` : turn.readError !== void 0 ? `read: ${turn.readError.slice(0, 160)}` : boxExtractError !== void 0 ? `boxExtract: ${boxExtractError}` : void 0;
 		if (process.env.BENCH_ARTIFACT_DIR) try {
 			mkdirSync(process.env.BENCH_ARTIFACT_DIR, { recursive: true });
 			const safe = `${adapter.name}_${task.id}_${uniq}`.replace(/[^a-zA-Z0-9_.-]/g, "_");
 			writeFileSync(`${process.env.BENCH_ARTIFACT_DIR}/${safe}.patch`, artifact);
 		} catch {}
-		return {
+		result = {
 			artifact,
-			ok: artifact.length > 0,
+			ok: turn.outcome.success && artifact.length > 0 && turn.readError === void 0 && boxExtractError === void 0,
+			usage: result.usage,
+			events: turn.events,
 			...detail ? { detail } : {}
 		};
+	} catch (err) {
+		result = {
+			...result,
+			ok: false,
+			detail: err instanceof Error ? err.message : String(err),
+			...err instanceof SandboxRunAbortError ? {
+				usage: sumSandboxUsage(err.events),
+				events: err.events
+			} : {}
+		};
 	} finally {
 		if (timer) clearTimeout(timer);
-		await run.close();
+		try {
+			await run?.close();
+		} catch (err) {
+			const cleanup = `cleanup: ${err instanceof Error ? err.message : String(err)}`;
+			result = {
+				...result,
+				detail: combineDetails(result.detail, cleanup)
+			};
+		}
 	}
+	return result;
 };
 function parseMaybeJson(value) {
 	try {
@@ -426,30 +459,54 @@ function retryPrompt(task, history, scores) {
 }
 async function loopedShot(input, shot, attempts) {
 	const scores = /* @__PURE__ */ new Map();
-	const result = await runRefineLoop({
-		rounds: attempts,
-		prompt: (round, history) => round === 1 ? input.task.prompt : retryPrompt(input.task, history, scores),
-		runShot: async (prompt, round) => {
-			const out = await shot({
-				...input,
-				prompt,
-				attempt: round
-			});
-			return {
-				artifact: out.artifact,
-				note: out.detail
-			};
-		},
-		judge: async (artifact, round) => {
-			const score = await input.adapter.judge(input.task, artifact);
-			scores.set(round, score);
-			return {
-				valid: score.resolved,
-				score: score.score
-			};
-		}
-	});
+	const shots = /* @__PURE__ */ new Map();
+	let pendingShot = false;
+	let result;
+	try {
+		result = await runRefineLoop({
+			rounds: attempts,
+			prompt: (round, history) => round === 1 ? input.task.prompt : retryPrompt(input.task, history, scores),
+			runShot: async (prompt, round) => {
+				input.signal?.throwIfAborted();
+				pendingShot = true;
+				const out = await shot({
+					...input,
+					prompt,
+					attempt: round
+				});
+				shots.set(round, out);
+				pendingShot = false;
+				return {
+					artifact: out.artifact,
+					note: out.detail
+				};
+			},
+			judge: async (artifact, round) => {
+				const score = await input.adapter.judge(input.task, artifact);
+				scores.set(round, score);
+				const succeeded = shots.get(round)?.ok === true;
+				return {
+					valid: succeeded && score.resolved,
+					score: succeeded ? score.score : 0
+				};
+			}
+		});
+	} catch (err) {
+		const completed = [...shots.values()];
+		return {
+			artifact: completed.at(-1)?.artifact ?? "",
+			ok: false,
+			usage: combinedUsage(pendingShot ? [...completed, {
+				artifact: "",
+				ok: false
+			}] : completed),
+			events: completed.flatMap((shot) => shot.events ?? []),
+			detail: err instanceof Error ? err.message : String(err)
+		};
+	}
 	const best = result.rounds.reduce((winner, candidate) => {
+		if (shots.get(candidate.round)?.ok !== true) return winner;
+		if (shots.get(winner.round)?.ok !== true) return candidate;
 		const a = scores.get(winner.round);
 		const b = scores.get(candidate.round);
 		if (!a) return candidate;
@@ -461,7 +518,9 @@ async function loopedShot(input, shot, attempts) {
 	const bestScore = scores.get(best.round);
 	return {
 		artifact: best.artifact,
-		ok: best.artifact.trim().length > 0,
+		ok: shots.get(best.round)?.ok === true && best.artifact.trim().length > 0,
+		usage: combinedUsage([...shots.values()]),
+		events: [...shots.values()].flatMap((shot) => shot.events ?? []),
 		detail: JSON.stringify({
 			mode: "refine-loop",
 			attempts: result.rounds.length,
@@ -477,6 +536,33 @@ async function loopedShot(input, shot, attempts) {
 		})
 	};
 }
+function combinedUsage(shots) {
+	const usage = {
+		input: 0,
+		output: 0,
+		costUsd: 0
+	};
+	let tokensKnown = shots.length > 0;
+	let usdKnown = shots.length > 0;
+	let estimate;
+	let unknownReason;
+	for (const shot of shots) {
+		usage.input += shot.usage?.input ?? 0;
+		usage.output += shot.usage?.output ?? 0;
+		usage.costUsd += shot.usage?.costUsd ?? 0;
+		tokensKnown &&= shot.usage !== void 0 && shot.usage.tokensKnown !== false;
+		usdKnown &&= shot.usage !== void 0 && shot.usage.usdKnown !== false;
+		unknownReason ??= shot.usage?.tokensUnknownReason;
+		if (shot.usage?.estimatedCostUsd !== void 0) estimate = (estimate ?? 0) + shot.usage.estimatedCostUsd;
+	}
+	return {
+		...usage,
+		...tokensKnown ? {} : { tokensKnown: false },
+		...usdKnown ? {} : { usdKnown: false },
+		...estimate === void 0 ? {} : { estimatedCostUsd: estimate },
+		...unknownReason === void 0 ? {} : { tokensUnknownReason: unknownReason }
+	};
+}
 function combineDetails(runDetail, scoreDetail) {
 	if (runDetail && scoreDetail) return JSON.stringify({
 		run: parseMaybeJson(runDetail),
@@ -535,6 +621,7 @@ async function prepareBenchmarks(benchmarks, resolve, opts) {
 	};
 }
 async function runBenchmarks(opts) {
+	opts.signal?.throwIfAborted();
 	if (opts.benchmarks.length === 0) throw new Error("runBenchmarks: no benchmarks selected");
 	if (opts.cells.length === 0) throw new Error("runBenchmarks: no cells to run");
 	const reps = Math.max(1, opts.reps ?? 1);
@@ -553,20 +640,24 @@ async function runBenchmarks(opts) {
 	await runPool(jobs, Math.max(1, opts.concurrency ?? 4), async (job, index) => {
 		const startedAt = Date.now();
 		let result;
+		let out;
 		try {
+			opts.signal?.throwIfAborted();
 			const shotInput = {
 				adapter: job.adapter,
 				task: job.task,
 				cell: job.cell,
 				routerBaseUrl: opts.routerBaseUrl,
 				routerKey: opts.routerKey,
+				...opts.modelApiKey === void 0 ? {} : { modelApiKey: opts.modelApiKey },
 				...opts.bridgeUrl ? { bridgeUrl: opts.bridgeUrl } : {},
 				...opts.bridgeBearer ? { bridgeBearer: opts.bridgeBearer } : {},
 				...opts.sandboxBaseUrl ? { sandboxBaseUrl: opts.sandboxBaseUrl } : {},
 				...opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {},
+				...opts.signal ? { signal: opts.signal } : {},
 				...opts.resolveClient ? { resolveClient: opts.resolveClient } : {}
 			};
-			const out = loopAttempts > 1 ? await loopedShot(shotInput, shot, loopAttempts) : await shot(shotInput);
+			out = loopAttempts > 1 ? await loopedShot(shotInput, shot, loopAttempts) : await shot(shotInput);
 			const score = await job.adapter.judge(job.task, out.artifact);
 			result = {
 				benchmark: job.benchmark,
@@ -577,7 +668,10 @@ async function runBenchmarks(opts) {
 				score: out.ok ? score.score : 0,
 				ok: out.ok,
 				...out.detail ?? score.detail ? { detail: combineDetails(out.detail, score.detail) } : {},
-				wallMs: Date.now() - startedAt
+				wallMs: Date.now() - startedAt,
+				artifact: out.artifact,
+				...out.usage === void 0 ? {} : { usage: out.usage },
+				...out.events === void 0 ? {} : { events: out.events }
 			};
 		} catch (err) {
 			result = {
@@ -589,7 +683,10 @@ async function runBenchmarks(opts) {
 				score: 0,
 				ok: false,
 				detail: err instanceof Error ? err.message.slice(0, 200) : String(err),
-				wallMs: Date.now() - startedAt
+				wallMs: Date.now() - startedAt,
+				...out === void 0 ? {} : { artifact: out.artifact },
+				...out?.usage === void 0 ? {} : { usage: out.usage },
+				...out?.events === void 0 ? {} : { events: out.events }
 			};
 		}
 		perTask.push(result);