pi-crew 0.9.41 → 0.9.44

package/src/runtime/coalesce-tasks.ts

@@ -78,7 +78,7 @@ export function planCoalescedGroups(
 	const buckets = new Map<string, TeamTaskState[]>();
 	for (const taskId of readyTaskIds) {
 		const task = taskById.get(taskId);
-		if (!task || !task.stepId) continue;
+		if (!task?.stepId) continue;
 		const step = stepById.get(task.stepId);
 		if (!step) continue;
 

package/src/runtime/compact-stages/tail-capture-stage.ts

@@ -59,7 +59,7 @@ export class TailCaptureStage implements ICompactStage {
 			// never contains a partial multi-byte sequence.
 			if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
 			let tail = text.slice(Math.max(0, text.length - this.maxBytes));
-			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(1024);
+			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(0, -1);
 			return this.marker ? `${this.marker}\n${tail}` : tail;
 		}
 		// Char cap mode.

package/src/runtime/crash-recovery.ts

@@ -397,31 +397,43 @@ export function purgeStaleActiveRunIndex(staleThresholdMs = 300_000, now = Date.
 		if (manifest?.status === "running" && manifest.async?.pid !== undefined) {
 			const pidAlive = checkProcessLiveness(manifest.async.pid).alive;
 			if (!pidAlive && !hasRecentLifeEvidence(entry, manifest.updatedAt, now, staleThresholdMs)) {
-				// Dead PID + no recent life evidence → cancel the manifest and unregister
+				// Dead PID + no recent life evidence → cancel the manifest and unregister.
+				// RT-F5: wrap load+modify+save in withRunLockSync so concurrent writers
+				// (e.g. team-runner final saveRunTasks) cannot interleave between the
+				// repaired-tasks write and the manifest-status flip. terminateLiveAgentsForRun
+				// is fire-and-forget so it stays OUTSIDE the lock to avoid blocking the
+				// critical section on async IPC.
 				try {
-					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId);
 					if (fullLoaded) {
-						const now_iso = new Date(now).toISOString();
-						const repairedTasks = fullLoaded.tasks.map((task) => {
-							if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
-								return {
-									...task,
-									status: "cancelled" as const,
-									finishedAt: now_iso,
-									error: "Orphaned run: worker process dead and no recent activity",
-								};
+						withRunLockSync(fullLoaded.manifest, () => {
+							// Re-read under lock so the stale-best-effort load above
+							// can't cause us to clobber a fresh status flip.
+							const fresh = loadRunManifestById(entry.cwd, entry.runId);
+							if (!fresh) return;
+							if (fresh.manifest.status !== "running") return;
+							const now_iso = new Date(now).toISOString();
+							const repairedTasks = fresh.tasks.map((task) => {
+								if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+									return {
+										...task,
+										status: "cancelled" as const,
+										finishedAt: now_iso,
+										error: "Orphaned run: worker process dead and no recent activity",
+									};
+								}
+								return task;
+							});
+							saveRunTasks(fresh.manifest, repairedTasks);
+							for (const task of repairedTasks) {
+								try {
+									upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+								} catch {
+									/* non-critical */
+								}
 							}
-							return task;
+							updateRunStatus(fresh.manifest, "cancelled", "Orphaned run: worker process dead and no recent activity");
 						});
-						saveRunTasks(fullLoaded.manifest, repairedTasks);
-						for (const task of repairedTasks) {
-							try {
-								upsertCrewAgent(fullLoaded.manifest, recordFromTask(fullLoaded.manifest, task, "scaffold"));
-							} catch {
-								/* non-critical */
-							}
-						}
-						updateRunStatus(fullLoaded.manifest, "cancelled", "Orphaned run: worker process dead and no recent activity");
 						void terminateLiveAgentsForRun(
 							fullLoaded.manifest.runId,
 							"cancelled",
@@ -447,35 +459,39 @@ export function purgeStaleActiveRunIndex(staleThresholdMs = 300_000, now = Date.
 		if (manifest?.status === "running" && manifest.async === undefined) {
 			if (!hasRecentLifeEvidence(entry, manifest.updatedAt, now, staleThresholdMs)) {
 				try {
-					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId);
 					if (fullLoaded && fullLoaded.manifest.status === "running") {
-						const now_iso = new Date(now).toISOString();
-						const repairedTasks = fullLoaded.tasks.map((task) => {
-							if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
-								return {
-									...task,
-									status: "cancelled" as const,
-									finishedAt: now_iso,
-									error: "Orphaned run: workflow completed but manifest never updated to terminal status",
-								};
+						withRunLockSync(fullLoaded.manifest, () => {
+							const fresh = loadRunManifestById(entry.cwd, entry.runId);
+							if (fresh?.manifest.status !== "running") return;
+							const now_iso = new Date(now).toISOString();
+							const repairedTasks = fresh.tasks.map((task) => {
+								if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+									return {
+										...task,
+										status: "cancelled" as const,
+										finishedAt: now_iso,
+										error: "Orphaned run: workflow completed but manifest never updated to terminal status",
+									};
+								}
+								return task;
+							});
+							saveRunTasks(fresh.manifest, repairedTasks);
+							for (const task of repairedTasks) {
+								try {
+									upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+								} catch {
+									/* non-critical */
+								}
 							}
-							return task;
+							updateRunStatus(
+								fresh.manifest,
+								"cancelled",
+								"Orphaned run: no async worker and no manifest update in over " +
+									Math.round(staleThresholdMs / 60000) +
+									" minutes",
+							);
 						});
-						saveRunTasks(fullLoaded.manifest, repairedTasks);
-						for (const task of repairedTasks) {
-							try {
-								upsertCrewAgent(fullLoaded.manifest, recordFromTask(fullLoaded.manifest, task, "scaffold"));
-							} catch {
-								/* non-critical */
-							}
-						}
-						updateRunStatus(
-							fullLoaded.manifest,
-							"cancelled",
-							"Orphaned run: no async worker and no manifest update in over " +
-								Math.round(staleThresholdMs / 60000) +
-								" minutes",
-						);
 						void terminateLiveAgentsForRun(
 							fullLoaded.manifest.runId,
 							"cancelled",

package/src/runtime/delivery-coordinator.ts

@@ -21,7 +21,6 @@ export interface DeliveryCoordinatorDeps {
 const PENDING_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 export class DeliveryCoordinator {
-	private ownerSessionId: string | undefined;
 	private active = false;
 	private generation = 0;
 	private pending: PendingDelivery[] = [];
@@ -29,6 +28,7 @@ export class DeliveryCoordinator {
 	private readonly deps: DeliveryCoordinatorDeps;
 	private ttlTimer: ReturnType<typeof setInterval> | undefined;
 	private timerStarted = false;
+	private ownerSessionId: string | undefined = undefined;
 
 	constructor(deps: DeliveryCoordinatorDeps) {
 		this.deps = deps;

package/src/runtime/deterministic-ast.ts

@@ -120,9 +120,9 @@ function isNewDateExpression(node: AstNode): boolean {
  */
 function isMemberExpression(node: AstNode, childKey: string, objectName: string, propertyName: string): boolean {
 	const child = asAstNode(node[childKey]);
-	if (!child || child.type !== "MemberExpression") return false;
+	if (child?.type !== "MemberExpression") return false;
 	const object = asAstNode(child.object);
-	if (!object || object.type !== "Identifier" || object.name !== objectName) return false;
+	if (object?.type !== "Identifier" || object.name !== objectName) return false;
 	return propertyNameOf(child) === propertyName;
 }
 

package/src/runtime/diagnostic-export.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import type { MetricSnapshot } from "../observability/metrics-primitives.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { readEvents, type TeamEvent } from "../state/event-log.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -148,7 +149,7 @@ export async function exportDiagnostic(
 	const dir = path.join(loaded.manifest.artifactsRoot, "diagnostic");
 	fs.mkdirSync(dir, { recursive: true });
 	const filePath = path.join(dir, `diagnostic-${safeTimestamp}.json`);
-	fs.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+	atomicWriteFile(filePath, `${JSON.stringify(report, null, 2)}\n`);
 	return { path: filePath, report };
 }
 

package/src/runtime/dwf-state-store.ts

@@ -28,6 +28,11 @@ export interface DwfCheckpointState {
 	logs: string[]; // capped copy (≤1000); the events log (dwf.log) is the durable source of truth
 	spent: number; // budget accumulator (round-14 P1-2)
 	agentCount: number;
+	/** PERS-1: per-agent-call idempotency cache. Maps a deterministic call ID to the
+	 *  cached result so a DWF resume skips already-completed agent calls (avoids
+	 *  duplicating artifacts/mailbox/tokens). Uses Record (not Map) for JSON
+	 *  serialization safety. */
+	completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }>;
 	updatedAt: string;
 }
 

package/src/runtime/dynamic-workflow-context.ts

@@ -35,6 +35,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../worktree/worktree-manager.ts";
 import { runChildPi } from "./child-pi.ts";
 import type { DwfCheckpointState } from "./dwf-state-store.ts";
+import { withWorkerSlot } from "./global-worker-cap.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { parsePiJsonOutput } from "./pi-json-output.ts";
 import { renderPlanTemplate } from "./plan-templates.ts";
@@ -269,6 +270,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		logs: opts.resumedState ? [...opts.resumedState.logs].slice(0, 1000) : [],
 		args: opts.args ?? {},
 	};
+	// PERS-1: per-agent-call idempotency cache. Hydrated from resumedState so a DWF
+	// resume skips already-completed agent calls (avoids duplicating artifacts/mailbox/tokens).
+	// Uses Record (not Map) for JSON serialization safety.
+	const completedAgentCalls: Record<string, { text: string; usage?: { input: number; output: number } }> =
+		opts.resumedState?.completedAgentCalls ?? {};
 	// round-14 P1-2: frozen budget surface. The closures read wfState.spent so the
 	// object stays live after Object.freeze(ctx). total is a snapshot primitive.
 	const budget = Object.freeze({
@@ -290,10 +296,35 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 			// regardless of which return/throw path is taken.
 			let worktreePath: string | undefined;
 			let worktreeBranch: string | undefined;
+			// BDG-2: declared before the try so the catch block can un-reserve on failure.
+			const ESTIMATE = 4096;
+			let reserved = false;
 			try {
-				// round-14 P1-2: budget check BEFORE spawning. When the per-workflow token
-				// budget is exhausted, reject the call without consuming a child worker.
-				if (budget.total !== null && budget.remaining() <= 0) {
+				// PERS-1: per-agent-call idempotency. Compute a deterministic call ID
+				// from the call arguments and check if this call was already completed
+				// (e.g. during a previous run before a crash). If so, return the cached
+				// result without re-spawning the agent.
+				const callId = JSON.stringify({
+					role: call.role,
+					agent: call.agent,
+					prompt: call.prompt,
+					model: call.model,
+					schema: call.schema ? "yes" : "no",
+				});
+				const cached = completedAgentCalls[callId];
+				if (cached) {
+					return {
+						ok: true,
+						text: cached.text,
+						usage: cached.usage,
+						durationMs: 0,
+					};
+				}
+
+				// BDG-2: reserve-then-adjust budget. Before spawning, estimate the cost and
+				// reserve it by adding to wfState.spent. This prevents N concurrent calls from
+				// all seeing the same remaining budget and overspending.
+				if (budget.total !== null && budget.remaining() < ESTIMATE) {
 					return {
 						ok: false,
 						text: "",
@@ -301,6 +332,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: 0,
 					};
 				}
+				// Reserve the estimate before spawning.
+				wfState.spent += ESTIMATE;
+				reserved = true;
+
 				const agentConfig = resolveAgentForRole(call.role, {
 					explicitAgent: call.agent,
 					team: opts.team,
@@ -353,20 +388,25 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					}
 				}
 
-				const childResult = await runChildPi({
-					cwd: agentCwd,
-					task,
-					agent: effectiveAgent,
-					model: call.model ?? opts.modelOverride ?? agentConfig.model,
-					skillPaths: undefined, // skills resolved via agent config + team-role plumbing
-					maxTurns: call.maxTurns,
-					graceTurns: call.graceTurns,
-					signal: opts.signal,
-					artifactsRoot: manifest.artifactsRoot,
-					runId: manifest.runId,
-					role: call.role ?? call.agent,
-				});
+				const childResult = await withWorkerSlot(() =>
+					runChildPi({
+						cwd: agentCwd,
+						task,
+						agent: effectiveAgent,
+						model: call.model ?? opts.modelOverride ?? agentConfig.model,
+						skillPaths: undefined, // skills resolved via agent config + team-role plumbing
+						maxTurns: call.maxTurns,
+						graceTurns: call.graceTurns,
+						signal: opts.signal,
+						artifactsRoot: manifest.artifactsRoot,
+						runId: manifest.runId,
+						role: call.role ?? call.agent,
+					}),
+				);
 				if (childResult.exitCode !== 0 || childResult.error) {
+					// BDG-2: un-reserve the estimate on spawn failure.
+					wfState.spent -= ESTIMATE;
+					reserved = false;
 					return {
 						ok: false,
 						text: "",
@@ -376,8 +416,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 				}
 				const parsed = parsePiJsonOutput(childResult.stdout);
 				// round-14 P1-2: accumulate this run's token usage into the workflow budget.
-				// Covers both the success and schema-mismatch paths (both report parsed.usage).
-				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0);
+				// BDG-2: adjust the reserve — subtract the estimate, add the actual usage.
+				// This correctly reduces spent when actualUsage < ESTIMATE.
+				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0) - ESTIMATE;
+				reserved = false;
 				let text = parsed.finalText ?? "";
 				// Round-11 test fix: parsePiJsonOutput only extracts text from pi event stream
 				// ({type:"message_end", message:{role:"assistant", content:[...]}}). When the
@@ -400,6 +442,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					producer: "dynamic-workflow",
 				});
 				if (call.schema !== undefined && !extracted.structured) {
+					// BDG-2: un-reserve was already done above (reserved = false after adjust).
 					return {
 						ok: false,
 						text,
@@ -409,6 +452,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: Date.now() - started,
 					};
 				}
+				// PERS-1: cache the successful result for idempotency on resume.
+				completedAgentCalls[callId] = {
+					text,
+					usage: { input: parsed.usage?.input ?? 0, output: parsed.usage?.output ?? 0 },
+				};
 				return {
 					ok: true,
 					text,
@@ -418,6 +466,8 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					durationMs: Date.now() - started,
 				};
 			} catch (error) {
+				// BDG-2: un-reserve the estimate on failure (only if still reserved).
+				if (reserved) wfState.spent -= ESTIMATE;
 				logInternalError("dynamic-workflow-context.agent", error, `runId=${manifest.runId}`);
 				return {
 					ok: false,
@@ -450,6 +500,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 							logs: wfState.logs.slice(0, 1000),
 							spent: wfState.spent,
 							agentCount,
+							completedAgentCalls,
 							updatedAt: new Date().toISOString(),
 						});
 					} catch (checkpointError) {
@@ -709,6 +760,12 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		get: () => agentCount,
 		enumerable: false,
 	});
+	// PERS-1: completedAgentCalls is read-only from the runner; the agent() method
+	// is the only writer. Exposed so getWorkflowCheckpoint() can include it.
+	Object.defineProperty(ctx, "__completedAgentCalls", {
+		get: () => completedAgentCalls,
+		enumerable: false,
+	});
 	return ctx;
 }
 
@@ -757,6 +814,9 @@ export function getWorkflowCheckpoint(ctx: WorkflowCtx): DwfCheckpointState {
 		logs: logs ?? [],
 		spent: ctx.budget.spent(),
 		agentCount: (ctx as unknown as { __agentCount?: number }).__agentCount ?? 0,
+		completedAgentCalls:
+			(ctx as unknown as { __completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }> })
+				.__completedAgentCalls ?? {},
 		updatedAt: new Date().toISOString(),
 	};
 }

package/src/runtime/dynamic-workflow-runner.ts

@@ -19,6 +19,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { transformSync } from "esbuild";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -113,7 +114,11 @@ async function loadWorkflowModule(scriptPath: string): Promise<DynamicWorkflowSc
 	// raw .dwf.ts file. This is the same source jiti will execute.
 	const scriptSource = readFileSync(scriptPath, "utf-8");
 	if (isDeterminismCheckEnabled()) {
-		assertDeterministicScript(scriptSource);
+		// DISC-1: acorn can only parse JavaScript, not TypeScript. Real .dwf.ts files
+		// contain type annotations/imports that cause a silent parse error, so the
+		// determinism check never runs. Transpile to JS via esbuild first.
+		const js = transformSync(scriptSource, { loader: "ts", format: "esm" }).code;
+		assertDeterministicScript(js);
 	}
 	// jiti is the same loader async-runner.ts uses (resolveTypeScriptLoader). We require it
 	// lazily so this module stays importable in environments without jiti (type-only consumers).
@@ -166,9 +171,16 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		});
 	}
 
+	// ERR-1: Create a timeout AbortController so we can abort spawned children on script timeout.
+	// Combine the input signal with the timeout controller's signal so EITHER source
+	// (external abort OR our timeout) propagates to runChildPi via the ctx.
+	// AbortSignal.any is available since Node 20.3 — the project requires Node 20+.
+	const timeoutController = new AbortController();
+	const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
+
 	const ctx = makeWorkflowCtx(manifest, {
 		concurrency: input.concurrency ?? workflow.maxConcurrency ?? 4,
-		signal,
+		signal: combinedSignal,
 		team: input.team,
 		modelOverride: input.modelOverride,
 		tokenBudget: input.tokenBudget ?? workflow.maxTokenBudget,
@@ -200,6 +212,10 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		let timeoutHandle: NodeJS.Timeout | undefined;
 		const timeoutPromise = new Promise<never>((_, reject) => {
 			timeoutHandle = setTimeout(() => {
+				// ERR-1: abort the timeout controller so the abort propagates to
+				// runChildPi (via the combined signal passed to makeWorkflowCtx),
+				// which kills spawned children instead of letting them run.
+				timeoutController.abort();
 				reject(
 					new Error(
 						`Dynamic workflow script timed out after ${SCRIPT_TIMEOUT_MS}ms. The script may have spawned a child process that did not exit. Check for spawn/exec calls without proper stdio handling.`,

package/src/runtime/foreground-control.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
@@ -82,7 +83,7 @@ export function writeForegroundInterruptRequest(
 			try {
 				fs.mkdirSync(lockDir, { recursive: true });
 				try {
-					fs.writeFileSync(pidFile, String(process.pid), "utf-8");
+					atomicWriteFile(pidFile, String(process.pid));
 				} catch {
 					/* best-effort */
 				}
@@ -178,7 +179,7 @@ export function writeForegroundInterruptRequest(
 			acknowledged: false,
 		};
 		fs.mkdirSync(path.dirname(controlPath), { recursive: true });
-		fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
+		atomicWriteFile(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`);
 		appendEvent(manifest.eventsPath, {
 			type: "foreground.interrupt_requested",
 			runId: manifest.runId,

package/src/runtime/goal-evaluator.ts

@@ -188,7 +188,9 @@ function tryParseDirectVerdict(stdout: string): { achieved: boolean; reason: str
  * Returns a GoalVerdict. On any failure (non-zero exit, non-JSON, invalid shape),
  * returns a `BLOCKED:`-prefixed verdict so the loop stops (§0c C6 fallback).
  */
-export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdict> {
+export async function evaluateGoal(
+	input: EvaluateGoalInput,
+): Promise<{ verdict: GoalVerdict; judgeUsage?: { totalTokens: number; inputTokens?: number; outputTokens?: number } }> {
 	const agent = synthesizeJudgeAgentConfig();
 	const task = buildJudgeTask(input);
 	const evaluatedAt = new Date().toISOString();
@@ -212,12 +214,15 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		});
 
 		if (result.exitCode !== 0 || result.error) {
-			return blockedVerdict(
-				input.turn,
-				input.model,
-				evaluatedAt,
-				`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
-			);
+			return {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 
 		const parsed = parsePiJsonOutput(result.stdout);
@@ -231,16 +236,22 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		const direct = !finalText.trim() ? tryParseDirectVerdict(result.stdout) : undefined;
 		if (direct) {
 			return {
-				turn: input.turn,
-				achieved: direct.achieved,
-				reason: direct.reason,
-				evidenceRefs: direct.evidenceRefs,
-				evaluatorModel: input.model,
-				evaluatedAt,
+				verdict: {
+					turn: input.turn,
+					achieved: direct.achieved,
+					reason: direct.reason,
+					evidenceRefs: direct.evidenceRefs,
+					evaluatorModel: input.model,
+					evaluatedAt,
+				},
+				judgeUsage: undefined,
 			};
 		}
 		if (!finalText.trim()) {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output");
+			return {
+				verdict: blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output"),
+				judgeUsage: undefined,
+			};
 		}
 
 		const extracted = extractStructuredResult(finalText);
@@ -252,27 +263,48 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 				})
 			: undefined;
 		if (!data || typeof data.achieved !== "boolean" || typeof data.reason !== "string") {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, `judge output not valid verdict JSON: ${truncate(finalText, 200)}`);
+			return {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge output not valid verdict JSON: ${truncate(finalText, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 		const evidenceRefs = Array.isArray(data.evidenceRefs)
 			? data.evidenceRefs.filter((r): r is string => typeof r === "string")
 			: undefined;
+		const judgeUsage = parsed.usage
+			? {
+					totalTokens: (parsed.usage.input ?? 0) + (parsed.usage.output ?? 0),
+					inputTokens: parsed.usage.input,
+					outputTokens: parsed.usage.output,
+				}
+			: undefined;
 		return {
-			turn: input.turn,
-			achieved: data.achieved,
-			reason: data.reason,
-			evidenceRefs,
-			evaluatorModel: input.model,
-			evaluatedAt,
+			verdict: {
+				turn: input.turn,
+				achieved: data.achieved,
+				reason: data.reason,
+				evidenceRefs,
+				evaluatorModel: input.model,
+				evaluatedAt,
+			},
+			judgeUsage,
 		};
 	} catch (error) {
 		logInternalError("goal-evaluator.evaluateGoal", error, `turn=${input.turn}`);
-		return blockedVerdict(
-			input.turn,
-			input.model,
-			evaluatedAt,
-			`judge threw: ${error instanceof Error ? error.message : String(error)}`,
-		);
+		return {
+			verdict: blockedVerdict(
+				input.turn,
+				input.model,
+				evaluatedAt,
+				`judge threw: ${error instanceof Error ? error.message : String(error)}`,
+			),
+			judgeUsage: undefined,
+		};
 	}
 }