@oh-my-pi/pi-tui 18.4.3 → 18.4.4

package/src/tools/lsp.ts

@@ -7,12 +7,14 @@
  * - Grouped references and symbols
  * - Collapsible/expandable views
  */
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { TspSpan, TspText, TspTone, TspTreeNode } from "@oh-my-pi/pi-wire";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer, ToolRenderResult } from "./renderer";
 import type { Component } from "../tui";
 import { Text } from "../components/text";
 import { getLanguageFromPath } from "../lang-from-path";
 import { highlightCode as highlightThemeCode, type Theme } from "../theme/theme";
 import {
+	formatCount,
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
@@ -26,6 +28,13 @@ import {
 } from "../render/render-utils";
 import { renderStatusLine } from "../render";
 import { framedToolCard } from "../render/tool-card";
+import { ansi, code, col, compact, keyed, md, node, row, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { walkGroupedOutput } from "./grouped-file-output";
+import { diagnosticGlyph, fileHref, fileRow, inlineErrorView } from "./native-view";
+import { activeThemeSymbol } from "../theme/active-symbols";
 
 /** Display arguments for an LSP tool request. */
 export interface LspParams {
@@ -693,10 +702,318 @@ function severityToColor(severity: ParsedDiagnostic["severity"]): "error" | "war
 	}
 }
 
+// =============================================================================
+// Native (TSP) Description
+// =============================================================================
+
+/** The head verb for an LSP action (`type_definition` → `Type definition`). */
+function lspActionTitle(action: string | undefined): string {
+	if (!action || action === "request") return "LSP";
+	const words = action.replace(/_/g, " ");
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+/**
+ * Native head (§7.3 lsp): the action as the verb; the file (`:line`) as a
+ * path target, else the query; then the symbol and option facts, then the
+ * result `meta` (a count chip).
+ */
+function lspNativeHead(
+	request: Partial<LspParams> | undefined,
+	fallbackAction: string,
+	meta: readonly TspText[] = [],
+): NativeToolHead {
+	const facts: string[] = [];
+	const symbol = request?.symbol ? plainText(request.symbol).replaceAll(/\r?\n/g, " ") : undefined;
+	let target: string | undefined;
+	let targetKind: NativeToolHead["targetKind"];
+	if (request?.file) {
+		target = request.line !== undefined ? `${shortenPath(request.file)}:${request.line}` : shortenPath(request.file);
+		targetKind = "path";
+	} else if (request?.query) {
+		target = request.query;
+		targetKind = "query";
+	} else if (request?.line !== undefined) {
+		facts.push(`line ${request.line}`);
+	}
+	if (symbol) facts.push(symbol);
+	if (request?.query && target !== request.query) facts.push(`query:${request.query}`);
+	if (request?.new_name) facts.push(`\u2192 ${request.new_name}`);
+	if (request?.apply !== undefined) facts.push(`apply:${request.apply ? "true" : "false"}`);
+	return {
+		title: lspActionTitle(request?.action ?? fallbackAction),
+		target,
+		targetKind,
+		href: request?.file ? fileHref(request.file) : undefined,
+		meta: [...(facts.length > 0 ? [plainText(facts.join(" \u00b7 "))] : []), ...meta],
+	};
+}
+
+/** A diagnostics response, parsed: diagnostics, server failures and partial-failure warnings. */
+interface LspDiagnosticsParse {
+	diagnostics: ParsedDiagnostic[];
+	failures: string[];
+	warnings: string[];
+	/** Lines neither a diagnostic nor a status line (kept verbatim). */
+	other: string[];
+}
+
+const DIAGNOSTIC_AT_RE = /^\d+:\d+\s+\[/;
+const DIAGNOSTICS_SUMMARY_RE = /^\d+ \w+\(s\)(?:, \d+ \w+\(s\))*:?$/;
+/** A per-file status line's leading status glyph (`✘`, `⚠`, a Nerd Font glyph, ASCII `[!!]`). */
+const STATUS_GLYPH_RE = /^(?:\[[^\]\s]*\]|[^\p{L}\p{N}\s./~\\]+)\s+/u;
+/** Per-file summaries (`✗ a.ts: 2 error(s)`, `✓ a.ts: no issues`) repeat what the rows and head count. */
+const FILE_SUMMARY_RE = /: (?:no issues|\d+ \w+\(s\)(?:, \d+ \w+\(s\))*)$/;
+
+/**
+ * Parse a diagnostics response: grouped (`# dir/`, `## file`, `  12:5 [error] …`)
+ * or flat (`file:12:5 [error] …`) diagnostic lines, and the per-file status
+ * lines (`✗ file: all language servers failed (…)`, `⚠ …some servers failed`,
+ * `✓ file: no issues`, `✗ file: 2 error(s)`).
+ */
+function parseLspDiagnostics(lines: readonly string[]): LspDiagnosticsParse {
+	const out: LspDiagnosticsParse = { diagnostics: [], failures: [], warnings: [], other: [] };
+	let file: string | undefined;
+	for (const event of walkGroupedOutput(lines)) {
+		if (event.kind !== "line") {
+			file = event.kind === "file" ? event.path : undefined;
+			continue;
+		}
+		const line = event.text.trim();
+		if (line === "OK" || DIAGNOSTICS_SUMMARY_RE.test(line)) continue;
+		// Matched by wording, not glyph: a transcript may outlive the theme that wrote it.
+		if (/\ball language servers failed\b/.test(line)) {
+			out.failures.push(line.replace(STATUS_GLYPH_RE, ""));
+			continue;
+		}
+		if (/\bsome servers failed\b/.test(line)) {
+			out.warnings.push(line.replace(STATUS_GLYPH_RE, ""));
+			continue;
+		}
+		if (FILE_SUMMARY_RE.test(line)) continue;
+		const parsed = parseDiagnosticMessage(file && DIAGNOSTIC_AT_RE.test(line) ? `${file}:${line}` : line);
+		if (parsed) out.diagnostics.push(parsed);
+		else out.other.push(line);
+	}
+	return out;
+}
+
+/** `2 errors · 1 warning` in the severity tones, or undefined when there are none. */
+function diagnosticCounts(diagnostics: readonly ParsedDiagnostic[]): TspSpan[] | undefined {
+	const counts: Record<ParsedDiagnostic["severity"], number> = { error: 0, warning: 0, info: 0, hint: 0 };
+	for (const d of diagnostics) counts[d.severity]++;
+	const spans: TspSpan[] = [];
+	for (const severity of ["error", "warning", "info", "hint"] as const) {
+		const n = counts[severity];
+		if (!n) continue;
+		if (spans.length > 0) spans.push(span(" \u00b7 ", "dim"));
+		spans.push(span(formatCount(severity, n), severityTone(severity)));
+	}
+	return spans.length > 0 ? spans : undefined;
+}
+
+function severityTone(severity: ParsedDiagnostic["severity"]): TspTone {
+	switch (severity) {
+		case "error":
+			return "error";
+		case "warning":
+			return "warning";
+		case "info":
+			return "info";
+		default:
+			return "muted";
+	}
+}
+
+/** One diagnostic row (role `omp.tool.diagnostic`): severity icon, mono `file:line:col`, source chip, message. */
+function diagnosticRow(diag: ParsedDiagnostic, key: string): NativeNode {
+	const message: TspSpan[] = [span(diag.message)];
+	if (diag.code) message.push(span(` ${diag.code}`, "muted"));
+	return keyed(
+		row(
+			compact([
+				diagnosticGlyph(diag.severity),
+				text([span(`${diag.filePath}:${diag.line}:${diag.col}`, "mono muted")], { wrap: "none" }),
+				diag.source ? node("badge", { text: diag.source }) : undefined,
+				text(message, { wrap: "word", grow: 1 }),
+			]),
+			{ role: "omp.tool.diagnostic" },
+		),
+		key,
+	);
+}
+
+/** A server failure / partial-failure row: the status icon and the message, in its tone. */
+function statusRow(message: string, tone: "error" | "warning", key: string): NativeNode {
+	return keyed(
+		row([diagnosticGlyph(tone), text([span(plainText(message), tone)], { wrap: "word", grow: 1 })], {
+			role: tone === "error" ? "omp.tool.error" : "omp.tool.diagnostic",
+		}),
+		key,
+	);
+}
+
+/**
+ * Diagnostics view: a card when there are diagnostics or failures (rows of
+ * severity icon · `file:line:col` · source · message), an inline `No issues`
+ * otherwise. A failed server is an error row, never "No issues".
+ */
+function describeLspDiagnostics(request: Partial<LspParams> | undefined, fallbackAction: string, lines: string[]) {
+	const parsed = parseLspDiagnostics(lines);
+	const counts = diagnosticCounts(parsed.diagnostics);
+	const failed =
+		parsed.failures.length > 0 ? [span(formatCount("server failure", parsed.failures.length), "error")] : undefined;
+	const rows: NativeNode[] = [
+		...parsed.failures.map((message, i) => statusRow(message, "error", `x${i}`)),
+		...parsed.diagnostics.map((diag, i) => diagnosticRow(diag, `d${i}`)),
+		...parsed.warnings.map((message, i) => statusRow(message, "warning", `w${i}`)),
+	];
+	if (parsed.other.length > 0) rows.push(keyed(code(parsed.other.join("\n"), { wrap: true }), "other"));
+	const hasErrors = parsed.failures.length > 0 || parsed.diagnostics.some(d => d.severity === "error");
+	const meta = compact<TspText>([counts, failed, !counts && !failed && "No issues"]);
+	const head = lspNativeHead(request, fallbackAction, meta);
+	if (parsed.diagnostics.length === 0 && parsed.failures.length === 0) {
+		return { tool: head, inline: true, body: rows.length > 0 ? rows : undefined } satisfies NativeToolView;
+	}
+	return {
+		tool: head,
+		tone: hasErrors ? "error" : "warning",
+		body: rows,
+		preview: { lines: 8 },
+	} satisfies NativeToolView;
+}
+
+/** References grouped by file (§7.3): a file row with the count, then the `line:col` positions. */
+function describeLspReferences(lines: string[]): NativeNode[] {
+	const byFile = new Map<string, string[]>();
+	for (const loc of lines) {
+		const match = loc.trim().match(/^(.+):(\d+):(\d+)$/);
+		if (!match) continue;
+		const [, file, line, col] = match;
+		let locs = byFile.get(file);
+		if (!locs) {
+			locs = [];
+			byFile.set(file, locs);
+		}
+		locs.push(`${line}:${col}`);
+	}
+	const nodes: NativeNode[] = [];
+	for (const [file, locs] of byFile) {
+		const name = plainText(file);
+		nodes.push(
+			keyed(
+				col(
+					[
+						fileRow(name, { chip: { text: String(locs.length), title: formatCount("reference", locs.length) } }),
+						text([span(locs.join("  "), "mono muted")], { wrap: "word" }),
+					],
+					{ gap: "xs" },
+				),
+				name,
+			),
+		);
+	}
+	return nodes;
+}
+
+function describeLspSymbols(lines: string[]): NativeNode | undefined {
+	const roots: TspTreeNode[] = [];
+	const stack: { indent: number; children: TspTreeNode[] }[] = [];
+	let index = 0;
+	for (const line of lines) {
+		if (!line.includes("@") || !line.includes("line")) continue;
+		const symMatch = line.trim().match(/^(\S+)\s+(.+?)\s*@\s*line\s*(\d+)/);
+		if (!symMatch) continue;
+		const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+		const children: TspTreeNode[] = [];
+		const treeNode: TspTreeNode = {
+			id: `${index++}`,
+			label: [
+				span(plainText(symMatch[1]), "accent"),
+				span(" "),
+				span(plainText(symMatch[2]), "accent"),
+				span(` line ${symMatch[3]}`, "muted"),
+			],
+			open: true,
+			children,
+		};
+		while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+		(stack[stack.length - 1]?.children ?? roots).push(treeNode);
+		stack.push({ indent, children });
+	}
+	return roots.length > 0 ? node("tree", { nodes: roots }) : undefined;
+}
+
+function describeLspResult(result: ToolRenderResult<LspToolDetails>, args: LspParams | undefined): NativeToolView {
+	const request = args ?? result.details?.request;
+	const fallbackAction = result.details?.action ?? "request";
+	const content = result.content?.[0];
+	const text = content?.type === "text" ? (content.text ?? "") : "";
+	if (result.isError) return inlineErrorView(lspNativeHead(request, fallbackAction), text || "LSP request failed");
+	if (!text) return { tool: lspNativeHead(request, fallbackAction, ["No result"]), tone: "warning", inline: true };
+
+	const lines = text.split("\n");
+	const statusError = activeThemeSymbol("status.error");
+	const refMatch = text.match(/(\d+)\s+reference\(s\)/);
+	const symbolsMatch = text.match(/Symbols in (.+):/);
+
+	if (/```(\w*)\n([\s\S]*?)```/.test(text)) {
+		return { tool: lspNativeHead(request, fallbackAction), inline: true, body: [md(text)], preview: { lines: 4 } };
+	}
+	if (
+		/\d+\s+(?:error|warning)\(s\)/.test(text) ||
+		text.includes(statusError) ||
+		(request?.action ?? fallbackAction) === "diagnostics"
+	) {
+		return describeLspDiagnostics(request, fallbackAction, lines);
+	}
+	if (refMatch) {
+		const refCount = Number.parseInt(refMatch[1], 10);
+		const body = describeLspReferences(lines);
+		return {
+			tool: lspNativeHead(request, fallbackAction, [formatCount("reference", refCount)]),
+			tone: refCount > 0 ? undefined : "warning",
+			inline: true,
+			body: body.length > 0 ? body : undefined,
+			preview: { lines: 8 },
+		};
+	}
+	if (symbolsMatch) {
+		const body = describeLspSymbols(lines);
+		return {
+			tool: lspNativeHead(request, fallbackAction, [`in ${symbolsMatch[1]}`]),
+			inline: true,
+			body: body ? [body] : undefined,
+			preview: { lines: 8 },
+		};
+	}
+	const hasError = text.includes("Error:") || text.includes(statusError);
+	const hasSuccess = text.includes(activeThemeSymbol("status.success")) || text.includes("Applied");
+	return {
+		tool: lspNativeHead(request, fallbackAction),
+		tone: hasError && !hasSuccess ? "error" : undefined,
+		inline: true,
+		body: [ansi(text)],
+		preview: { lines: 4 },
+	};
+}
+
+const lspResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render LSP requests and responses in the transcript. */
 export const lspToolRenderer = {
 	renderCall,
 	renderResult,
+	describeCall(args: LspParams): NativeToolView {
+		return { tool: lspNativeHead(args, "request"), inline: true };
+	},
+	describeResult(
+		result: ToolRenderResult<LspToolDetails>,
+		_options: RenderResultOptions,
+		args?: LspParams,
+	): NativeToolView | undefined {
+		return lspResultMemo.get(result, [], () => describeLspResult(result, args));
+	},
 	mergeCallAndResult: true,
 	inline: true,
 } satisfies ToolRenderer<LspParams, LspToolDetails>;

package/src/tools/mcp.ts

@@ -6,9 +6,16 @@
  */
 import { type Component, Markdown } from "../index";
 
-import type { RenderResultOptions } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions } from "./renderer";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
+import { ansi, md } from "../native/describe";
+import type { NativeChild } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorText, noteText, truncationNotice } from "./native-view";
 import { getMarkdownTheme, type Theme } from "../theme/theme";
 import {
+	describeJsonTree,
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -230,6 +237,78 @@ export function renderMCPResult(
 	);
 }
 
