@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/tools/render-mermaid.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import { type MermaidAsciiRenderOptions, prompt, renderMermaidAscii } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import renderMermaidDescription from "../prompts/tools/render-mermaid.md" with { type: "text" };
 import type { ToolSession } from "./index";
 

package/src/tools/render-utils.ts

@@ -10,8 +10,9 @@ import * as path from "node:path";
 import type { ToolCallContext } from "@prometheus-ai/agent-core";
 import type { Ellipsis } from "@prometheus-ai/natives";
 import type { Component } from "@prometheus-ai/tui";
-import { replaceTabs, truncateToWidth } from "@prometheus-ai/tui";
+import { getKeybindings, replaceTabs, truncateToWidth } from "@prometheus-ai/tui";
 import { pluralize } from "@prometheus-ai/utils";
+import { formatKeyHints, type KeyId } from "../config/keybindings";
 import { settings } from "../config/settings";
 import type { Theme } from "../modes/theme/theme";
 import { Hasher } from "../tui/utils";
@@ -75,8 +76,16 @@ export const TRUNCATE_LENGTHS = {
 	SHORT: 40,
 } as const;
 
-/** Standard expand hint text */
-export const EXPAND_HINT = "(Ctrl+O for more)";
+/** Keybinding action that toggles tool-output expansion. */
+const EXPAND_ACTION = "app.tools.expand";
+/** Fallback key when no binding is resolvable (e.g. outside an interactive session). */
+const DEFAULT_EXPAND_KEY: KeyId = "ctrl+o";
+
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export function expandKeyHint(): string {
+	const keys = getKeybindings().getKeys(EXPAND_ACTION);
+	return formatKeyHints(keys.length > 0 ? keys : [DEFAULT_EXPAND_KEY]);
+}
 
 // =============================================================================
 // Text Truncation Utilities
