@oh-my-pi/pi-coding-agent 15.7.2 → 15.7.5

package/src/edit/hashline/diff.ts

@@ -5,17 +5,25 @@
  * pair to {@link generateDiffString} so the renderer can show the diff
  * while the tool call is still streaming.
  *
- * Validation is intentionally light: only the section snapshot tag is checked
- * (so the preview goes red when anchors are stale), no plan-mode guards
- * and no auto-generated-file refusal — those belong on the write path.
+ * Uses the same snapshot-tag semantics as the apply path: a live content-hash
+ * match is accepted even when the tag was minted by a source that did not keep
+ * history, and stale tags recover through the session snapshot store when possible.
  */
 import {
+	type ApplyResult,
+	applyEdits,
+	computeFileHash,
+	type Edit,
 	Patch as HashlinePatch,
+	hasBlockEdit,
+	MismatchError,
 	missingSnapshotTagMessage,
 	normalizeToLF,
 	type Patch,
 	type PatchSection,
-	type Snapshot,
+	parsePatchStreaming,
+	Recovery,
+	resolveBlockEdits,
 	type SnapshotStore,
 	stripBom,
 } from "@oh-my-pi/hashline";
@@ -48,24 +56,79 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
-function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
-	return snapshot.text === currentText;
+function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
+	return edits.some(edit => {
+		if (edit.kind === "delete") return true;
+		if (edit.kind === "block") return true;
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+	});
 }
-function validateSectionHash(
+
+function createMismatchError(
 	section: PatchSection,
 	absolutePath: string,
-	text: string,
+	normalized: string,
 	snapshots: SnapshotStore,
-): string | null {
-	if (section.fileHash === undefined) {
-		// The snapshot tag is mandatory on every section — head/tail inserts
-		// included — to keep this preview path in lockstep with the apply path
-		// (`Patcher.prepare`), which rejects tagless sections unconditionally.
-		return missingSnapshotTagMessage(section.path);
+	expected: string,
+): MismatchError {
+	return new MismatchError({
+		path: section.path,
+		expectedFileHash: expected,
+		actualFileHash: computeFileHash(normalized),
+		fileLines: normalized.split("\n"),
+		anchorLines: section.collectAnchorLines(),
+		hashRecognized: snapshots.byHash(absolutePath, expected) !== null,
+	});
+}
+
+function parsePreviewEdits(section: PatchSection, streaming: boolean | undefined): readonly Edit[] {
+	return streaming ? parsePatchStreaming(section.diff).edits : section.edits;
+}
+
+function resolvePreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	expected: string | undefined;
+	liveMatches: boolean;
+	edits: readonly Edit[];
+}): readonly Edit[] {
+	const { section, absolutePath, normalized, snapshots, expected, liveMatches, edits } = args;
+	if (!hasBlockEdit(edits)) return edits;
+	const baseText = expected === undefined || liveMatches ? normalized : snapshots.byHash(absolutePath, expected)?.text;
+	if (baseText === undefined) {
+		throw createMismatchError(section, absolutePath, normalized, snapshots, expected ?? "");
 	}
-	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
-	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;
-	return `Hashline snapshot tag mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file does not match that snapshot; re-read and try again.`;
+	return resolveBlockEdits(edits, baseText, section.path, nativeBlockResolver, { onUnresolved: "throw" });
+}
+
+function applyPreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	options: HashlineDiffOptions;
+}): ApplyResult {
+	const { section, absolutePath, normalized, snapshots, options } = args;
+	const expected = section.fileHash;
+	if (!options.skipHashValidation && expected === undefined) {
+		throw new Error(missingSnapshotTagMessage(section.path));
+	}
+	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
+	const edits = parsePreviewEdits(section, options.streaming);
+	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
+	if (options.skipHashValidation || expected === undefined || liveMatches) return applyEdits(normalized, resolved);
+	if (!hasAnchorScopedEdit(resolved)) return applyEdits(normalized, resolved);
+
+	const recovered = new Recovery(snapshots).tryRecover({
+		path: absolutePath,
+		currentText: normalized,
+		fileHash: expected,
+		edits: resolved,
+	});
+	if (recovered) return recovered;
+	throw createMismatchError(section, absolutePath, normalized, snapshots, expected);
 }
 
 export async function computeHashlineSectionDiff(
@@ -79,13 +142,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		if (!options.skipHashValidation) {
-			const hashError = validateSectionHash(section, absolutePath, normalized, snapshots);
-			if (hashError) return { error: hashError };
-		}
-		const result = options.streaming
-			? section.applyPartialTo(normalized, nativeBlockResolver)
-			: section.applyTo(normalized, nativeBlockResolver);
+		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
 		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.text);
 	} catch (err) {

package/src/edit/renderer.ts

@@ -235,23 +235,27 @@ function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string)
 
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
-	// Hunk-aware truncation keeps the change rows themselves visible. Tail-mode
-	// pins the visible window to the bottom of the diff so newly streamed
-	// hunks stay on screen as more arrives, instead of leaving the user stuck
-	// staring at the head of the file while the tail scrolls offscreen.
-	const {
-		text: truncatedDiff,
-		hiddenHunks,
-		hiddenLines,
-	} = truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, EDIT_STREAMING_PREVIEW_LINES, { fromTail: true });
+	// "Cursor" tail window: pin the last EDIT_STREAMING_PREVIEW_LINES rows to the
+	// bottom of the diff so freshly streamed changes stay on screen, and accept
+	// the trailing rows "from the back" once the diff outgrows the window. The
+	// whole-file diff is recomputed on every streamed chunk and its Myers
+	// alignment is not monotonic in payload length, so a hunk-aware window that
+	// kept whole change segments gained and lost rows tick to tick — the box
+	// stuttered, and the earlier high-water fix traded that for a half-empty
+	// rectangle. A strict fixed-height window keeps the box steady and always
+	// full of real diff context instead of blank padding.
+	const allLines = diff.replace(/\n+$/u, "").split("\n");
+	const hiddenLines = Math.max(0, allLines.length - EDIT_STREAMING_PREVIEW_LINES);
+	const visible = hiddenLines > 0 ? allLines.slice(hiddenLines) : allLines;
 	let text = "\n\n";