+/** Visible MCP argument entries (streaming/intent bookkeeping keys dropped). */
+function visibleMcpArgs(args: Record<string, unknown> | undefined): [string, unknown][] {
+	if (!args || typeof args !== "object") return [];
+	return Object.entries(args).filter(([key]) => key !== INTENT_FIELD && key !== "__partialJson");
+}
+
+/** Inline args summary budget in characters (a data cap, not a width). */
+const MCP_ARGS_SUMMARY_CHARS = 160;
+
+/** Native MCP head: the tool title with a one-line args summary as target. */
+function mcpHead(title: string, args: Record<string, unknown> | undefined): NativeToolHead {
+	const entries = visibleMcpArgs(args);
+	const summary =
+		entries.length > 0
+			? formatArgsInline(Object.fromEntries(entries), MCP_ARGS_SUMMARY_CHARS, { characterBudget: true })
+			: "";
+	return { title, target: summary ? plainText(summary) : undefined, targetKind: "text" };
+}
+
+/** Native MCP call view: the head only, inline while pending. */
+export function describeMCPCall(args: Record<string, unknown>, label: string): NativeToolView {
+	return { tool: mcpHead(label, args), inline: true };
+}
+
+const mcpResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
+/**
+ * Native MCP result view: JSON output as a JSON tree, Markdown when the
+ * preference is on, otherwise the raw text as tool output. The head's args
+ * summary stands in for the ANSI card's Args tree.
+ */
+export function describeMCPResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: MCPToolDetails; isError?: boolean },
+	_options: RenderResultOptions,
+	args?: Record<string, unknown>,
+): NativeToolView | undefined {
+	return mcpResultMemo.get(result, [renderMarkdownResults, JSON.stringify(args ?? null)], () => {
+		const textContent = (result.content ?? [])
+			.filter(block => block.type === "text")
+			.map(block => block.text ?? "")
+			.filter(text => text.length > 0)
+			.join("\n\n");
+		const output = stripOutputNotice(textContent, result.details?.meta).trimEnd();
+		const isError = result.isError ?? result.details?.isError ?? false;
+		const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+		const body: NativeChild[] = [];
+		let parsed: unknown;
+		let isJson = false;
+		if (output.startsWith("{") || output.startsWith("[")) {
+			try {
+				parsed = JSON.parse(output);
+				isJson = true;
+			} catch {
+				// Bracketed non-JSON text falls through to Markdown/raw output.
+			}
+		}
+		if (!output) body.push(noteText("(no output)"));
+		else if (isError) body.push(errorText(output));
+		else if (isJson) body.push(describeJsonTree(parsed));
+		else if (renderMarkdownResults) body.push(md(output));
+		else body.push(ansi(output));
+		const warning = truncationNotice(result.details?.meta);
+		if (warning) body.push(warning);
+		return {
+			tool: mcpHead(title, args),
+			tone: isError ? "error" : undefined,
+			body,
+			preview: { lines: 4 },
+		};
+	});
+}
+
 import type { OutputMeta } from "./output-meta";
 
 let renderMarkdownResults = false;

