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

package/src/theme/shimmer.ts

@@ -1,3 +1,7 @@
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { node } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { isNativeRendering } from "../native/state";
 import type { Theme, ThemeColor } from "./theme";
 import { FG_RESET } from "./color";
 
@@ -151,6 +155,28 @@ export function shimmerEnabled(): boolean {
 	return activeMode !== "disabled";
 }
 
+/**
+ * Describe shimmering segments for a TSP terminal, which clocks the sweep
+ * itself: a `shimmer` node in the active mode, or plain spans in the mid tier
+ * color when shimmer is disabled. Palette tiers given as theme colors travel as
+ * token names; raw-ANSI tiers are dropped (the terminal's theme decides).
+ */
+export function describeShimmer(segments: readonly ShimmerSegment[], key?: string): NativeNode {
+	const spans: TspSpan[] = [];
+	for (const { text: value, palette } of segments) {
+		if (value.length === 0) continue;
+		const mid = (palette ?? DEFAULT_SHIMMER_PALETTE).mid;
+		spans.push(typeof mid === "string" ? { t: value, s: mid } : { t: value });
+	}
+	if (activeMode === "disabled") return node("text", { spans }, undefined, key);
+	const palette = segments[0]?.palette ?? DEFAULT_SHIMMER_PALETTE;
+	const tokens: { low?: string; mid?: string; high?: string } = {};
+	if (typeof palette.low === "string") tokens.low = palette.low;
+	if (typeof palette.mid === "string") tokens.mid = palette.mid;
+	if (typeof palette.high === "string") tokens.high = palette.high;
+	return node("shimmer", { spans, mode: activeMode, palette: tokens }, undefined, key);
+}
+
 /**
  * Apply a shimmer sweep across one or more segments, treating them as a
  * single continuous string for band positioning. Each segment can supply
@@ -165,6 +191,13 @@ export function shimmerEnabled(): boolean {
  *   - No per-char allocations beyond the run buffer.
  */
 export function shimmerSegments(segments: readonly ShimmerSegment[], theme: ShimmerTheme): string {
+	// A TSP terminal animates shimmer from described nodes; a frame painted
+	// here would freeze mid-sweep, so the text goes out unstyled.
+	if (isNativeRendering()) {
+		let out = "";
+		for (const { text: value } of segments) out += value;
+		return out;
+	}
 	const mode = activeMode;
 
 	// Disabled: no animation or code-point scan. Preserve the all-empty result,

package/src/theme/theme-class.ts

@@ -140,6 +140,26 @@ const underlineStyler = chalk.underline;
 const strikethroughStyler = chalk.strikethrough;
 const inverseStyler = chalk.inverse;
 
+/** Theme token of a thinking/effort level name (`off`…`max`); unknown levels (`auto`) map to `thinkingOff`. */
+export function thinkingLevelToken(level: string): ThemeColor {
+	switch (level) {
+		case "minimal":
+			return "thinkingMinimal";
+		case "low":
+			return "thinkingLow";
+		case "medium":
+			return "thinkingMedium";
+		case "high":
+			return "thinkingHigh";
+		case "xhigh":
+			return "thinkingXhigh";
+		case "max":
+			return "thinkingMax";
+		default:
+			return "thinkingOff";
+	}
+}
+
 export class Theme {
 	#fgColors: Record<ThemeColor, string>;
 	#bgColors: Record<ThemeBg, string>;
@@ -419,25 +439,10 @@ export class Theme {
 
 	/** Border color for a thinking/effort level name (`off`…`max`); unknown levels fall back to `thinkingOff`. */
 	getThinkingBorderColor(level: string): (str: string) => string {
-		switch (level) {
-			case "off":
-				return (str: string) => this.fg("thinkingOff", str);
-			case "minimal":
-				return (str: string) => this.fg("thinkingMinimal", str);
-			case "low":
-				return (str: string) => this.fg("thinkingLow", str);
-			case "medium":
-				return (str: string) => this.fg("thinkingMedium", str);
-			case "high":
-				return (str: string) => this.fg("thinkingHigh", str);
-			case "xhigh":
-				return (str: string) => this.fg("thinkingXhigh", str);
-			case "max":
-				// thinkingMax is optional; themes without it resolve to the xhigh color.
-				return (str: string) => this.fg(this.#fgColors.thinkingMax ? "thinkingMax" : "thinkingXhigh", str);
-			default:
-				return (str: string) => this.fg("thinkingOff", str);
-		}
+		const token = thinkingLevelToken(level);
+		// thinkingMax is optional; themes without it resolve to the xhigh color.
+		const color = token === "thinkingMax" && !this.#fgColors.thinkingMax ? "thinkingXhigh" : token;
+		return (str: string) => this.fg(color, str);
 	}
 
 	getBashModeBorderColor(): (str: string) => string {

package/src/theme/theme.ts

@@ -7,8 +7,16 @@ import { getCustomThemesDir } from "@oh-my-pi/pi-utils/dirs";
 import * as logger from "@oh-my-pi/pi-utils/logger";
 import { setActiveSymbolTheme } from "./active-symbols";
 import { ansi256ToHex, resolveThemeColors, resolveVarRefs } from "./color";
-import { type CreateThemeOptions, getBuiltinThemes, loadTheme, loadThemeJson, loadThemeSync } from "./loader";
-import type { ThemeColor, ThemeJson } from "./schema";
+import {
+	type CreateThemeOptions,
+	createTheme,
+	getBuiltinThemes,
+	loadTheme,
+	loadThemeJson,
+	loadThemeJsonSync,
+	loadThemeSync,
+} from "./loader";
+import { isValidThemeBg, isValidThemeColor, type ThemeColor, type ThemeJson } from "./schema";
 import type { SymbolPreset } from "./symbols";
 import type { Theme } from "./theme-class";
 
@@ -84,6 +92,8 @@ function getDefaultTheme(): string {
 /** Active theme; imports remain live across initialization, previews, and theme switches. */
 export var theme: Theme;
 var currentThemeName: string | undefined;
+/** Theme shown by `previewTheme` until the next non-preview assignment. */
+var previewThemeName: string | undefined;
 
 type ThemeBinding = (value: Theme) => void;
 var themeBindings: Set<ThemeBinding> | undefined;
@@ -98,8 +108,10 @@ export function bindTheme(binding: ThemeBinding): () => void {
 	};
 }
 
-function assignTheme(value: Theme): void {
+/** `previewName` marks a theme-selector preview; any other assignment ends it. */
+function assignTheme(value: Theme, previewName?: string): void {
 	theme = value;
+	previewThemeName = previewName;
 	setActiveSymbolTheme(value);
 	if (themeBindings) {
 		for (const binding of themeBindings) binding(value);
@@ -121,6 +133,9 @@ export interface ThemeChangeEvent {
 }
 
 var currentSymbolPresetOverride: SymbolPreset | undefined;
+// Process-local preset forced while a Tern Surface Protocol surface is live;
+// wins over the user's preset and is never persisted.
+var nativeSymbolPreset: SymbolPreset | undefined;
 var currentColorBlindMode: boolean = false;
 var themeWatcher: fs.FSWatcher | undefined;
 var themeReloadTimer: NodeJS.Timeout | undefined;
@@ -134,7 +149,7 @@ let themeEpoch = 0;
 
 function getCurrentThemeOptions(): CreateThemeOptions {
 	return {
-		symbolPresetOverride: currentSymbolPresetOverride,
+		symbolPresetOverride: nativeSymbolPreset ?? currentSymbolPresetOverride,
 		colorBlindMode: currentColorBlindMode,
 	};
 }
@@ -162,10 +177,7 @@ export function initThemeSync(
 	lightTheme?: string,
 ): void {
 	const name = configureTheme(symbolPreset, colorBlindMode, darkTheme, lightTheme);
-	const options: CreateThemeOptions = {
-		symbolPresetOverride: currentSymbolPresetOverride,
-		colorBlindMode: currentColorBlindMode,
-	};
+	const options = getCurrentThemeOptions();
 	try {
 		assignTheme(loadThemeSync(name, options));
 	} catch (error) {
@@ -255,7 +267,8 @@ export async function previewTheme(
 		if (requestId !== themeLoadRequestId) {
 			return { success: false, error: "Theme preview superseded by a newer request" };
 		}
-		assignTheme(loadedTheme);
+		// Previewing the active theme again (selector cancel) ends the preview.
+		assignTheme(loadedTheme, name === currentThemeName ? undefined : name);
 		notifyThemeChange(event);
 		return { success: true };
 	} catch (error) {
@@ -337,6 +350,30 @@ export function getSymbolPresetOverride(): SymbolPreset | undefined {
 	return currentSymbolPresetOverride;
 }
 
+/**
+ * Force `preset` while a Tern Surface Protocol surface is live (the terminal's
+ * font carries every Nerd Font glyph, so icons need no Glyph Protocol
+ * registration); `undefined` restores the user's preset. Process-local and
+ * never persisted. Rebuilds the active theme synchronously so the next frame
+ * already uses it, and notifies theme listeners like a preset change. Returns
+ * whether the active theme was rebuilt (callers invalidate render caches).
+ */
+export function setNativeSymbolPreset(preset: SymbolPreset | undefined): boolean {
+	if (nativeSymbolPreset === preset) return false;
+	nativeSymbolPreset = preset;
+	if (!currentThemeName || typeof theme === "undefined") return false;
+	++themeLoadRequestId;
+	try {
+		assignTheme(loadThemeSync(currentThemeName, getCurrentThemeOptions()));
+	} catch (error) {
+		// In-memory themes can't be rebuilt by name; they keep their symbols.
+		logger.debug("Native symbol preset: theme rebuild skipped", { theme: currentThemeName, error: String(error) });
+		return false;
+	}
+	notifyThemeChange({ ephemeral: true });
+	return true;
+}
+
 /**
  * Set color blind mode, recreating the theme with the new setting.
  * When enabled, uses blue instead of green for diff additions.
@@ -770,6 +807,71 @@ export async function getResolvedThemeColors(themeName?: string): Promise<Record
 	return cssColors;
 }
 
+/** One appearance variant of {@link NativeThemePalette}: token name → `#rrggbb`. */
+export type NativeThemeVariant = Record<string, string>;
+
+/** omp's resolved theme for a Tern Surface Protocol terminal (the `t` verb body minus `sf`). */
+export interface NativeThemePalette {
+	dark?: NativeThemeVariant;
+	light?: NativeThemeVariant;
+	name: { dark?: string; light?: string };
+}
+
+/**
+ * Cheap identity of everything {@link getNativeThemePalette} depends on;
+ * recompute the palette only when it changes.
+ */
+export function getNativeThemePaletteKey(): string {
+	return `${themeEpoch}|${autoDetectedTheme}|${autoDarkTheme}|${autoLightTheme}|${currentThemeName}|${previewThemeName}|${currentColorBlindMode}`;
+}
+
+/** Every token of theme `name` as hex (terminal-default tokens omitted), plus its export colours. */
+function nativeThemeVariant(name: string): { light: boolean; colors: NativeThemeVariant } {
+	const themeJson = loadThemeJsonSync(name);
+	const built = createTheme(themeJson, getCurrentThemeOptions());
+	const raw = resolveThemeColors(themeJson.colors, themeJson.vars);
+	const colors: NativeThemeVariant = {};
+	for (const key in raw) {
+		// Terminal-default tokens stay unset; keys outside the schema are ignored like the theme does.
+		if (raw[key as keyof typeof raw] === "") continue;
+		if (isValidThemeColor(key)) colors[key] = built.getColorHex(key);
+		else if (isValidThemeBg(key)) colors[key] = built.getBgHex(key);
+	}
+	const exported = resolveThemeExportColors(themeJson);
+	for (const key of ["pageBg", "cardBg", "infoBg"] as const) {
+		const value = exported[key];
+		if (value) colors[key] = value;
+	}
+	return { light: isLightThemeJson(themeJson), colors };
+}
+
+/**
+ * omp's theme for a native surface: with auto theme, the configured dark and
+ * light themes; otherwise (or while the theme selector previews one) the
+ * active theme under its own appearance only. Themes without a loadable
+ * definition (in-memory instances) contribute nothing.
+ */
+export function getNativeThemePalette(): NativeThemePalette {
+	const palette: NativeThemePalette = { name: {} };
+	const add = (name: string, as?: "dark" | "light"): void => {
+		try {
+			const variant = nativeThemeVariant(name);
+			const slot = as ?? (variant.light ? "light" : "dark");
+			palette[slot] = variant.colors;
+			palette.name[slot] = name;
+		} catch (error) {
+			logger.debug("Native theme palette: theme not loadable", { name, error: String(error) });
+		}
+	};
+	const single = previewThemeName ?? (autoDetectedTheme ? undefined : currentThemeName);
+	if (single !== undefined) add(single);
+	else {
+		add(autoDarkTheme, "dark");
+		add(autoLightTheme, "light");
+	}
+	return palette;
+}
+
 /**
  * Check if a theme is a "light" theme by analyzing its status-line background
  * luminance. Loads theme JSON synchronously (built-in or custom file on disk)

package/src/tools/ask.ts

@@ -1,4 +1,10 @@
-import type { ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, ToolRenderer, ToolRenderResult } from "./renderer";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { compact, md, node, row, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { noteText, resultText } from "./native-view";
 
 import {
 	type Component,
@@ -281,8 +287,158 @@ function renderAnswerOptionLines(
 	return out;
 }
 
+function askHead(question: string | undefined, meta?: string): NativeToolHead {
+	const first = question ? plainText(sanitizeCarriageReturns(question)).trim().split("\n")[0] : "";
+	return { title: "Ask", target: first || undefined, targetKind: "text", meta: meta ? [meta] : undefined };
+}
+
+/** One question of a multi-question result: the question as markdown over its answers. */
+function describeQuestionSection(id: string, question: string, rest: readonly NativeChild[]): NativeNode {
+	return node("section", {}, [md(plainText(question)), ...rest], id);
+}
+
+/** An answer row: a success check before the chosen label, or a quiet unchosen label. */
+function answerRow(key: string, label: TspSpan[], chosen: boolean): NativeNode {
+	return row(
+		compact([chosen ? node("icon", { name: "check", tone: "success" }) : undefined, text(label, { wrap: "word" })]),
+		{ gap: "sm", align: "baseline", role: chosen ? "omp.tool.answer" : "omp.tool.answer.off", key },
+	);
+}
+
+/**
+ * Answered option list: every offered option marked chosen or not, plus any
+ * quoted custom answer and a muted note. A lone "Cancelled" line when nothing was chosen.
+ */
+function describeAnswers(
+	options: string[] | undefined,
+	selectedOptions: string[] | undefined,
+	customInput: string | undefined,
+	note: string | undefined,
+	selectedIndices: ReadonlySet<number> | undefined,
+): NativeChild[] {
+	const selected = new Set(selectedOptions ?? []);
+	if (selected.size === 0 && customInput === undefined && note === undefined) {
+		return [text([span("Cancelled", "warning")], { tone: "warning" })];
+	}
+	const labels = options && options.length > 0 ? options : (selectedOptions ?? []);
+	const rows = labels.map((label, index) => {
+		const isSelected = selectedIndices !== undefined ? selectedIndices.has(index) : selected.has(label);
+		return answerRow(`${index}`, [span(plainText(label), isSelected ? "toolOutput" : "muted")], isSelected);
+	});
+	if (customInput !== undefined) {
+		rows.push(answerRow("custom", [span(`\u201c${plainText(customInput)}\u201d`, "toolOutput")], true));
+	}
+	return compact([
+		...rows,
+		note !== undefined
+			? text([span(plainText(note), "muted")], { wrap: "word", role: "omp.tool.context" })
+			: undefined,
+	]);
+}
+
+/** Pending ask: an inline head naming the question; the ask dialog owns the form. */
+function describeAskCall(args: AskRenderArgs): NativeToolView {
+	const questions = normalizeRenderQuestions(args.questions);
+	const first = questions?.[0]?.question ?? (typeof args.question === "string" ? args.question : undefined);
+	const more = questions && questions.length > 1 ? `${questions.length} questions` : undefined;
+	return {
+		tool: askHead(first, more),
+		inline: true,
+		body: [text([span("Waiting for your answer…", "muted")])],
+	};
+}
+
+function describeAskResult(result: ToolRenderResult<AskToolDetails>, args: AskRenderArgs | undefined): NativeToolView {
+	const rawDetails = result.details;
+	const fallback = plainText(sanitizeCarriageReturns(resultText(result)));
+	const argQuestion =
+		normalizeRenderQuestions(args?.questions)?.[0]?.question ??
+		(typeof args?.question === "string" ? args.question : undefined);
+	if (!rawDetails) {
+		return { tool: askHead(argQuestion), tone: "warning", body: fallback ? [noteText(fallback)] : undefined };
+	}
+	const details = sanitizeAskResultDetails(rawDetails);
+
+	if (details.chatRedirect) {
+		return {
+			tool: askHead(details.questions?.[0] ?? argQuestion, "chat redirect"),
+			tone: "info",
+			body: (details.questions ?? []).map(q => md(plainText(q))),
+		};
+	}
+
+	if (details.results && details.results.length > 0) {
+		const results = details.results;
+		const rawResults = rawDetails.results ?? [];
+		const answered = results.some(
+			r =>
+				r.customInput !== undefined || r.note !== undefined || (r.selectedOptions && r.selectedOptions.length > 0),
+		);
+		return {
+			tool: askHead(results[0]?.question, results.length > 1 ? `${results.length} questions` : undefined),
+			tone: answered ? undefined : "warning",
+			// Sanitizing preserves order and length, so raw indices align with `r`.
+			body: results.map((r, index) =>
+				describeQuestionSection(
+					r.id,
+					r.question,
+					describeAnswers(
+						r.options,
+						r.selectedOptions,
+						r.customInput,
+						r.note,
+						selectedIndicesFor(rawResults[index]?.options, rawResults[index]?.selectedOptions),
+					),
+				),
+			),
+		};
+	}
+
+	if (!details.question) {
+		return { tool: askHead(argQuestion), body: fallback ? [text(fallback, { wrap: "word" })] : undefined };
+	}
+
+	const answered =
+		details.customInput !== undefined ||
+		details.note !== undefined ||
+		(details.selectedOptions && details.selectedOptions.length > 0);
+	return {
+		tool: askHead(details.question),
+		tone: answered ? undefined : "warning",
+		body: compact([
+			md(plainText(details.question)),
+			...describeAnswers(
+				details.options,
+				details.selectedOptions,
+				details.customInput,
+				details.note,
+				selectedIndicesFor(rawDetails.options, rawDetails.selectedOptions),
+			),
+			details.timedOut
+				? text([span("auto-selected after timeout — not a user choice", "muted")], {
+						wrap: "word",
+						role: "omp.tool.notice",
+					})
+				: undefined,
+		]),
+	};
+}
+
+const askCallMemo = new OwnerMemo<NativeToolView | undefined>();
+const askResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render question forms and their recorded answers. */
 export const askToolRenderer = {
+	describeCall(args: AskRenderArgs): NativeToolView | undefined {
+		return askCallMemo.get(args, [JSON.stringify(args)], () => describeAskCall(args));
+	},
+	describeResult(
+		result: ToolRenderResult<AskToolDetails>,
+		_options?: RenderResultOptions,
+		args?: AskRenderArgs,
+	): NativeToolView | undefined {
+		return askResultMemo.get(result, [], () => describeAskResult(result, args));
+	},
 	mergeCallAndResult: true,
 	renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const label = formatTitle("Ask", uiTheme);

package/src/tools/ast-edit.ts

@@ -14,7 +14,11 @@ import {
 } from "../render/render-utils";
 import { classifyGroupedLines, groupLineIndicesByBlank } from "./grouped-file-output";
 import type { OutputMeta } from "./output-meta";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import { code, compact, diff, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { diffStatsMeta, displayPath, errorText, fileDiffSection, noteText, resultText, statsText } from "./native-view";
+import { getLanguageFromPath } from "../lang-from-path";
 
 /** Display metadata returned by ast-edit. */
 export interface AstEditToolDetails {
@@ -82,6 +86,86 @@ function patternPreview(pat: string | undefined): string | undefined {
 	return collapsed || undefined;
 }
 
+const AST_EDIT_HEADER_RE = /^(#+)\s+(.*)$/;
+const AST_EDIT_CHANGE_LINE_RE = /^([+\- ])\s*(\d+)(?:│|[:|])(.*)$/;
+const AST_EDIT_HEADER_SUFFIX_RE = /\s+\([^)]*\)\s*$/;
+
+/** One file's proposed rewrite: its unified diff text and change counts. */
+interface AstEditFileDiff {
+	path: string;
+	lines: string[];
+	added: number;
+	removed: number;
+	lastOld?: number;
+}
+
+/**
+ * Parse ast-edit display content (`# dir/`, `## file (N replacements)`,
+ * `-12│old` / `+12│new`) into one unified diff per file.
+ */
+function parseAstEditChanges(lines: readonly string[]): AstEditFileDiff[] {
+	const files: AstEditFileDiff[] = [];
+	const dirs: string[] = [];
+	let file: AstEditFileDiff | undefined;
+	const flush = () => {
+		if (file && file.lines.length > 0) files.push(file);
+		file = undefined;
+	};
+	for (const line of lines) {
+		const header = AST_EDIT_HEADER_RE.exec(line);
+		if (header) {
+			flush();
+			const depth = header[1]!.length;
+			const rest = header[2]!.trimEnd().replace(AST_EDIT_HEADER_SUFFIX_RE, "");
+			dirs.length = depth - 1;
+			if (rest.endsWith("/")) {
+				dirs[depth - 1] = rest.slice(0, -1);
+				continue;
+			}
+			const prefix = dirs.filter(Boolean).join("/");
+			file = { path: prefix ? `${prefix}/${rest}` : rest, lines: [], added: 0, removed: 0 };
+			continue;
+		}
+		if (!file || line.trim().length === 0) continue;
+		const change = AST_EDIT_CHANGE_LINE_RE.exec(line);
+		if (!change) continue;
+		const lineNumber = Number.parseInt(change[2]!, 10);
+		if (file.lastOld === undefined || lineNumber > file.lastOld + 1 || lineNumber < file.lastOld) {
+			file.lines.push(`@@ -${lineNumber} +${lineNumber} @@`);
+		}
+		file.lastOld = lineNumber;
+		if (change[1] === "+") file.added++;
+		else if (change[1] === "-") file.removed++;
+		file.lines.push(`${change[1]}${change[3]}`);
+	}
+	flush();
+	return files;
+}
+
+/** A file's proposed rewrite as a `diff`: highlighted by the path's language, no path header. */
+function astEditDiff(file: AstEditFileDiff): NativeNode {
+	return diff(file.lines.join("\n"), { lang: getLanguageFromPath(file.path) });
+}
+
+/** The single rewrite pattern (`target:"pattern"`), or the rewrite count, for the head. */
+function astEditPatternHead(args: AstEditRenderArgs | undefined): Pick<NativeToolHead, "target" | "targetKind"> {
+	const rewriteCount = args?.ops?.length ?? 0;
+	if (rewriteCount === 1) {
+		const pattern = patternPreview(args?.ops?.[0]?.pat);
+		return pattern ? { target: pattern, targetKind: "pattern" } : {};
+	}
+	return rewriteCount > 1 ? { target: `${rewriteCount} rewrites`, targetKind: "text" } : {};
+}
+
+/** Scope facts for the final quiet line: `in src · searched 12 files · limit reached; narrow path`. */
+function astEditScopeStats(details: AstEditToolDetails | undefined): NativeNode | undefined {
+	const parts: string[] = [];
+	if (details?.scopePath) parts.push(`in ${details.scopePath}`);
+	if (details?.filesSearched) parts.push(`searched ${formatCount("file", details.filesSearched)}`);
+	if (details?.limitReached) parts.push("limit reached; narrow path");
+	return statsText(parts);
+}
+
 /** Render AST edit calls and results. */
 export const astEditToolRenderer = {
 	inline: true,
@@ -206,5 +290,94 @@ export const astEditToolRenderer = {
 			};
 		});
 	},
+	describeCall(args: AstEditRenderArgs): NativeToolView {
+		return {
+			tool: {
+				title: "AST Edit",
+				...astEditPatternHead(args),
+				meta: args.paths?.length ? [`in ${args.paths.map(displayPath).join(", ")}`] : undefined,
+			},
+		};
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: AstEditToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: AstEditRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		const patternHead = astEditPatternHead(args);
+		if (result.isError) {
+			return {
+				tool: { title: "AST Edit", ...patternHead },
+				tone: "error",
+				body: [errorText(resultText(result) || "Unknown error")],
+			};
+		}
+		const parseErrors = details?.parseErrors ?? [];
+		const parseNote: NativeChild | undefined =
+			parseErrors.length > 0
+				? node(
+						"section",
+						{
+							head: [span(formatParseErrorsCountLabel(parseErrors, details?.parseErrorsTotal), "warning")],
+							collapsible: true,
+							collapsed: true,
+						},
+						[code(parseErrors.join("\n"))],
+						"parse-errors",
+					)
+				: undefined;
+		const totalReplacements = details?.totalReplacements ?? 0;
+		if (totalReplacements === 0) {
+			return {
+				tool: { title: "AST Edit", ...patternHead, meta: ["0 replacements"] },
+				tone: "warning",
+				body: compact<NativeChild>([parseNote, astEditScopeStats(details)]),
+			};
+		}
+		const limitReached = details?.limitReached ?? false;
+		const allLines = (details?.displayContent ?? resultText(result)).split("\n");
+		const kept = groupLineIndicesByBlank(allLines)
+			.filter(indices => {
+				const first = allLines[indices[0]!]!;
+				return !first.startsWith("Safety cap reached") && !first.startsWith("Parse issues:");
+			})
+			.flatMap(indices => indices.map(index => allLines[index]!));
+		const files = parseAstEditChanges(kept);
+		const fileCount = Math.max(details?.filesTouched ?? 0, files.length);
+		let added = 0;
+		let removed = 0;
+		for (const file of files) {
+			added += file.added;
+			removed += file.removed;
+		}
+		// Same shape as edit: one file heads the call by path with a bare diff;
+		// several head it as `N files` with one borderless section per file.
+		const single = fileCount === 1 && files.length === 1 ? files[0] : undefined;
+		const changes: NativeChild[] = single
+			? [astEditDiff(single)]
+			: files.map(file => fileDiffSection(file, [astEditDiff(file)], { role: "omp.tool.ast_edit.file" }));
+		// The head names the files, so a single rewrite's pattern moves to a quiet context line.
+		const pattern = args?.ops?.length === 1 ? patternPreview(args.ops[0]?.pat) : undefined;
+		return {
+			tool: {
+				title: "AST Edit",
+				target: single ? displayPath(single.path) : formatCount("file", fileCount),
+				targetKind: single ? "path" : "text",
+				meta: compact([diffStatsMeta(added, removed), formatCount("replacement", totalReplacements)]),
+				badges: details?.applied ? undefined : [{ text: "proposed", tone: "warning" }],
+			},
+			tone: limitReached ? "warning" : undefined,
+			body: compact<NativeChild>([
+				pattern !== undefined &&
+					text([span(pattern, "code")], { lines: 1, truncate: "end", role: "omp.tool.context" }),
+				...(changes.length > 0 ? changes : [noteText(kept.join("\n"))]),
+				parseNote,
+				astEditScopeStats(details),
+			]),
+			preview: { lines: COLLAPSED_CHANGE_LIMIT },
+		};
+	},
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<AstEditRenderArgs, AstEditToolDetails>;