-	if (hiddenHunks > 0 || hiddenLines > 0) {
+	if (hiddenLines > 0) {
+		const hiddenHunks = getDiffStats(allLines.slice(0, hiddenLines).join("\n")).hunks;
 		const remainder: string[] = [];
 		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
-		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		remainder.push(`${hiddenLines} more lines`);
 		text += `${uiTheme.fg("dim", `… (${remainder.join(", ")} above)`)}\n`;
 	}
-	text += renderDiffColored(truncatedDiff, { filePath: rawPath });
+	text += renderDiffColored(visible.join("\n"), { filePath: rawPath });
 	text += uiTheme.fg("dim", `\n(${label})`);
 	return text;
 }

package/src/eval/__tests__/agent-bridge.test.ts

@@ -0,0 +1,433 @@
+import { afterAll, afterEach, describe, expect, it, vi } from "bun:test";
+import * as path from "node:path";
+import { TempDir } from "@oh-my-pi/pi-utils";
+import { Settings } from "../../config/settings";
+import type { PlanModeState } from "../../plan-mode/state";
+import * as taskDiscovery from "../../task/discovery";
+import type { ExecutorOptions } from "../../task/executor";
+import * as taskExecutor from "../../task/executor";
+import { AgentOutputManager } from "../../task/output-manager";
+import type { AgentDefinition, AgentProgress, SingleResult } from "../../task/types";
+import type { ToolSession } from "../../tools";
+import { EVAL_AGENT_MAX_DEPTH, runEvalAgent } from "../agent-bridge";
+import { disposeAllVmContexts } from "../js/context-manager";
+import { executeJs } from "../js/executor";
+import { disposeAllKernelSessions, executePython } from "../py/executor";
+
+const taskAgent = {
+	name: "task",
+	description: "Task agent",
+	systemPrompt: "Run the task.",
+	source: "bundled",
+	spawns: "*",
+	model: ["pi/task"],
+} satisfies AgentDefinition;
+
+const reviewerAgent = {
+	name: "reviewer",
+	description: "Reviewer agent",
+	systemPrompt: "Review the task.",
+	source: "bundled",
+	model: ["pi/smol"],
+} satisfies AgentDefinition;
+
+interface SessionOptions {
+	cwd?: string;
+	sessionFile?: string | null;
+	artifactsDir?: string | null;
+	spawns?: string | null;
+	depth?: number;
+	activeModel?: string;
+	modelString?: string;
+	enableLsp?: boolean;
+	settings?: Settings;
+	outputManager?: AgentOutputManager;
+	planMode?: boolean;
+}
+
+function makeSession(options: SessionOptions = {}): ToolSession {
+	const settings =
+		options.settings ??
+		Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+		});
+	const artifactsDir = options.artifactsDir ?? null;
+	return {
+		cwd: options.cwd ?? process.cwd(),
+		hasUI: false,
+		settings,
+		taskDepth: options.depth ?? 0,
+		enableLsp: options.enableLsp ?? true,
+		agentOutputManager: options.outputManager,
+		getSessionFile: () => options.sessionFile ?? null,
+		getSessionSpawns: () => options.spawns ?? "*",
+		getActiveModelString: () => options.activeModel ?? "p/active",
+		getModelString: () => options.modelString ?? "p/fallback",
+		getArtifactsDir: () => artifactsDir,
+		getSessionId: () => "test-session",
+		getEvalSessionId: () => "test-eval-session",
+		getPlanModeState: options.planMode
+			? () =>
+					({
+						enabled: true,
+						planFilePath: path.join(options.cwd ?? process.cwd(), "plan.md"),
+					}) satisfies PlanModeState
+			: undefined,
+	};
+}
+
+function mockAgents(agents: AgentDefinition[] = [taskAgent, reviewerAgent]): void {
+	vi.spyOn(taskDiscovery, "discoverAgents").mockResolvedValue({ agents, projectAgentsDir: null });
+}
+
+function singleResult(options: ExecutorOptions, overrides: Partial<SingleResult> = {}): SingleResult {
+	return {
+		index: options.index,
+		id: options.id,
+		agent: options.agent.name,
+		agentSource: options.agent.source,
+		task: options.task,
+		assignment: options.assignment,
+		description: options.description,
+		exitCode: 0,
+		output: "ok",
+		stderr: "",
+		truncated: false,
+		durationMs: 1,
+		tokens: 0,
+		...overrides,
+	};
+}
+
+function makeEvalSession(
+	tempDir: TempDir,
+	prefix: string,
+): { session: ToolSession; sessionFile: string; sessionId: string } {
+	const sessionFile = path.join(tempDir.path(), "session.jsonl");
+	const artifactsDir = sessionFile.slice(0, -6);
+	const session = makeSession({
+		cwd: tempDir.path(),
+		sessionFile,
+		artifactsDir,
+		outputManager: new AgentOutputManager(() => artifactsDir),
+	});
+	return { session, sessionFile, sessionId: `${prefix}:${crypto.randomUUID()}` };
+}
+
+describe("runEvalAgent", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("resolves the default task agent and agentType overrides", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
+			singleResult(options, {
+				output: options.agent.name,
+			}),
+		);
+		const session = makeSession();
+
+		const defaultResult = await runEvalAgent({ prompt: "hello" }, { session });
+		const overrideResult = await runEvalAgent({ prompt: "hello", agentType: "reviewer" }, { session });
+
+		expect(defaultResult.text).toBe("task");
+		expect(overrideResult.text).toBe("reviewer");
+		expect(runSpy.mock.calls[0]?.[0].agent.name).toBe("task");
+		expect(runSpy.mock.calls[1]?.[0].agent.name).toBe("reviewer");
+	});
+
+	it("throws for an unknown agent", async () => {
+		mockAgents([taskAgent]);
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+
+		await expect(runEvalAgent({ prompt: "hello", agentType: "missing" }, { session: makeSession() })).rejects.toThrow(
+			'Unknown agent "missing"',
+		);
+	});
+
+	it("enforces spawn restrictions and the eval recursion cap", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+
+		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ spawns: "" }) })).rejects.toThrow(
+			"spawns disabled",
+		);
+		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ spawns: "reviewer" }) })).rejects.toThrow(
+			"Allowed: reviewer",
+		);
+		await expect(
+			runEvalAgent({ prompt: "hello" }, { session: makeSession({ depth: EVAL_AGENT_MAX_DEPTH }) }),
+		).rejects.toThrow("maximum depth");
+		expect(runSpy).not.toHaveBeenCalled();
+	});
+
+	it("throws instead of spawning from plan mode", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+
+		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ planMode: true }) })).rejects.toThrow(
+			"unavailable in plan mode",
+		);
+		expect(runSpy).not.toHaveBeenCalled();
+	});
+
+	it("passes the parent execution context and only sets outputSchema when schema is supplied", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+		const abortController = new AbortController();
+		const schema = { type: "object", properties: { ok: { type: "boolean" } } };
+		const session = makeSession({ depth: 2, activeModel: "p/current", modelString: "p/fallback" });
+
+		await runEvalAgent(
+			{ prompt: " hello ", context: " context ", label: "My Agent", model: "p/override", schema },
+			{ session, signal: abortController.signal },
+		);
+		await runEvalAgent({ prompt: "plain" }, { session });
+
+		const firstOptions = runSpy.mock.calls[0]?.[0];
+		const secondOptions = runSpy.mock.calls[1]?.[0];
+		if (!firstOptions || !secondOptions) throw new Error("runSubprocess was not called");
+		expect(firstOptions.taskDepth).toBe(2);
+		expect(firstOptions.signal).toBe(abortController.signal);
+		expect(firstOptions.parentActiveModelPattern).toBe("p/current");
+		expect(firstOptions.outputSchema).toBe(schema);
+		expect(firstOptions.assignment).toBe("hello");
+		expect(firstOptions.context).toBe("context");
+		expect(firstOptions.description).toBe("My Agent");
+		expect(firstOptions.modelOverride).toEqual(["p/override"]);
+		expect(secondOptions.outputSchema).toBeUndefined();
+	});
+
+	it("maps successful and failed subagent results", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess");
+		runSpy.mockImplementationOnce(async options =>
+			singleResult(options, {
+				id: "0-EvalAgent",
+				output: "done",
+				resolvedModel: "p/model",
+			}),
+		);
+		runSpy.mockImplementationOnce(async options =>
+			singleResult(options, {
+				exitCode: 1,
+				output: "",
+				stderr: "stderr",
+				error: "boom",
+			}),
+		);
+
+		const result = await runEvalAgent({ prompt: "hello" }, { session: makeSession() });
+		expect(result).toEqual({
+			text: "done",
+			details: { agent: "task", id: "0-EvalAgent", model: "p/model", structured: false },
+		});
+		await expect(runEvalAgent({ prompt: "fail" }, { session: makeSession() })).rejects.toThrow("boom");
+	});
+});
+
+describe("agent() through eval runtimes", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	afterAll(async () => {
+		await disposeAllVmContexts();
+		await disposeAllKernelSessions();
+	});
+
+	it("exposes agent() in JavaScript and parses structured output", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-js-");
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent");
+		mockAgents();
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
+			singleResult(options, {
+				output: options.outputSchema ? '{"ok":true,"n":3}' : "hello from agent",
+			}),
+		);
+
+		const result = await executeJs(
+			'const text = await agent("hi"); const data = await agent("json", { schema: { type: "object" } }); return JSON.stringify([text, data]);',
+			{ cwd: tempDir.path(), sessionId, session, sessionFile },
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(JSON.parse(result.output.trim())).toEqual(["hello from agent", { ok: true, n: 3 }]);
+	});
+
+	it("runs JavaScript parallel() with bounded concurrency while preserving order", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-js-parallel-");
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-parallel");
+		mockAgents();
+		let inFlight = 0;
+		let maxInFlight = 0;
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			inFlight++;
+			maxInFlight = Math.max(maxInFlight, inFlight);
+			try {
+				await Bun.sleep(options.assignment === "a" ? 30 : 10);
+				return singleResult(options, { output: options.assignment ?? "" });
+			} finally {
+				inFlight--;
+			}
+		});
+
+		const result = await executeJs(
+			'const values = await parallel(["a", "b", "c", "d"].map(name => () => agent(name)), { concurrency: 2 }); return JSON.stringify(values);',
+			{ cwd: tempDir.path(), sessionId, session, sessionFile },
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(JSON.parse(result.output.trim())).toEqual(["a", "b", "c", "d"]);
+		expect(maxInFlight).toBeGreaterThan(1);
+		expect(maxInFlight).toBeLessThanOrEqual(2);
+	});
+
+	it("propagates JavaScript parallel() rejections", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-js-reject-");
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-reject");
+		mockAgents();
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			if (options.assignment === "bad") {
+				return singleResult(options, { exitCode: 1, output: "", stderr: "boom", error: "boom" });
+			}
+			return singleResult(options, { output: options.assignment ?? "" });
+		});
+
+		const result = await executeJs('await parallel([() => agent("ok"), () => agent("bad")], { concurrency: 2 });', {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			sessionFile,
+		});
+
+		expect(result.exitCode).toBe(1);
+		expect(result.output).toContain("boom");
+	});
+
+	it("exposes agent() in the Python runtime", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-");
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent");
+		mockAgents();
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
+			singleResult(options, { output: "hello from python" }),
+		);
+
+		const probe = await executePython('print("probe")', {
+			cwd: tempDir.path(),
+			sessionId: `${sessionId}:probe`,
+			sessionFile,
+			kernelMode: "per-call",
+		});
+		if (probe.exitCode === undefined && probe.cancelled) {
+			expect(probe.output).toBe("");
+			return;
+		}
+		expect(probe.exitCode).toBe(0);
+
+		const result = await executePython('print(agent("hi"))', {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "per-call",
+			toolSession: session,
+		});
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output.trim()).toBe("hello from python");
+	});
+
+	it("streams enriched agent progress through onStatus before the cell finishes", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-progress-");
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-progress");
+		mockAgents();
+
+		const makeProgress = (options: ExecutorOptions, overrides: Partial<AgentProgress>): AgentProgress => ({
+			index: options.index,
+			id: options.id,
+			agent: options.agent.name,
+			agentSource: options.agent.source,
+			status: "running",
+			task: options.task,
+			assignment: options.assignment,
+			description: options.description,
+			recentTools: [],
+			recentOutput: [],
+			toolCount: 0,
+			tokens: 0,
+			cost: 0,
+			durationMs: 0,
+			...overrides,
+		});
+
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			options.onProgress?.(
+				makeProgress(options, {
+					status: "running",
+					currentTool: "read",
+					currentToolArgs: "config.ts",
+					lastIntent: "Reading config",
+					toolCount: 4,
+					contextTokens: 5000,
+					contextWindow: 200000,
+					cost: 0.03,
+					durationMs: 800,
+					resolvedModel: "p/model",
+				}),
+			);
+			options.onProgress?.(
+				makeProgress(options, {
+					status: "completed",
+					toolCount: 7,
+					contextTokens: 8000,
+					contextWindow: 200000,
+					cost: 0.06,
+					durationMs: 1500,
+					resolvedModel: "p/model",
+				}),
+			);
+			return singleResult(options, { output: "done" });
+		});
+
+		const events: Array<{ op: string; [key: string]: unknown }> = [];
+		const result = await executeJs('await agent("investigate", { label: "Scout" });', {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			sessionFile,
+			onStatus: event => events.push(event),
+		});
+
+		expect(result.exitCode).toBe(0);
+
+		const agentEvents = events.filter(event => event.op === "agent");
+		// Both throttled ticks were delivered live (the cell awaited agent() and
+		// the executor collected them as displayOutputs too).
+		expect(agentEvents.length).toBe(2);
+
+		const running = agentEvents[0];
+		expect(running.status).toBe("running");
+		expect(running.currentTool).toBe("read");
+		expect(running.lastIntent).toBe("Reading config");
+		expect(running.contextTokens).toBe(5000);
+		expect(running.taskPreview).toBe("investigate");
+		expect(typeof running.id).toBe("string");
+
+		// The final completion event keeps the rich stats — no sparse event
+		// coalesces over it and drops toolCount/cost.
+		const completed = agentEvents[1];
+		expect(completed.status).toBe("completed");
+		expect(completed.toolCount).toBe(7);
+		expect(completed.cost).toBeCloseTo(0.06);
+		expect(completed.id).toBe(running.id);
+
+		// Same events are still present in the executor's returned displayOutputs.
+		const displayAgentEvents = result.displayOutputs.filter(
+			(output): output is Extract<typeof output, { type: "status" }> => output.type === "status",
+		);
+		expect(displayAgentEvents.length).toBe(2);
+	});
+});