package/src/tools/memory.ts

@@ -1,4 +1,4 @@
-import type { ToolRenderer } from "./renderer";
+import type { NativeToolView, ToolRenderer } from "./renderer";
 /**
  * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
  * `reflect`).
@@ -23,6 +23,10 @@ import {
 	replaceTabs,
 	type ToolUIStatus,
 } from "../render/render-utils";
+import { item, list, md, span, text } from "../native/describe";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, resultText, toolHead } from "./native-view";
 
 // Each stored memory renders as `<bullet> <content>`; the bullet glyph comes
 // from the active theme (`•` by default, a nerd-font dot under nerd themes).
@@ -48,10 +52,6 @@ function retainContents(args: RetainRenderArgs | undefined): string[] {
 	return contents;
 }
 
-function resultText(result: { content?: Array<{ type: string; text?: string }> }): string {
-	return (result.content?.find(c => c.type === "text")?.text ?? "").trim();
-}
-
 /** Single-line query header used by `recall`/`reflect` calls and results. */
 function queryHeader(
 	title: string,
@@ -85,6 +85,24 @@ function retainComponent(contents: string[], header: string, getExpanded: () =>
 	});
 }
 
+/** Retained memories as a list, clamped to the collapsed item budget. */
+function describeRetain(contents: string[], summary?: string): NativeToolView {
+	return {
+		head: toolHead("Retain", summary),
+		inline: true,
+		body:
+			contents.length > 0
+				? [list(contents.map((content, i) => item(String(i), { label: plainText(content) })))]
+				: [],
+		preview: { lines: PREVIEW_LIMITS.COLLAPSED_ITEMS },
+	};
+}
+
+const retainCallMemo = new OwnerMemo<NativeToolView | undefined>();
+const retainResultMemo = new OwnerMemo<NativeToolView | undefined>();
+const recallResultMemo = new OwnerMemo<NativeToolView | undefined>();
+const reflectResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render retained memory items and their storage summary. */
 export const retainToolRenderer = {
 	inline: true,
@@ -101,12 +119,12 @@ export const retainToolRenderer = {
 		args?: RetainRenderArgs,
 	): Component {
 		if (result.isError) {
-			return new Text(formatErrorMessage(resultText(result) || "Retain failed", theme), 0, 0);
+			return new Text(formatErrorMessage(resultText(result).trim() || "Retain failed", theme), 0, 0);
 		}
 		const contents = retainContents(args);
 		// `summary` is the tool's own "N memories stored/queued." line; drop the
 		// trailing period so it reads cleanly as a status meta segment.
-		const summary = resultText(result).replace(/\.$/, "");
+		const summary = resultText(result).trim().replace(/\.$/, "");
 		const header = renderStatusLine(
 			{
 				iconOverride: theme.styledSymbol("tool.memory", "accent"),
@@ -117,6 +135,21 @@ export const retainToolRenderer = {
 		);
 		return retainComponent(contents, header, () => options.expanded, theme);
 	},
+	describeCall(args: RetainRenderArgs): NativeToolView | undefined {
+		const contents = retainContents(args);
+		return retainCallMemo.get(args, [contents.join("\0")], () => describeRetain(contents));
+	},
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: MemoryRetainDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: RetainRenderArgs,
+	): NativeToolView | undefined {
+		return retainResultMemo.get(result, [], () => {
+			if (result.isError)
+				return { ...errorView("Retain", resultText(result).trim() || "Retain failed"), inline: true };
+			return describeRetain(retainContents(args), resultText(result).trim().replace(/\.$/, ""));
+		});
+	},
 } satisfies ToolRenderer<RetainRenderArgs, MemoryRetainDetails>;
 
 /** Render recalled memories with an expandable body. */
@@ -133,9 +166,9 @@ export const recallToolRenderer = {
 		args?: QueryRenderArgs,
 	): Component {
 		if (result.isError) {
-			return new Text(formatErrorMessage(resultText(result) || "Recall failed", theme), 0, 0);
+			return new Text(formatErrorMessage(resultText(result).trim() || "Recall failed", theme), 0, 0);
 		}
-		const text = resultText(result);
+		const text = resultText(result).trim();
 		const match = text.match(/^Found (\d+) relevant/);
 		const found = match ? Number(match[1]) : 0;
 		const meta = [found > 0 ? `${found} found` : "no matches"];
@@ -165,6 +198,34 @@ export const recallToolRenderer = {
 			},
 		);
 	},
