@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

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

@@ -231,6 +231,57 @@ describe("runEvalAgent", () => {
 		});
 		await expect(runEvalAgent({ prompt: "fail" }, { session: makeSession() })).rejects.toThrow("boom");
 	});
+
+	// Regression: a runtime-limit abort returns exitCode=1, stderr="", error=undefined,
+	// aborted=true, abortReason="Subagent runtime limit exceeded (...)". The previous
+	// failure-message coalesce stopped at the empty `stderr` (since `??` only skips
+	// nullish values) and shipped an empty error through the bridge — Python then
+	// surfaced the generic `bridge call '__agent__' failed`. See #2006.
+	it("surfaces abortReason for aborts that leave stderr empty", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess");
+		runSpy.mockImplementationOnce(async options =>
+			singleResult(options, {
+				exitCode: 1,
+				output: "",
+				stderr: "",
+				error: undefined,
+				aborted: true,
+				abortReason: "Subagent runtime limit exceeded (task.maxRuntimeMs=900000)",
+			}),
+		);
+		runSpy.mockImplementationOnce(async options =>
+			singleResult(options, {
+				exitCode: 1,
+				output: "",
+				stderr: "   ",
+				error: "   ",
+				aborted: true,
+				abortReason: "Cancelled by caller",
+			}),
+		);
+		runSpy.mockImplementationOnce(async options =>
+			singleResult(options, {
+				exitCode: 1,
+				output: "",
+				stderr: "",
+				error: undefined,
+			}),
+		);
+
+		await expect(runEvalAgent({ prompt: "slow" }, { session: makeSession() })).rejects.toThrow(
+			"Subagent runtime limit exceeded (task.maxRuntimeMs=900000)",
+		);
+		// Whitespace-only stderr/error must not mask abortReason either.
+		await expect(runEvalAgent({ prompt: "cancelled" }, { session: makeSession() })).rejects.toThrow(
+			"Cancelled by caller",
+		);
+		// Last resort: still produce a non-empty message even when nothing useful is set,
+		// so Python never falls back to `bridge call '__agent__' failed`.
+		await expect(runEvalAgent({ prompt: "blank" }, { session: makeSession() })).rejects.toThrow(
+			"agent() subagent 'task' failed.",
+		);
+	});
 });
 
 describe("agent() through eval runtimes", () => {
@@ -326,18 +377,6 @@ describe("agent() through eval runtimes", () => {
 			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,
@@ -345,6 +384,10 @@ describe("agent() through eval runtimes", () => {
 			kernelMode: "per-call",
 			toolSession: session,
 		});
+		if (result.exitCode === undefined && result.cancelled) {
+			expect(result.output).toBe("");
+			return; // kernel unavailable in this environment
+		}
 
 		expect(result.exitCode).toBe(0);
 		expect(result.output.trim()).toBe("hello from python");
@@ -373,22 +416,14 @@ describe("agent() through eval runtimes", () => {
 			}
 		});
 
-		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(
 			'import json\nprint(json.dumps(parallel([lambda n=n: agent(n) for n in ["a", "b", "c", "d"]])))',
 			{ cwd: tempDir.path(), sessionId, sessionFile, kernelMode: "per-call", toolSession: session },
 		);
+		if (result.exitCode === undefined && result.cancelled) {
+			expect(result.output).toBe("");
+			return; // kernel unavailable in this environment
+		}
 
 		expect(result.exitCode).toBe(0);
 		expect(JSON.parse(result.output.trim())).toEqual(["a", "b", "c", "d"]);
@@ -412,7 +447,14 @@ describe("agent() through eval runtimes", () => {
 		// The host must respond the instant the cell aborts so the kernel can
 		// unwind via KeyboardInterrupt instead of being hard-killed (which used to
 		// surface "[kernel] Python kernel shutdown" and lose all session state).
+		let inFlight = 0;
+		let markSaturated: (() => void) | undefined;
+		const saturated = new Promise<void>(resolve => {
+			markSaturated = resolve;
+		});
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			// task.maxConcurrency=6 → six bridge calls block at once; signal then.
+			if (++inFlight >= 6) markSaturated?.();
 			await Bun.sleep(9000); // deliberately ignores options.signal
 			return singleResult(options, { output: options.assignment ?? "" });
 		});
@@ -432,8 +474,9 @@ describe("agent() through eval runtimes", () => {
 		expect(seed.exitCode).toBe(0);
 
 		const ac = new AbortController();
-		// Abort ~1s in, after the worker threads are blocked in their bridge calls.
-		setTimeout(() => ac.abort(new Error("external interrupt")), 1000);
+		// Abort the instant all six worker threads are confirmed blocked in their
+		// bridge calls (condition-driven) instead of waiting a fixed wall second.
+		void saturated.then(() => ac.abort(new Error("external interrupt")));
 
 		const start = Date.now();
 		const result = await executePython(
@@ -568,12 +611,12 @@ describe("agent() through eval runtimes", () => {
 		// of its own. The bridge pause must make that delegated time invisible to
 		// the watchdog.
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
-			await Bun.sleep(200);
+			await Bun.sleep(40);
 			return singleResult(options, { output: "done" });
 		});
 
 		const ops: string[] = [];
-		using idle = new IdleTimeout(60);
+		using idle = new IdleTimeout(20);
 		const result = await runEvalAgent(
 			{ prompt: "investigate" },
 			{
@@ -591,7 +634,7 @@ describe("agent() through eval runtimes", () => {
 		expect(ops).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP]);
 		expect(idle.signal.aborted).toBe(false);
 
-		await Bun.sleep(90);
+		await Bun.sleep(60);
 		expect(idle.signal.aborted).toBe(true);
 	});
 
@@ -604,7 +647,7 @@ describe("agent() through eval runtimes", () => {
 		// They render as status, but timeout accounting is controlled only by the
 		// bridge pause/resume events.
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
-			for (let i = 0; i < 40; i++) {
+			for (let i = 0; i < 20; i++) {
 				options.onProgress?.({
 					index: options.index,
 					id: options.id,
@@ -621,13 +664,13 @@ describe("agent() through eval runtimes", () => {
 					cost: 0,
 					durationMs: i * 10,
 				});
-				await Bun.sleep(10);
+				await Bun.sleep(5);
 			}
 			return singleResult(options, { output: "done" });
 		});
 
 		const ops: string[] = [];
-		using idle = new IdleTimeout(80);
+		using idle = new IdleTimeout(40);
 		const result = await runEvalAgent(
 			{ prompt: "investigate" },
 			{

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

@@ -4,6 +4,7 @@ import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import * as ai from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { TempDir } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
@@ -13,7 +14,7 @@ import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 import { runEvalLlm } from "../llm-bridge";
-import { disposeAllKernelSessions, executePython } from "../py/executor";
+import { disposeAllKernelSessions, type PythonResult } from "../py/executor";
 
 function makeModel(provider: string, id: string, extra: Partial<Model<Api>> = {}): Model<Api> {
 	return {
@@ -57,6 +58,7 @@ function makeSession(opts: SessionOptions = {}): ToolSession {
 	const modelRegistry = {
 		getAvailable: () => opts.available ?? [SMOL, DEFAULT, SLOW],
 		getApiKey: async () => (opts.apiKey === undefined ? "test-key" : opts.apiKey),
+		resolver: () => async () => (opts.apiKey === undefined ? "test-key" : opts.apiKey),
 	} as unknown as ModelRegistry;
 	return {
 		settings,
@@ -96,6 +98,77 @@ function assistant(opts: {
 	};
 }
 
+async function runPythonLlmInSubprocess(options: { structured: boolean; tempDir: TempDir }): Promise<PythonResult> {
+	const repoRoot = path.resolve(import.meta.dir, "../../../..");
+	const scriptPath = path.join(options.tempDir.path(), "run-python-llm.ts");
+	const resultPath = path.join(options.tempDir.path(), "python-llm-result.json");
+	const aiPath = path.resolve(import.meta.dir, "../../../../ai/src/index.ts");
+	const executorPath = path.resolve(import.meta.dir, "../py/executor.ts");
+	const settingsPath = path.resolve(import.meta.dir, "../../config/settings.ts");
+	const code = options.structured
+		? 'import json\nprint(json.dumps(llm("hi", schema={"type": "object"})))'
+		: 'print(llm("hi", model="smol"))';
+	const responseContent = options.structured
+		? '[{ type: "toolCall", id: "tc-1", name: "respond", arguments: { ok: true } }]'
+		: '[{ type: "text", text: "hello from python" }]';
+	await Bun.write(
+		scriptPath,
+		`
+import { vi } from "bun:test";
+import * as ai from ${JSON.stringify(aiPath)};
+import { executePython } from ${JSON.stringify(executorPath)};
+import { Settings } from ${JSON.stringify(settingsPath)};
+
+const SMOL = {
+	id: "smol",
+	name: "smol",
+	api: "openai-responses",
+	provider: "p",
+	baseUrl: "https://example.test/v1",
+	reasoning: false,
+	input: ["text"],
+	cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 1 },
+	contextWindow: 128000,
+	maxTokens: 4096,
+};
+const settings = Settings.isolated({ "async.enabled": false, "task.isolation.mode": "none" });
+settings.setModelRole("smol", "p/smol");
+settings.setModelRole("slow", "p/slow");
+const session = {
+	settings,
+	modelRegistry: {
+		getAvailable: () => [SMOL],
+		getApiKey: async () => "test-key",
+		resolver: () => async () => "test-key",
+	},
+	getActiveModelString: () => "p/smol",
+};
+vi.spyOn(ai, "completeSimple").mockResolvedValue({
+	role: "assistant",
+	api: "openai-responses",
+	provider: "p",
+	model: "smol",
+	stopReason: "stop",
+	content: ${responseContent},
+});
+const result = await executePython(${JSON.stringify(code)}, {
+	cwd: ${JSON.stringify(options.tempDir.path())},
+	sessionId: ${JSON.stringify(`py-llm:${options.structured ? "struct" : "plain"}`)},
+	sessionFile: ${JSON.stringify(path.join(options.tempDir.path(), "session.jsonl"))},
+	toolSession: session,
+	kernelMode: "per-call",
+});
+await Bun.write(${JSON.stringify(resultPath)}, JSON.stringify(result));
+process.exit(0);
+`,
+	);
+	const child = await $`bun ${scriptPath}`.cwd(repoRoot).quiet().nothrow();
+	const stdout = child.stdout.toString();
+	const stderr = child.stderr.toString();
+	if (child.exitCode !== 0) throw new Error(stderr || stdout || `Python llm subprocess exited with ${child.exitCode}`);
+	return (await Bun.file(resultPath).json()) as PythonResult;
+}
+
 describe("runEvalLlm", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
@@ -290,38 +363,24 @@ describe("llm() through eval runtimes", () => {
 	});
 
 	it("exposes llm() in the Python runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-py-");
-		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `py-llm:${crypto.randomUUID()}`;
-		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "hello from python" }));
-
-		const result = await executePython('print(llm("hi", model="smol"))', {
-			cwd: tempDir.path(),
-			sessionId,
-			sessionFile,
-			toolSession: makeSession(),
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.output.trim()).toBe("hello from python");
+		const tempDir = TempDir.createSync("@omp-eval-llm-py-");
+		try {
+			const result = await runPythonLlmInSubprocess({ structured: false, tempDir });
+			expect(result.exitCode).toBe(0);
+			expect(result.output.trim()).toBe("hello from python");
+		} finally {
+			tempDir.removeSync();
+		}
 	});
 
 	it("parses structured llm() output in the Python runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-py-struct-");
-		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `py-llm-struct:${crypto.randomUUID()}`;
-		vi.spyOn(ai, "completeSimple").mockResolvedValue(
-			assistant({ toolCall: { name: "respond", arguments: { ok: true } } }),
-		);
-
-		const result = await executePython('import json\nprint(json.dumps(llm("hi", schema={"type": "object"})))', {
-			cwd: tempDir.path(),
-			sessionId,
-			sessionFile,
-			toolSession: makeSession(),
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(JSON.parse(result.output.trim())).toEqual({ ok: true });
+		const tempDir = TempDir.createSync("@omp-eval-llm-py-struct-");
+		try {
+			const result = await runPythonLlmInSubprocess({ structured: true, tempDir });
+			expect(result.exitCode).toBe(0);
+			expect(JSON.parse(result.output.trim())).toEqual({ ok: true });
+		} finally {
+			tempDir.removeSync();
+		}
 	});
 });

package/src/eval/agent-bridge.ts

@@ -13,7 +13,7 @@ import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.m
 import * as taskDiscovery from "../task/discovery";
 import * as taskExecutor from "../task/executor";
 import { AgentOutputManager } from "../task/output-manager";
-import type { AgentDefinition, AgentProgress } from "../task/types";
+import type { AgentDefinition, AgentProgress, SingleResult } from "../task/types";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
 import { withBridgeTimeoutPause } from "./bridge-timeout";
@@ -173,6 +173,26 @@ function emitProgressStatus(emitStatus: ((event: JsStatusEvent) => void) | undef
 	});
 }
 
+/**
+ * Coalesce a subagent failure into a non-empty, human-meaningful error message.
+ *
+ * When the executor aborts a subagent (runtime limit, parent cancellation, …)
+ * the actionable explanation lives on `abortReason`, while `error`/`stderr`
+ * are routinely empty strings. Plain `??` coalescing stops at the empty string
+ * and ships an empty error through the bridge — Python then surfaces only the
+ * generic `bridge call '__agent__' failed`. See #2006.
+ */
+function buildSubagentFailureMessage(agentName: string, result: SingleResult): string {
+	const abortReason = trimToUndefined(result.abortReason);
+	if (result.aborted && abortReason) return abortReason;
+	return (
+		trimToUndefined(result.error) ??
+		trimToUndefined(result.stderr) ??
+		abortReason ??
+		`agent() subagent '${agentName}' failed.`
+	);
+}
+
 /**
  * Run a single subagent on behalf of an eval cell's `agent()` call.
  */
@@ -225,7 +245,6 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		getSessionId: options.session.getSessionId ?? (() => null),
 	};
 	const parentArtifactManager = options.session.getArtifactManager?.() ?? undefined;
-	const parentEvalSessionId = options.session.getEvalSessionId?.() ?? undefined;
 	const mcpManager = options.session.mcpManager ?? MCPManager.instance();
 	const { sessionFile, artifactsDir, contextFile } = await getArtifacts(options.session);
 	const outputManager = getOutputManager(options.session);
@@ -260,6 +279,12 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			authStorage: options.session.authStorage,
 			modelRegistry: options.session.modelRegistry,
 			settings: options.session.settings,
+			// Eval `agent()` subagents are never wall-clock capped: the parent
+			// cell's idle watchdog is suspended for the whole bridge call
+			// (withBridgeTimeoutPause), so a long-running phase/recovery workflow
+			// must not be killed by `task.maxRuntimeMs`. Force the limit off
+			// regardless of the inherited session setting.
+			maxRuntimeMs: 0,
 			mcpManager,
 			contextFiles,
 			skills: availableSkills,
@@ -271,14 +296,16 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			parentHindsightSessionState: options.session.getHindsightSessionState?.(),
 			parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
 			parentTelemetry: options.session.getTelemetry?.(),
-			parentEvalSessionId,
+			// Deliberately omit parentEvalSessionId: the parent's Python kernel is
+			// blocked on this bridge call, so sharing the eval session would deadlock
+			// (subagent queues behind the parent's in-flight execution, parent waits
+			// for subagent → circular). Each bridge-spawned subagent gets its own
+			// eval session with an independent kernel.
 		}),
 	);
 
-	if (result.exitCode !== 0 || result.error) {
-		const failureMessage =
-			result.error ?? result.stderr ?? result.abortReason ?? `agent() subagent '${agentName}' failed.`;
-		throw new ToolError(failureMessage);
+	if (result.exitCode !== 0 || result.error || result.aborted) {
+		throw new ToolError(buildSubagentFailureMessage(agentName, result));
 	}
 
 	options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);

package/src/eval/llm-bridge.ts

@@ -15,6 +15,7 @@ import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent
 import { type Api, Effort, getSupportedEfforts, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import * as z from "zod/v4";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
+
 import { expandRoleAlias, formatModelString, resolveModelFromString } from "../config/model-resolver";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
@@ -112,8 +113,9 @@ export async function runEvalLlm(args: unknown, options: EvalLlmBridgeOptions):
 		);
 	}
 
-	const apiKey = await options.session.modelRegistry?.getApiKey(model);
-	if (!apiKey) {
+	const registry = options.session.modelRegistry;
+	const apiKey = await registry?.getApiKey(model);
+	if (!registry || !apiKey) {
 		throw new ToolError(
 			`llm() has no API key for ${formatModelString(model)}. Configure credentials for this provider or choose another tier.`,
 		);
@@ -143,7 +145,10 @@ export async function runEvalLlm(args: unknown, options: EvalLlmBridgeOptions):
 				tools,
 			},
 			{
-				apiKey,
+				apiKey: registry.resolver(model.provider, {
+					sessionId: options.session.getSessionId?.() ?? undefined,
+					baseUrl: model.baseUrl,
+				}),
 				signal: options.signal,
 				reasoning: reasoningForTier(tier, model),
 				toolChoice: schema ? { type: "tool", name: STRUCTURED_TOOL_NAME } : undefined,

package/src/extensibility/extensions/runner.ts

@@ -354,6 +354,7 @@ export class ExtensionRunner {
 		"ctrl+o": true,
 		"ctrl+t": true,
 		"ctrl+g": true,
+		"alt+m": true,
 		// Default chord for `app.message.followUp` (Windows Terminal can't deliver Ctrl+Enter; #1903).
 		"ctrl+q": true,
 		"shift+tab": true,

package/src/extensibility/plugins/doctor.ts

@@ -25,7 +25,6 @@ export async function runDoctorChecks(): Promise<DoctorCheck[]> {
 	const apiKeys = [
 		{ name: "ANTHROPIC_API_KEY", description: "Anthropic API" },
 		{ name: "OPENAI_API_KEY", description: "OpenAI API" },
-		{ name: "PERPLEXITY_API_KEY", description: "Perplexity search" },
 		{ name: "EXA_API_KEY", description: "Exa search" },
 	];
 

package/src/extensibility/plugins/marketplace-auto-update.ts

@@ -0,0 +1,49 @@
+import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+
+type MarketplaceAutoUpdateMode = "off" | "notify" | "auto";
+
+interface MarketplaceAutoUpdateOptions {
+	autoUpdate: MarketplaceAutoUpdateMode;
+	resolveActiveProjectRegistryPath: (cwd: string) => Promise<string | null>;
+	clearPluginRootsCache: () => void;
+}
+
+export function scheduleMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): void {
+	if (options.autoUpdate === "off") {
+		return;
+	}
+
+	void runMarketplaceAutoUpdate(options);
+}
+
+async function runMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): Promise<void> {
+	try {
+		// Startup perf: marketplace manager pulls scraper/fetch/cache code; keep it out of the initial TUI graph.
+		const {
+			MarketplaceManager,
+			getInstalledPluginsRegistryPath,
+			getMarketplacesCacheDir,
+			getMarketplacesRegistryPath,
+			getPluginsCacheDir,
+		} = await import("./marketplace");
+		const mgr = new MarketplaceManager({
+			marketplacesRegistryPath: getMarketplacesRegistryPath(),
+			installedRegistryPath: getInstalledPluginsRegistryPath(),
+			projectInstalledRegistryPath: (await options.resolveActiveProjectRegistryPath(getProjectDir())) ?? undefined,
+			marketplacesCacheDir: getMarketplacesCacheDir(),
+			pluginsCacheDir: getPluginsCacheDir(),
+			clearPluginRootsCache: options.clearPluginRootsCache,
+		});
+		await mgr.refreshStaleMarketplaces();
+		const updates = await mgr.checkForUpdates();
+		if (updates.length === 0) return;
+		if (options.autoUpdate === "auto") {
+			await mgr.upgradeAllPlugins();
+			logger.debug(`Auto-upgraded ${updates.length} marketplace plugin(s)`);
+		} else {
+			logger.debug(`${updates.length} marketplace plugin update(s) available — /marketplace upgrade`);
+		}
+	} catch {
+		// Silently ignore — network failure, corrupt data, offline.
+	}
+}

package/src/goals/tools/goal-tool.ts

@@ -8,9 +8,9 @@ import type { Theme, ThemeColor } from "../../modes/theme/theme";
 import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
 import { formatDuration } from "../../slash-commands/helpers/format";
 import type { ToolSession } from "../../tools";
-import { formatErrorMessage, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+import { formatErrorDetail, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { ToolError } from "../../tools/tool-errors";
-import { renderStatusLine, truncateToWidth } from "../../tui";
+import { framedBlock, renderStatusLine, truncateToWidth } from "../../tui";
 import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
@@ -173,8 +173,7 @@ export const goalToolRenderer = {
 		if (args.op === "create" && args.token_budget !== undefined) {
 			meta.push(`budget ${formatNumber(args.token_budget)}`);
 		}
-		const text = renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme);
-		return new Text(text, 0, 0);
+		return new Text(renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme), 0, 0);
 	},
 
 	renderResult(
@@ -190,51 +189,62 @@ export const goalToolRenderer = {
 
 		if (result.isError) {
 			const header = renderStatusLine({ icon: "error", title: "Goal", description }, uiTheme);
-			const body = formatErrorMessage(fallbackText || "Goal tool failed", uiTheme);
-			return new Text([header, body].join("\n"), 0, 0);
+			return framedBlock(uiTheme, width => ({
+				header,
+				sections: [{ lines: formatErrorDetail(fallbackText || "Goal tool failed", uiTheme).split("\n") }],
+				state: "error",
+				borderColor: "error",
+				width,
+			}));
 		}
 
 		const goal = details?.goal ?? null;
 		if (!goal) {
-			const header = renderStatusLine({ icon: "warning", title: "Goal", description }, uiTheme);
-			const body = uiTheme.fg("muted", "No active goal.");
-			return new Text([header, body].join("\n"), 0, 0);
+			return new Text(
+				renderStatusLine({ icon: "warning", title: "Goal", description, meta: ["no active goal"] }, uiTheme),
+				0,
+				0,
+			);
 		}
 
-		const lines: string[] = [];
-		lines.push(
-			renderStatusLine(
-				{
-					icon: "success",
-					title: "Goal",
-					description,
-					badge: { label: goal.status, color: goalBadgeColor(goal.status) },
-				},
-				uiTheme,
-			),
+		const header = renderStatusLine(
+			{
+				icon: "success",
+				title: "Goal",
+				description,
+				badge: { label: goal.status, color: goalBadgeColor(goal.status) },
+			},
+			uiTheme,
 		);
 
+		const lines: string[] = [];
 		const objectiveText = truncateToWidth(goal.objective.trim(), TRUNCATE_LENGTHS.LONG);
-		lines.push(`  ${uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`))}`);
+		lines.push(uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`)));
 
 		const used = formatNumber(goal.tokensUsed);
 		const tokensLine =
 			goal.tokenBudget !== undefined
 				? `${used} / ${formatNumber(goal.tokenBudget)} tokens (${formatNumber(Math.max(0, goal.tokenBudget - goal.tokensUsed))} left)`
 				: `${used} tokens`;
-		lines.push(`  ${uiTheme.fg("dim", tokensLine)}`);
-
+		const metaParts = [tokensLine];
 		if (goal.timeUsedSeconds > 0) {
-			lines.push(`  ${uiTheme.fg("dim", `${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`)}`);
+			metaParts.push(`${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`);
 		}
+		lines.push(uiTheme.fg("dim", metaParts.join(" · ")));
 
 		const report = details?.completionBudgetReport;
+		const sections: Array<{ label?: string; lines: string[] }> = [{ lines }];
 		if (report) {
-			lines.push("");
-			lines.push(uiTheme.italic(uiTheme.fg("muted", report)));
+			sections.push({ label: "Report", lines: report.split("\n").map(line => uiTheme.fg("muted", line)) });
 		}
 
-		return new Text(lines.join("\n"), 0, 0);
+		return framedBlock(uiTheme, width => ({
+			header,
+			sections,
+			state: "success",
+			borderColor: "borderMuted",
+			width,
+		}));
 	},
 
 	mergeCallAndResult: true,