package/src/eval/__tests__/budget-bridge.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "bun:test";
+import type { GoalModeState } from "../../goals/state";
+import type { UsageStatistics } from "../../session/session-manager";
+import type { ToolSession } from "../../tools";
+import { runEvalBudget } from "../budget-bridge";
+
+type TurnBudget = { total: number | null; spent: number; hard: boolean };
+
+function makeSession(parts: { turn?: TurnBudget; goal?: GoalModeState; usage?: UsageStatistics }): ToolSession {
+	return {
+		getTurnBudget: parts.turn ? () => parts.turn as TurnBudget : undefined,
+		getGoalModeState: parts.goal ? () => parts.goal : undefined,
+		getUsageStatistics: parts.usage ? () => parts.usage as UsageStatistics : undefined,
+	} as unknown as ToolSession;
+}
+
+function goalState(extra: Partial<GoalModeState["goal"]>): GoalModeState {
+	return {
+		enabled: true,
+		mode: "active",
+		goal: { id: "g1", status: "active", tokensUsed: 0, timeUsedSeconds: 0, ...extra },
+	} as GoalModeState;
+}
+
+function usage(output: number): UsageStatistics {
+	return { input: 0, output, cacheRead: 0, cacheWrite: 0, premiumRequests: 0, cost: 0 };
+}
+
+describe("runEvalBudget", () => {
+	it("prefers an active +Nk turn directive over Goal Mode", async () => {
+		const session = makeSession({
+			turn: { total: 200_000, spent: 5_000, hard: true },
+			goal: goalState({ tokenBudget: 100_000, tokensUsed: 4_200 }),
+		});
+		expect(await runEvalBudget({}, { session })).toEqual({ total: 200_000, spent: 5_000, hard: true });
+	});
+
+	it("reports an advisory turn budget as hard:false", async () => {
+		const session = makeSession({ turn: { total: 50_000, spent: 1_000, hard: false } });
+		expect(await runEvalBudget({}, { session })).toEqual({ total: 50_000, spent: 1_000, hard: false });
+	});
+
+	it("falls through to Goal Mode when no turn directive set a ceiling", async () => {
+		const session = makeSession({
+			turn: { total: null, spent: 7_777, hard: false },
+			goal: goalState({ tokenBudget: 100_000, tokensUsed: 4_200 }),
+		});
+		expect(await runEvalBudget({}, { session })).toEqual({ total: 100_000, spent: 4_200, hard: true });
+	});
+
+	it("treats a Goal Mode budget as hard, and a budgetless goal as no ceiling", async () => {
+		const withBudget = makeSession({ goal: goalState({ tokenBudget: 80_000, tokensUsed: 9_000 }) });
+		expect(await runEvalBudget({}, { session: withBudget })).toEqual({ total: 80_000, spent: 9_000, hard: true });
+
+		const noBudget = makeSession({ goal: goalState({ tokenBudget: undefined, tokensUsed: 1_234 }) });
+		expect(await runEvalBudget({}, { session: noBudget })).toEqual({ total: null, spent: 1_234, hard: false });
+	});
+
+	it("reports no ceiling but still surfaces spend", async () => {
+		const fromTurn = makeSession({ turn: { total: null, spent: 333, hard: false } });
+		expect(await runEvalBudget({}, { session: fromTurn })).toEqual({ total: null, spent: 333, hard: false });
+
+		const fromUsage = makeSession({ usage: usage(777) });
+		expect(await runEvalBudget({}, { session: fromUsage })).toEqual({ total: null, spent: 777, hard: false });
+
+		const empty = makeSession({});
+		expect(await runEvalBudget({}, { session: empty })).toEqual({ total: null, spent: 0, hard: false });
+	});
+});