+	describeCall(args: QueryRenderArgs): NativeToolView {
+		return { head: toolHead("Recall", args.query?.trim()), inline: true };
+	},
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: QueryRenderArgs,
+	): NativeToolView | undefined {
+		return recallResultMemo.get(result, [], () => {
+			const query = args?.query?.trim();
+			const output = resultText(result).trim();
+			if (result.isError) return { ...errorView("Recall", output || "Recall failed", query), inline: true };
+			const found = Number(output.match(/^Found (\d+) relevant/)?.[1] ?? 0);
+			if (found === 0) return { head: toolHead("Recall", query, "no matches"), tone: "warning", inline: true };
+			// Collapsed keeps to the header; expanding reveals the recalled memories.
+			const memories = output
+				.replace(/^[^\n]*\n+/, "")
+				.split("\n")
+				.slice(0, PREVIEW_LIMITS.OUTPUT_EXPANDED)
+				.join("\n");
+			return {
+				head: toolHead("Recall", query, `${found} found`),
+				inline: true,
+				body: memories.trim() ? [text([span(plainText(memories), "muted")], { wrap: "word" })] : [],
+				preview: { lines: 0 },
+			};
+		});
+	},
 } satisfies ToolRenderer<QueryRenderArgs, unknown>;
 
 /** Render synthesized memory reflections. */