@@ -124,6 +133,8 @@ export function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFram
 	switch (status) {
 		case "success":
 			return theme.styledSymbol("status.success", "success");
+		case "done":
+			return theme.styledSymbol("status.done", "success");
 		case "error":
 			return theme.styledSymbol("status.error", "error");
 		case "warning":
@@ -150,7 +161,7 @@ export function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFram
 export function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string {
 	if (expanded) return "";
 	if (hasMore === false) return "";
-	return theme.fg("dim", wrapBrackets(EXPAND_HINT, theme));
+	return theme.fg("dim", wrapBrackets(`${expandKeyHint()}: Expand`, theme));
 }
 
 /**
@@ -172,24 +183,32 @@ export function formatMoreItems(remaining: number, itemType: string): string {
 }
 
 /**
- * Maximum rows a tool's streaming/pending *call* preview may render before it is
- * capped. This is intentionally conservative: the preview still sits inside a
- * transcript that already consumed some viewport rows, and tool blocks carry
- * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
- * or command preview like 10-12 lines can still overflow and strand its top
- * while the block is volatile. Keeping the live call window short avoids that
- * across terminals without turning the transcript into an interactive scroller.
+ * Collapsed command/code previews render a tail window sized from the live
+ * viewport: terminal rows minus a reserve for the rest of the block (frame,
+ * Output section, stats line) and the editor/status area below the
+ * transcript. This keeps a volatile streaming block from growing past the
+ * viewport and stranding its top, while letting tall terminals show more.
  */
-export const CALL_PREVIEW_MAX_LINES = 6;
+const PREVIEW_WINDOW_RESERVED_ROWS = 20;
+/** Floor so tiny or unknown viewports still show a useful window. */
+const PREVIEW_WINDOW_MIN_LINES = 6;
+/** Assumed viewport when rows are unknown (non-TTY, tests). */
+const PREVIEW_WINDOW_FALLBACK_ROWS = 30;
+
+/** Tail-window height for collapsed command/code previews. */
+export function previewWindowRows(): number {
+	const rows = process.stdout.rows || PREVIEW_WINDOW_FALLBACK_ROWS;
+	return Math.max(PREVIEW_WINDOW_MIN_LINES, rows - PREVIEW_WINDOW_RESERVED_ROWS);
+}
 
 /**
- * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
- * show both the head and the live tail so the user can still see what the tool
- * is currently writing while the volatile block stays short enough not to strand
- * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
- * fully uncap live tool previews for the same reason.
+ * Cap a pre-rendered command preview to a viewport-sized tail window: the end
+ * of the command stays visible (it is the live edge while args stream) behind
+ * an "… N earlier lines" marker on top. The same window applies while
+ * streaming and after completion so the block never jumps; only `expanded`
+ * (ctrl+o) uncaps it.
  *
- * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
  * nested previews stay aligned.
  */
 export function capPreviewLines(
@@ -197,34 +216,38 @@ export function capPreviewLines(
 	theme: Theme,
 	options: { max?: number; expanded?: boolean; prefix?: string } = {},
 ): string[] {
-	const max = options.max ?? (options.expanded ? PREVIEW_LIMITS.EXPANDED_LINES : CALL_PREVIEW_MAX_LINES);
+	if (options.expanded) return lines;
+	const max = options.max ?? previewWindowRows();
 	if (lines.length <= max) return lines;
-	if (max <= 1) {
-		const hint = formatExpandHint(theme, options.expanded, true);
-		const moreLine = `${formatMoreItems(lines.length, "line")}${hint ? ` ${hint}` : ""}`;
-		return [`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`];
-	}
-	const bodyBudget = max - 1; // reserve one summary row
-	const headCount = Math.max(1, Math.ceil(bodyBudget / 2));
-	const tailCount = Math.max(1, bodyBudget - headCount);
-	const hidden = Math.max(0, lines.length - headCount - tailCount);
-	const hint = formatExpandHint(theme, options.expanded, true);
-	const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
-	return [
-		...lines.slice(0, headCount),
-		`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`,
-		...lines.slice(lines.length - tailCount),
-	];
+	const visible = max <= 1 ? [] : lines.slice(lines.length - (max - 1));
+	const hidden = lines.length - visible.length;
+	const hint = formatExpandHint(theme, false, true);
+	const marker = `… ${hidden} earlier ${pluralize("line", hidden)}${hint ? ` ${hint}` : ""}`;
+	return [`${options.prefix ?? ""}${theme.fg("dim", marker)}`, ...visible];
 }
 
 export function formatMeta(meta: string[], theme: Theme): string {
 	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
 }
 
-export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+function sanitizeErrorText(message: string | undefined): string {
 	const clean = (message ?? "").replace(/^Error:\s*/, "").trim();
-	const safe = clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
-	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${safe}`)}`;
+	return clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
+}
+
+export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${sanitizeErrorText(message)}`)}`;
+}
+
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export function formatErrorDetail(message: string | undefined, theme: Theme): string {
+	return `  ${theme.fg("error", sanitizeErrorText(message))}`;
 }
 
 export function formatEmptyMessage(message: string, theme: Theme): string {
@@ -253,7 +276,7 @@ export function formatCodeFrameLine(
 // Tool UI Helpers
 // =============================================================================
 
-export type ToolUIStatus = "success" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIStatus = "success" | "done" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
 export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
 
 export interface ToolUITitleOptions {
@@ -315,6 +338,7 @@ export function formatDiagnostics(
 	expanded: boolean,
 	theme: Theme,
 	getLangIcon: (filePath: string) => string,
+	options?: { title?: string },
 ): string {
 	if (diag.messages.length === 0) return "";
 
@@ -346,7 +370,8 @@ export function formatDiagnostics(
 		? theme.styledSymbol("status.error", "error")
 		: theme.styledSymbol("status.warning", "warning");
 	const summary = sanitizeDiagnosticDisplayText(diag.summary);
-	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${summary})`)}`;
+	const summaryTag = summary ? ` ${theme.fg("dim", `(${summary})`)}` : "";
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", options?.title ?? "Diagnostics")}${summaryTag}`;
 
 	const maxDiags = expanded ? diag.messages.length : 5;
 	let diagsShown = 0;
@@ -494,7 +519,7 @@ function parseDiffSegments(lines: string[]): DiffSegment[] {
 
 	for (const line of lines) {
 		const isChange = line.startsWith("+") || line.startsWith("-");
-		const isEllipsis = line.trimStart().startsWith("...");
+		const isEllipsis = line.trimStart().startsWith("...") || line.trim().length === 0;
 
 		if (isEllipsis) {
 			if (current) segments.push(current);
@@ -601,7 +626,7 @@ export function truncateDiffByHunk(
 					const half = Math.ceil(allowedLines / 2);
 					if (seg.lines.length > allowedLines) {
 						kept.push(...seg.lines.slice(0, half));
-						kept.push(seg.lines[0].replace(/^(\s*\d*\s*).*/, "$1..."));
+						kept.push("");
 						kept.push(...seg.lines.slice(-half));
 					} else {
 						kept.push(...seg.lines);
@@ -722,36 +747,6 @@ export function capParseErrors(
 // Renderer helpers shared by search / find / ast tools
 // =============================================================================
 
-/**
- * Group `rawLines` by blank-line separators, mirroring the historical search /
- * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
- * runs of blank lines; otherwise collapses non-empty lines into a single group.
- */
-export function splitGroupsByBlankLine(rawLines: string[]): string[][] {
-	const hasSeparators = rawLines.some(line => line.trim().length === 0);
-	const groups: string[][] = [];
-	if (hasSeparators) {
-		let current: string[] = [];
-		for (const line of rawLines) {
-			if (line.trim().length === 0) {
-				if (current.length > 0) {
-					groups.push(current);
-					current = [];
-				}
-				continue;
-			}
-			current.push(line);
-		}
-		if (current.length > 0) groups.push(current);
-	} else {
-		const nonEmpty = rawLines.filter(line => line.trim().length > 0);
-		if (nonEmpty.length > 0) {
-			groups.push(nonEmpty);
-		}
-	}
-	return groups;
-}
-
 /**
  * Standard width+expand keyed render cache used by every search-style tool
  * renderer. `compute` re-runs only when the cache key changes; the returned
@@ -760,16 +755,21 @@ export function splitGroupsByBlankLine(rawLines: string[]): string[][] {
 export function createCachedComponent(
 	getExpanded: () => boolean,
 	compute: (width: number, expanded: boolean) => string[],
+	options: { paddingX?: number } = {},
 ): Component {
 	let cached: { key: bigint; lines: string[] } | undefined;
 	return {
-		render(width: number): string[] {
+		render(width: number): readonly string[] {
 			const expanded = getExpanded();
 			const key = new Hasher().bool(expanded).u32(width).digest();
 			if (cached?.key === key) return cached.lines;
-			const lines = compute(width, expanded);
-			cached = { key, lines };
-			return lines;
+			const paddingX = Math.max(0, options.paddingX ?? 0);
+			const innerWidth = Math.max(1, width - paddingX * 2);
+			const lines = compute(innerWidth, expanded);
+			const pad = paddingX === 0 ? "" : " ".repeat(paddingX);
+			const paddedLines = paddingX === 0 ? lines : lines.map(line => `${pad}${line}${pad}`);
+			cached = { key, lines: paddedLines };
+			return paddedLines;
 		},
 		invalidate() {
 			cached = undefined;
@@ -777,6 +777,62 @@ export function createCachedComponent(
 	};
 }
 
+/**
+ * Single-slot memo for an expensive rendered string (syntax highlighting, diff
+ * coloring) keyed by the exact inputs that shape the bytes: theme instance,
+ * expanded state, a caller-chosen salt (path/language), and the source content.
+ * Field-wise comparison instead of a concatenated key string: a cache hit costs
+ * one string value-compare (engines short-circuit on length) and a miss never
+ * allocates a key. Comparing the {@link Theme} by reference is sound because
+ * theme switches replace the instance wholesale (`setTheme`/`previewTheme`/
+ * `setSymbolPreset` in modes/theme/theme.ts) — themes are never mutated in
+ * place.
+ */
+export interface RenderedStringCache {
+	theme: Theme | null;
+	expanded: boolean;
+	salt: string;
+	content: string;
+	value: string;
+}
+
+export function createRenderedStringCache(): RenderedStringCache {
+	return { theme: null, expanded: false, salt: "", content: "", value: "" };
+}
+
+/** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
+export function invalidateRenderedStringCache(cache: RenderedStringCache): void {
+	cache.theme = null;
+}
+
+export function cachedRenderedString(
+	cache: RenderedStringCache | undefined,
+	theme: Theme,
+	expanded: boolean,
+	salt: string,
+	content: string,
+	render: () => string,
+): string {
+	if (
+		cache !== undefined &&
+		cache.theme === theme &&
+		cache.expanded === expanded &&
+		cache.salt === salt &&
+		cache.content === content
+	) {
+		return cache.value;
+	}
+	const value = render();
+	if (cache !== undefined) {
+		cache.theme = theme;
+		cache.expanded = expanded;
+		cache.salt = salt;
+		cache.content = content;
+		cache.value = value;
+	}
+	return value;
+}
+
 /**
  * Append the indented bullet list of parse errors (capped at
  * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the

package/src/tools/renderers.ts

@@ -21,6 +21,7 @@ import { evalToolRenderer } from "./eval-render";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
+import { ircToolRenderer } from "./irc";
 import { jobToolRenderer } from "./job";
 import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory-render";
 import { readToolRenderer } from "./read";
@@ -31,7 +32,7 @@ import { sshToolRenderer } from "./ssh";
 import { todoToolRenderer } from "./todo";
 import { writeToolRenderer } from "./write";
 
-type ToolRenderer = {
+export type ToolRenderer = {
 	renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
 	renderResult: (
 		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
@@ -42,6 +43,15 @@ type ToolRenderer = {
 	mergeCallAndResult?: boolean;
 	/** Render without background box, inline in the response flow */
 	inline?: boolean;
+	/**
+	 * Whether pending-call rows are provisional: useful on screen while a tool is
+	 * streaming, but not durable transcript history. `true` means every pending
+	 * shape is provisional. `"collapsed"` means only the collapsed pending shape
+	 * is provisional; expanded rendering is top-anchored/append-shaped enough to
+	 * let the transcript commit its settled prefix. Absent = the pending preview
+	 * streams rows the result render preserves.
+	 */
+	provisionalPendingPreview?: boolean | "collapsed";
 };
 
 export const toolRenderers: Record<string, ToolRenderer> = {
@@ -58,6 +68,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	search: searchToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	inspect_image: inspectImageToolRenderer as ToolRenderer,
+	irc: ircToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
 	job: jobToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,

package/src/tools/report-tool-issue.ts

@@ -13,17 +13,19 @@
  * (including from subagents) read the cached decision without prompting.
  *
  * When the user grants consent, push is automatically active against the
- * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.prometheus.trivlab.com`). Each
+ * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.prometheus.sh`). Each
  * insert schedules a background flush that POSTs pending rows and deletes
  * them on HTTP 2xx. `PROMETHEUS_AUTO_QA_PUSH=1` forces push in non-interactive
  * environments where the consent dialog never fires. Tool execution is
  * never blocked on the network and never throws.
  */
+
 import { Database } from "bun:sqlite";
 import path from "node:path";
 import type { AgentTool } from "@prometheus-ai/agent-core";
-import { $env, $flag, APP_NAME, getAgentDir, getInstallId, logger, VERSION } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import type { FetchImpl } from "@prometheus-ai/ai";
+import { $env, $flag, getAgentDir, getInstallId, logger, VERSION } from "@prometheus-ai/utils";
+import { z } from "zod/v4";
 import type { Settings } from "..";
 import type { ToolSession } from "./index";
 
@@ -205,10 +207,11 @@ export function openAutoQaDb(): Database | null {
 	if (cachedDb) return cachedDb;
 	try {
 		const db = new Database(getAutoQaDbPath());
+		// Install the busy handler BEFORE any lock-taking statement. See #2421.
+		db.run("PRAGMA busy_timeout = 5000");
 		db.run(`
 			PRAGMA journal_mode=WAL;
 			PRAGMA synchronous=NORMAL;
-			PRAGMA busy_timeout=5000;
 			CREATE TABLE IF NOT EXISTS grievances (
 				id INTEGER PRIMARY KEY AUTOINCREMENT,
 				model TEXT NOT NULL,
@@ -260,6 +263,10 @@ export interface FlushOptions {
 	 * future debug recipes); never set from the tool's auto-flush path.
 	 */
 	bypassConsent?: boolean;
+	/**
+	 * Fetch implementation for the push POST. Defaults to global fetch.
+	 */
+	fetch?: FetchImpl;
 	/**
 	 * Fires once at the start of the loop with the snapshot count of
 	 * unpushed rows. Subsequent inserts won't be reflected (the count is
@@ -345,13 +352,14 @@ async function performFlush(db: Database, config: PushConfig, options: FlushOpti
 		const totalRow = db.prepare("SELECT COUNT(*) AS n FROM grievances WHERE pushed = 0").get() as { n: number };
 		options.onStart(totalRow.n);
 	}
+	const fetchImpl = options.fetch ?? fetch;
 	let totalPushed = 0;
 	for (;;) {
 		const rows = selectStmt.all(FLUSH_BATCH_SIZE) as GrievanceRow[];
 		if (rows.length === 0) return { pushed: totalPushed, ok: true };
 
 		const body = JSON.stringify({
-			agent: { name: APP_NAME, version: VERSION },
+			agent: { name: "prometheus", version: VERSION },
 			installId: getInstallId(),
 			// Coarse host fingerprint for triage — `darwin`/`linux`/`win32` +
 			// `arm64`/`x64`. Useful for "is this bug arch-specific?" without
@@ -366,7 +374,7 @@ async function performFlush(db: Database, config: PushConfig, options: FlushOpti
 
 		let response: Response;
 		try {
-			response = await fetch(config.endpoint, {
+			response = await fetchImpl(config.endpoint, {
 				method: "POST",
 				headers,
 				body,

package/src/tools/resolve.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@prometheus-ai/tui";
 import { Text } from "@prometheus-ai/tui";
 import { prompt, untilAborted } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
@@ -187,6 +187,20 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 		return untilAborted(signal, async () => {
 			const invoker = this.session.peekQueueInvoker?.() ?? this.session.peekStandingResolveHandler?.();
 			if (!invoker) {
+				// `discard` is a request to cancel/abort a staged action. When nothing is
+				// pending, the desired end-state (no staged change) already holds, so honor
+				// it as a successful cancellation instead of surfacing a hard error to the
+				// model. `apply` still errors — there is nothing to apply.
+				if (params.action === "discard") {
+					return {
+						content: [{ type: "text" as const, text: "Nothing to discard; no pending action remains." }],
+						details: {
+							action: "discard",
+							reason: params.reason,
+							...(params.extra != null ? { extra: params.extra } : {}),
+						},
+					};
+				}
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
 			const result = (await invoker(params)) as AgentToolResult<ResolveToolDetails>;
@@ -227,7 +241,10 @@ export const resolveToolRenderer = {
 		const isApply = action === "apply" && !result.isError;
 		const isFailedApply = action === "apply" && result.isError;
 		const bgColor = result.isError ? "error" : isApply ? "success" : "warning";
-		const icon = isApply ? uiTheme.status.success : uiTheme.status.error;
+		// Bare symbol: the line is wrapped in inverse(fg(...)), so any embedded fg
+		// reset (styledSymbol/status glyphs carry their own \x1b[39m) would drop the
+		// inverse block back to the default background mid-line.
+		const icon = uiTheme.symbol(isApply ? "tool.resolve" : "status.error");
 		const verb = isApply ? "Accept" : isFailedApply ? "Failed" : "Discard";
 		const separator = ": ";
 		const separatorIndex = label.indexOf(separator);
@@ -240,7 +257,7 @@ export const resolveToolRenderer = {
 		const lines = ["", headerLine, "", uiTheme.italic(reason), ""];
 
 		return {
-			render(width: number) {
+			render(width: number): readonly string[] {
 				const lineWidth = Math.max(3, width);
 				const innerWidth = Math.max(1, lineWidth - 2);
 				return lines.map(line => {

package/src/tools/review.ts

@@ -12,7 +12,7 @@ import type { AgentTool } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
 import { Container, Text } from "@prometheus-ai/tui";
 import { isRecord } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
 import type { ReviewFinding } from "../task/types";
@@ -169,7 +169,7 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 		}`;
 
 		return new Text(
-			`${theme.fg("success", theme.status.success)} ${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
+			`${theme.styledSymbol("tool.review", "accent")} ${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
 				"dim",
 				location,
 			)}`,

package/src/tools/search-tool-bm25.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@prometheus-ai/tui";
 import { Text } from "@prometheus-ai/tui";
 import { prompt } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
@@ -16,9 +16,9 @@ import {
 	searchDiscoverableTools,
 	summarizeDiscoverableTools,
 } from "../tool-discovery/tool-index";
-import { renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import { framedBlock, renderStatusLine, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
-import { formatCount, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
+import { formatCount, formatExpandHint, formatMoreItems, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
 const DEFAULT_LIMIT = 8;
@@ -171,6 +171,25 @@ function renderMatchLines(match: SearchToolBm25Match, theme: Theme): string[] {
 	return lines;
 }
 
+function renderMatchBullets(tools: SearchToolBm25Match[], expanded: boolean, theme: Theme): string[] {
+	const shown = expanded ? tools.length : Math.min(tools.length, COLLAPSED_MATCH_LIMIT);
+	const bullet = theme.fg("dim", theme.format.bullet);
+	const lines: string[] = [];
+	for (let i = 0; i < shown; i++) {
+		const itemLines = renderMatchLines(tools[i]!, theme);
+		lines.push(`${bullet} ${itemLines[0]}`);
+		for (let j = 1; j < itemLines.length; j++) {
+			lines.push(`  ${itemLines[j]}`);
+		}
+	}
+	const remaining = tools.length - shown;
+	if (remaining > 0) {
+		const hint = formatExpandHint(theme, expanded, true);
+		lines.push(`${theme.fg("muted", formatMoreItems(remaining, "tool"))}${hint ? ` ${hint}` : ""}`);
+	}
+	return lines;
+}
+
 function renderFallbackResult(text: string, theme: Theme): Component {
 	const header = renderStatusLine({ icon: "warning", title: TOOL_DISCOVERY_TITLE }, theme);
 	const bodyLines = (text || "Tool discovery completed")
@@ -271,14 +290,11 @@ export const searchToolBm25Renderer = {
 	renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const query = typeof args.query === "string" ? replaceTabs(args.query.trim()) : "";
 		const meta = args.limit ? [`limit:${args.limit}`] : [];
-		return new Text(
-			renderStatusLine(
-				{ icon: "pending", title: TOOL_DISCOVERY_TITLE, description: query || "(empty query)", meta },
-				uiTheme,
-			),
-			0,
-			0,
+		const header = renderStatusLine(
+			{ icon: "pending", title: TOOL_DISCOVERY_TITLE, description: query || "(empty query)", meta },
+			uiTheme,
 		);
+		return new Text(header, 0, 0);
 	},
 
 	renderResult(
@@ -305,7 +321,9 @@ export const searchToolBm25Renderer = {
 		const safeQuery = replaceTabs(details.query);
 		const header = renderStatusLine(
 			{
-				icon: details.tools.length > 0 ? "success" : "warning",
+				...(details.tools.length > 0
+					? { iconOverride: uiTheme.fg("accent", uiTheme.symbol("icon.search")) }
+					: { icon: "warning" as const }),
 				title: TOOL_DISCOVERY_TITLE,
 				description: truncateToWidth(safeQuery, MATCH_LABEL_LEN),
 				meta,
@@ -318,19 +336,14 @@ export const searchToolBm25Renderer = {
 			return new Text(`${header}\n${uiTheme.fg("muted", emptyMessage)}`, 0, 0);
 		}
 
-		const lines = [header];
-		const treeLines = renderTreeList(
-			{
-				items: details.tools,
-				expanded: options.expanded,
-				maxCollapsed: COLLAPSED_MATCH_LIMIT,
-				itemType: "tool",
-				renderItem: match => renderMatchLines(match, uiTheme),
-			},
-			uiTheme,
-		);
-		lines.push(...treeLines);
-		return new Text(lines.join("\n"), 0, 0);
+		return framedBlock(uiTheme, width => ({
+			header,
+			sections: [{ lines: renderMatchBullets(details.tools, options.expanded ?? false, uiTheme) }],
+			state: "success",
+			borderColor: "borderMuted",
+			applyBg: false,
+			width,
+		}));
 	},
 
 	mergeCallAndResult: true,