@@ -181,7 +242,7 @@ export const reflectToolRenderer = {
 		args?: QueryRenderArgs,
 	): Component {
 		if (result.isError) {
-			return new Text(formatErrorMessage(resultText(result) || "Reflect failed", theme), 0, 0);
+			return new Text(formatErrorMessage(resultText(result).trim() || "Reflect failed", theme), 0, 0);
 		}
 		const header = queryHeader(
 			"Reflect",
@@ -191,7 +252,7 @@ export const reflectToolRenderer = {
 			undefined,
 			theme.styledSymbol("tool.memory", "accent"),
 		);
-		const answer = resultText(result);
+		const answer = resultText(result).trim();
 		const answerLines = answer.split("\n").filter(line => line.trim().length > 0);
 		return createCachedComponent(
 			() => options.expanded,
@@ -212,6 +273,27 @@ export const reflectToolRenderer = {
 			},
 		);
 	},
+	describeCall(args: QueryRenderArgs): NativeToolView {
+		return { head: toolHead("Reflect", args.query?.trim()), inline: true };
+	},
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: QueryRenderArgs,
+	): NativeToolView | undefined {
+		return reflectResultMemo.get(result, [], () => {
+			const query = args?.query?.trim();
+			const answer = resultText(result).trim();
+			if (result.isError) return { ...errorView("Reflect", answer || "Reflect failed", query), inline: true };
+			const shown = answer.split("\n").slice(0, PREVIEW_LIMITS.OUTPUT_EXPANDED).join("\n").trim();
+			return {
+				head: toolHead("Reflect", query),
+				inline: true,
+				body: shown ? [md(shown, { role: "omp.memory.reflect" })] : [],
+				preview: { lines: PREVIEW_LIMITS.OUTPUT_COLLAPSED },
+			};
+		});
+	},
 } satisfies ToolRenderer<QueryRenderArgs, unknown>;
 
 /** Number of memories accepted by retain. */