pi-supernova 0.0.4 → 0.0.6

package/render.js

@@ -6,12 +6,12 @@
  * so every width/truncate path here is self-contained and must never trust a host
  * truncate that appends ellipsis after cutting to maxWidth.
  *
- * OMP path uses rounded framedBlock chrome (same as native write/edit). Pi path
- * keeps the muted violet SafeText wash (no side rails).
+ * Pi and OMP share one self-owned result card. The call slot stays empty so the
+ * lifecycle never duplicates; mutating operations include bounded inline diffs.
  */
 
 import { stripVTControlCharacters } from "node:util";
-import { isString, isObject } from "./decode.js";
+import { isString, isObject, isFunction } from "./decode.js";
 import {
 	measureWidth,
 	hardTruncate,
@@ -43,83 +43,18 @@ function fitOutputLines(text, width) {
 	return out.length > 0 ? out : [""];
 }
 
-/**
- * Soft violet / grey-blue wash — same structure as Pi's standard tool Box
- * (padding + background), just purple-tinted instead of green.
- * Tuned for dark themes (tokyo-night and friends).
- */
-export const NOVA_CHROME = {
-	pendingBg: [26, 28, 42], // deep grey-blue
-	successBg: [24, 30, 46], // muted blue-purple
-	errorBg: [40, 26, 34], // muted rose-purple
-};
-
-function bgRgb(rgb, text) {
-	const [r, g, b] = rgb;
-	return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
-}
-
-function chromeBg(tone) {
-	if (tone === "error") return NOVA_CHROME.errorBg;
-	if (tone === "success") return NOVA_CHROME.successBg;
-	return NOVA_CHROME.pendingBg;
-}
-
-/**
- * Paint one row like Pi's Box: 1-col pad + content, washed to full width.
- * No side-rail characters — the background block is the "border".
- * Final visible width is always ≤ `width` (Pi crash contract).
- */
-export function paintNovaRow(content, width, tone = "pending") {
-	const w = Math.max(1, width | 0);
-	const bg = chromeBg(tone);
-	const padX = 1;
-	const inner = Math.max(1, w - padX * 2);
-	const body = clampLine(content, inner);
-	const row = `${" ".repeat(padX)}${body}`;
-	const pad = Math.max(0, w - measureWidth(row));
-	const painted = bgRgb(bg, row + " ".repeat(pad));
-	if (measureWidth(painted) <= w) return painted;
-	return clampLine(stripVTControlCharacters(painted), w);
-}
-
-/**
- * Framed Text for supernova. Uses renderShell: "self" so we own the chrome
- * color (muted purple/grey-blue) instead of the host's green tool panels.
- * Structure matches Pi's standard Box (pad + bg), without side-rail characters.
- */
+/** Compact bounded text; the host supplies the card background and borders. */
 export class SafeText {
 	constructor(text = "") {
 		this.text = text;
-		this.tone = "pending";
-		this.framing = true;
 	}
 	setText(text) {
 		this.text = text;
 	}
-	setTone(tone) {
-		if (tone === "error" || tone === "success" || tone === "pending") this.tone = tone;
-	}
-	setFraming(enabled) {
-		this.framing = !!enabled;
-	}
 	invalidate() {}
 	render(width = 80) {
-		const w = Math.max(1, width | 0);
 		const raw = String(this.text ?? "");
-		if (!raw.trim()) return [];
-
-		if (!this.framing) {
-			return fitOutputLines(raw, w);
-		}
-
-		// Match Pi Box: 1-col horizontal pad, 1-row vertical pad, purple bg wash.
-		const padX = 1;
-		const inner = Math.max(1, w - padX * 2);
-		const bodyLines = fitOutputLines(raw, inner);
-		const empty = paintNovaRow("", w, this.tone);
-		const painted = bodyLines.map((line) => paintNovaRow(line, w, this.tone));
-		return [empty, ...painted, empty];
+		return raw.trim() ? fitOutputLines(raw, Math.max(1, width | 0)) : [];
 	}
 }
 
@@ -127,24 +62,6 @@ export class SafeText {
 export const visibleWidth = measureWidth;
 export const truncateToWidth = hardTruncate;
 
-const ACTION_ICONS = {
-	write: "✎ ",
-	edit: "✎ ",
-	apply_patch: "✎ ",
-	patch: "✎ ",
-	bash: "❯ ",
-	exec: "❯ ",
-	read: "▤ ",
-	surface: "▤ ",
-	search: "⌕ ",
-	grep: "⌕ ",
-	find: "⌕ ",
-	ls: "▤ ",
-	// Avoid double-width emoji (⚡) — measure disagreements with Pi caused 92>91 crashes.
-	speculate: "✶ ",
-	snap: "⌖ ",
-};
-
 export function extractOperationsFromCode(code) {
 	const trimmed = String(code || "").trim();
 	if (!trimmed) return [];
@@ -185,18 +102,20 @@ export function extractOperationsFromCode(code) {
 
 	const namedCalls = [
 		{ regex: /(?:^|[^\w$.])(?:nova\.)?read\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "read", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?write\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "edit", wrap: (p) => p },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?write\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "write", wrap: (p) => p },
 		{ regex: /(?:^|[^\w$.])(?:nova\.)?edit\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "edit", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?patch\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "edit", wrap: (p) => p },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?patch\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "patch", wrap: (p) => p },
 		{
 			regex: /(?:^|[^\w$.])(?:nova\.)?bash\s*\(\s*["'`]([^"'`]+)["'`]/gm,
 			tool: "bash",
 			wrap: (c) => (c.length > 32 ? c.slice(0, 29) + "…" : c),
 		},
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?exec\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "bash", wrap: (c) => c },
-		{ regex: /(?:nova\.)?search\s*\(\s*["'`]([^"'`]+)["'`]/g, tool: "read", wrap: (q) => `"${q}"` },
-		{ regex: /(?:nova\.)?surface\s*\(\s*["'`]([^"'`]+)["'`]/g, tool: "read", wrap: (p) => p },
-		{ regex: /(?:nova\.)?snap\s*\(\s*["'`]([^"'`]+)["'`]/g, tool: "read", wrap: (q) => `"${q}"` },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?exec\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "exec", wrap: (c) => c },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?search\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "search", wrap: (q) => `"${q}"` },
+		{ regex: /(?:^|[^\w$.])nova\.describe\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "describe", wrap: (name) => name },
+		{ regex: /(?:^|[^\w$.])nova\.has\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "has", wrap: (name) => name },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?surface\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "surface", wrap: (p) => p },
+		{ regex: /(?:^|[^\w$.])(?:nova\.)?snap\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "snap", wrap: (q) => `"${q}"` },
 	];
 	for (const item of namedCalls) {
 		while ((match = item.regex.exec(trimmed)) !== null) {
@@ -211,77 +130,70 @@ export function extractOperationsFromCode(code) {
 	return ops;
 }
 
-export function renderDiffBox(diff, theme, width = 60) {
-	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return "";
-
-	const w = Math.max(20, width | 0);
-	const cleanPath = String(diff.path || "").replace(/\\/g, "/");
-	const baseName = cleanPath.split("/").pop() || cleanPath;
-	const opLabel = diff.op === "edit" ? "Edit" : diff.op === "write" ? "Write" : "Patch";
-
-	// Stats BEFORE path so +N/-N survive narrow-terminal truncation (prior test/crash footgun).
-	const stats =
-		theme.fg("dim", "⟨") +
-		theme.fg("toolDiffAdded", `+${diff.added}`) +
-		theme.fg("dim", "/") +
-		theme.fg("toolDiffRemoved", `-${diff.removed}`) +
-		theme.fg("dim", "⟩");
-	// Do not clamp here — SafeText.render(terminalWidth) is the single choke point.
-	// Pre-clamping with a guessed width ate filenames under mock/ANSI-marker themes.
-	const header =
-		theme.fg("accent", "✎ ") +
-		theme.fg("toolTitle", theme.bold(`${opLabel} `)) +
-		stats +
-		" " +
-		theme.fg("muted", baseName);
-
-	const divWidth = Math.min(w, Math.max(20, Math.min(70, w)));
-	const divider = theme.fg("borderMuted", "─".repeat(divWidth));
-
-	const maxShown = 8;
-	const shownLines = diff.lines.slice(0, maxShown);
+function formatDiffRows(diff, theme, maxShown = 6) {
+	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return [];
 	const body = [];
-
-	for (const item of shownLines) {
+	for (const item of diff.lines.slice(0, maxShown)) {
 		const num = item.lineNum || 0;
-		let row;
 		if (item.type === "remove") {
 			const gut = theme.fg("toolDiffRemoved", `-${num}`.padStart(5));
-			const sep = theme.fg("borderMuted", " │ ");
-			const txt = theme.fg("toolDiffRemoved", `- ${item.text}`);
-			row = `${gut}${sep}${txt}`;
+			body.push(`${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffRemoved", `- ${cleanInlineText(item.text)}`)}`);
 		} else if (item.type === "add") {
 			const gut = theme.fg("toolDiffAdded", `+${num}`.padStart(5));
-			const sep = theme.fg("borderMuted", " │ ");
-			const txt = theme.fg("toolDiffAdded", `+ ${item.text}`);
-			row = `${gut}${sep}${txt}`;
+			body.push(`${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffAdded", `+ ${cleanInlineText(item.text)}`)}`);
 		} else {
 			const gut = theme.fg("dim", ` ${num}`.padStart(5));
-			const sep = theme.fg("borderMuted", " │ ");
-			const txt = theme.fg("toolDiffContext", `  ${item.text}`);
-			row = `${gut}${sep}${txt}`;
+			body.push(`${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffContext", `  ${cleanInlineText(item.text)}`)}`);
 		}
-		body.push(row);
 	}
+	const displayLineCount = Number.isInteger(diff.displayLineCount) ? diff.displayLineCount : diff.lines.length;
+	if (displayLineCount > maxShown) {
+		body.push(theme.fg("dim", `      │ … ${displayLineCount - maxShown} more lines`));
+	}
+	return body;
+}
+
+export function renderDiffBox(diff, theme, width = 60, maxShown = 6) {
+	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return "";
+	const w = Math.max(20, width | 0);
+	const cleanPath = String(diff.path || "").replace(/\\/g, "/");
+	const baseName = cleanPath.split("/").pop() || cleanPath;
+	const opLabel = diff.op === "edit" ? "Edit" : diff.op === "write" ? "Write" : "Patch";
+	const stats = theme.fg("dim", "⟨") + theme.fg("toolDiffAdded", `+${diff.added}`) + theme.fg("dim", "/") + theme.fg("toolDiffRemoved", `-${diff.removed}`) + theme.fg("dim", "⟩");
+	const header = theme.fg("accent", "✎ ") + theme.fg("toolTitle", theme.bold(`${opLabel} `)) + stats + " " + theme.fg("muted", baseName);
+	const divider = theme.fg("borderMuted", "─".repeat(Math.min(70, w)));
+	return `${header}\n${divider}\n${formatDiffRows(diff, theme, maxShown).join("\n")}\n${divider}`;
+}
 
-	if (diff.lines.length > maxShown) {
-		const remaining = diff.lines.length - maxShown;
-		body.push(theme.fg("dim", `      │ … ${remaining} more lines`));
+function stripUnsafeControls(value) {
+	let clean = "";
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		const isC0 = codePoint <= 0x08 || codePoint === 0x0b || codePoint === 0x0c || (codePoint >= 0x0e && codePoint <= 0x1f);
+		const isDeleteOrC1 = codePoint >= 0x7f && codePoint <= 0x9f;
+		if (!isC0 && !isDeleteOrC1) clean += character;
 	}
+	return clean;
+}
+
+function cleanBlockText(value) {
+	const normalized = stripVTControlCharacters(String(value ?? "")).replace(/\r\n?/g, "\n");
+	return stripUnsafeControls(normalized).replace(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "");
+}
 
-	return `${header}\n${divider}\n${body.join("\n")}\n${divider}`;
+function cleanInlineText(value) {
+	return cleanBlockText(value).replace(/\s*\n\s*/g, " ").trim();
 }
 
-function displayOperation(tool, target) {
-	if (["write", "edit", "apply_patch", "patch"].includes(tool)) return { tool: "edit", target };
-	if (["bash", "exec"].includes(tool)) return { tool: "bash", target };
-	if (["read", "surface", "snap", "search", "grep", "find", "ls"].includes(tool))
-		return { tool: "read", target };
-	return null;
+function displayOperation(tool, target, diff, ok) {
+	const rawName = cleanInlineText(tool);
+	if (!rawName) return null;
+	const normalized = rawName === "apply_patch" ? "patch" : rawName;
+	return { tool: normalized, target, diff, ok };
 }
 
 function formatOpTarget(raw, tool) {
-	const text = String(raw ?? "");
+	const text = cleanInlineText(raw);
 	if (!text) return "";
 	if (tool === "bash") {
 		// Keep commands readable; wrap handles the rest at render time.
@@ -292,7 +204,7 @@ function formatOpTarget(raw, tool) {
 }
 
 function isTheme(value) {
-	return !!value && typeof value === "object" && typeof value.fg === "function";
+	return isObject(value) && isFunction(value.fg);
 }
 
 /**
@@ -302,13 +214,13 @@ function isTheme(value) {
  */
 export function normalizeCallRenderArgs(a, b, c) {
 	if (isTheme(b)) {
-		const context = c && typeof c === "object" ? c : {};
-		if (!context.state || typeof context.state !== "object") context.state = {};
+		const context = isObject(c) ? c : {};
+		if (!isObject(context.state)) context.state = {};
 		return { args: a, theme: b, context, host: "pi" };
 	}
 	if (isTheme(c)) {
-		const options = b && typeof b === "object" ? b : {};
-		if (!options.state || typeof options.state !== "object") options.state = {};
+		const options = isObject(b) ? b : {};
+		if (!isObject(options.state)) options.state = {};
 		const context = {
 			...options,
 			state: options.state,
@@ -329,21 +241,19 @@ export function normalizeCallRenderArgs(a, b, c) {
  *   Pi:  (result, {expanded,isPartial}, theme, context)
  *   OMP: (result, {expanded,isPartial}, theme, args)  — 4th is args, not context
  *
- * Call shapes share the first three positions, so host is inferred from the 4th
- * arg / whether the OMP tui framedBlock import resolved.
+ * Call shapes share the first three positions, so host is inferred from the
+ * fourth argument's context-versus-args shape.
  */
 function detectResultHost(options, ctxOrArgs) {
 	if (isTheme(options)) return "pi";
 	if (
-		ctxOrArgs &&
-		typeof ctxOrArgs === "object" &&
+		isObject(ctxOrArgs) &&
 		("lastComponent" in ctxOrArgs || "invalidate" in ctxOrArgs)
 	) {
 		return "pi";
 	}
 	if (
-		ctxOrArgs &&
-		typeof ctxOrArgs === "object" &&
+		isObject(ctxOrArgs) &&
 		("code" in ctxOrArgs || "timeoutMs" in ctxOrArgs)
 	) {
 		return "omp";
@@ -353,39 +263,40 @@ function detectResultHost(options, ctxOrArgs) {
 
 export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
 	if (isTheme(themeOrCtx)) {
-		const opts = options && typeof options === "object" ? options : {};
+		const opts = isObject(options) ? options : {};
 		let context;
 		if (
-			ctxOrArgs &&
-			typeof ctxOrArgs === "object" &&
+			isObject(ctxOrArgs) &&
 			!isTheme(ctxOrArgs) &&
 			("lastComponent" in ctxOrArgs || "state" in ctxOrArgs || "invalidate" in ctxOrArgs)
 		) {
 			context = ctxOrArgs;
 		} else {
-			context = { ...(opts.state ? { state: opts.state } : {}), lastComponent: opts.lastComponent };
+			context = { state: opts.state, lastComponent: opts.lastComponent };
 		}
-		if (!context.state || typeof context.state !== "object") context.state = {};
+		if (!isObject(context.state)) context.state = {};
 		return {
 			result,
 			expanded: !!opts.expanded,
 			isPartial: !!opts.isPartial,
 			theme: themeOrCtx,
 			context,
+			args: ctxOrArgs?.code ? ctxOrArgs : context.args,
 			host: detectResultHost(options, ctxOrArgs),
 			options: opts,
 		};
 	}
 	// Extremely defensive: (result, theme, context) oddball
 	if (isTheme(options)) {
-		const context = themeOrCtx && typeof themeOrCtx === "object" ? themeOrCtx : {};
-		if (!context.state || typeof context.state !== "object") context.state = {};
+		const context = isObject(themeOrCtx) ? themeOrCtx : {};
+		if (!isObject(context.state)) context.state = {};
 		return {
 			result,
 			expanded: !!context.expanded,
 			isPartial: !!context.isPartial,
 			theme: options,
 			context,
+			args: context.args,
 			host: "pi",
 			options: {},
 		};
@@ -393,225 +304,157 @@ export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs
 	throw new Error("supernova renderResult: theme missing (expected Pi or OMP signature)");
 }
 
-function collectCallOps(args, context) {
-	const stateTrace = context?.state?.trace;
-	if (Array.isArray(stateTrace) && stateTrace.length > 0) {
-		return stateTrace
-			.map((item) => {
-				const tool = item?.name || "tool";
-				let target = "";
-				if (item?.args?.path) target = String(item.args.path);
-				else if (item?.args?.command) target = String(item.args.command);
-				else if (item?.args?.pattern) target = String(item.args.pattern);
-				return displayOperation(tool, target);
-			})
-			.filter(Boolean);
-	}
-	return extractOperationsFromCode(args?.code)
-		.map((op) => displayOperation(op.tool, op.target))
-		.filter(Boolean);
-}
-
-function formatElapsed(state) {
-	if (state?.wallMs != null) return `${state.wallMs}ms`;
-	if (state?.startedAt != null) {
-		const elapsed = Math.round(performance.now() - state.startedAt);
-		// Suppress sub-100ms noise on the pending head (matches quiet Write/Edit calls).
-		if (elapsed < 100) return "";
-		return elapsed >= 1000 ? `${(elapsed / 1000).toFixed(1)}s` : `${elapsed}ms`;
-	}
+function operationTarget(item) {
+	const args = item?.args || {};
+	const name = item?.name;
+	if (name === "snap") {
+		const query = args.query ? `"${args.query}"` : "";
+		return args.path ? `${query} → ${args.path}` : query;
+	}
+	if (name === "search") return args.query ? `"${args.query}"` : "";
+	if (args.path) return String(args.path);
+	if (item?.diff?.path) return String(item.diff.path);
+	if (args.target && isString(args.target)) return args.target;
+	if (args.command) return String(args.command);
+	if (args.pattern) return String(args.pattern);
+	if (args.query) return String(args.query);
 	return "";
 }
 
-function tickCallTimer(context) {
-	const state = context?.state;
-	if (state && state.startedAt == null) state.startedAt = performance.now();
-	if (state && context?.executionStarted && state.wallMs == null && state.timer == null) {
-		state.timer = setTimeout(() => {
-			state.timer = null;
-			context.invalidate?.();
-		}, 100);
-	}
-}
-
-function formatOpBodyLine(theme, op) {
-	const icon = ACTION_ICONS[op.tool] || "✦ ";
-	const bullet = theme.fg("accent", icon);
-	const toolName = theme.fg("syntaxFunction", op.tool.padEnd(4, " "));
-	const rawTarget = formatOpTarget(op.target, op.tool);
-	const target = rawTarget ? " " + theme.fg("muted", rawTarget) : "";
-	return `${bullet}${toolName}${target}`;
-}
-
-function shouldUseOmpFrame(host) {
-	return host === "omp";
-}
-
-/**
- * OMP write/edit look: rounded framedBlock + status-line header.
- * Pending call has no hourglass on the head row (same as native Write/Edit).
- */
-function renderOmpCallCard(theme, { ops, timeStr, expanded, code }) {
-	const opSummary =
-		ops.length === 0
-			? "composing"
-			: ops.map((op) => op.tool).join(theme.sep?.dot ? ` ${theme.sep.dot} ` : " · ");
-	const description = timeStr ? `${opSummary} · ${timeStr}` : opSummary;
-	// No pending icon on the framed head row — matches native Write/Edit.
-	const header = novaStatusLine(theme, {
-		title: "nova",
-		description,
-	});
-	return novaFramedBlock(theme, (width) => {
-		const bodyLines = ops.map((op) => formatOpBodyLine(theme, op));
-		if (expanded && code) {
-			bodyLines.push(theme.fg("dim", "── source ──"));
-			for (const line of String(code).trim().split("\n")) {
-				bodyLines.push(theme.fg("toolOutput", line));
-			}
-		}
-		return {
-			header,
-			sections: bodyLines.length > 0 ? [{ lines: bodyLines }] : [],
-			state: "pending",
-			borderColor: "borderMuted",
-			width,
-		};
-	});
-}
-
-function renderOmpResultCard(theme, { isErr, payload, expanded, bodyText, isPartial, spinnerFrame }) {
-	if (isErr) {
-		const errLines = [];
-		if (payload?.error) errLines.push(theme.fg("error", String(payload.error)));
-		if (expanded && payload?.logs?.length) {
-			errLines.push(theme.fg("dim", "── logs ──"));
-			for (const log of payload.logs) errLines.push(theme.fg("dim", String(log)));
+function normalizeTraceDiff(item) {
+	const diff = item?.diff;
+	if (isObject(diff)) return diff;
+	if (!isString(diff) || !diff.trim()) return undefined;
+	const lines = [];
+	let added = 0;
+	let removed = 0;
+	for (const rawLine of cleanBlockText(diff).split("\n")) {
+		let match = /^([+-])\s*(\d+)\s?(.*)$/.exec(rawLine);
+		if (match) {
+			const type = match[1] === "+" ? "add" : "remove";
+			if (type === "add") added += 1;
+			else removed += 1;
+			lines.push({ type, lineNum: Number(match[2]), text: match[3] });
+			continue;
 		}
-		const header = novaStatusLine(theme, {
-			icon: "error",
-			title: "nova",
-			description: payload?.error ? String(payload.error).split("\n")[0] : "error",
-		});
-		return novaFramedBlock(theme, (width) => ({
-			header,
-			sections: errLines.length > 0 ? [{ lines: errLines }] : [],
-			state: "error",
-			borderColor: "error",
-			width,
-		}));
+		match = /^\s+(\d+)\s?(.*)$/.exec(rawLine);
+		if (match) lines.push({ type: "context", lineNum: Number(match[1]), text: match[2] });
 	}
+	if (lines.length === 0) return undefined;
+	return { path: item?.args?.path || "", op: item?.name, added, removed, lines };
+}
 
-	const wall = payload?.wallMs != null ? `${payload.wallMs}ms` : "";
-	const header = novaStatusLine(theme, {
-		icon: isPartial ? "running" : undefined,
-		spinnerFrame,
-		title: "nova",
-		description: wall || undefined,
-	});
-	const bodyLines = String(bodyText || "").split("\n");
-	while (bodyLines.length > 0 && bodyLines[0].trim() === "") bodyLines.shift();
-	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1].trim() === "") bodyLines.pop();
-	return novaFramedBlock(theme, (width) => ({
-		header,
-		sections: bodyLines.length > 0 ? [{ lines: bodyLines }] : [],
-		state: isPartial ? "pending" : "success",
-		borderColor: "borderMuted",
-		width,
-	}));
+function operationsFromTrace(trace) {
+	if (!Array.isArray(trace)) return [];
+	return trace
+		.map((item) => displayOperation(item?.name || "tool", operationTarget(item), normalizeTraceDiff(item), item?.ok))
+		.filter(Boolean);
 }
 
 export function renderSupernovaCall(a, b, c) {
-	const { args, theme, context, options, host } = normalizeCallRenderArgs(a, b, c);
-	tickCallTimer(context);
-	const ops = collectCallOps(args, context);
-	const timeStr = formatElapsed(context?.state);
-
-	if (shouldUseOmpFrame(host)) {
-		return renderOmpCallCard(theme, {
-			ops,
-			timeStr,
-			expanded: !!context?.expanded,
-			code: args?.code,
-		});
-	}
-
+	const { context, options } = normalizeCallRenderArgs(a, b, c);
 	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
 	if (options) options.lastComponent = comp;
 	else if (context) context.lastComponent = comp;
+	comp.setText("");
+	return comp;
+}
 
-	// Compact aesthetic — never dump raw JSON args (the stock tool fallback).
-	let out = theme.fg("toolTitle", theme.bold("nova"));
-	if (timeStr) {
-		out += " " + theme.fg("dim", `· ${timeStr}`);
-	}
-
-	if (ops.length === 0) {
-		out += " " + theme.fg("dim", "· composing");
-	} else {
-		for (const op of ops) {
-			out += `\n  ${formatOpBodyLine(theme, op)}`;
-		}
-	}
+function formatDiffStats(theme, diff) {
+	if (!diff || !isObject(diff)) return "";
+	return " " + theme.fg("toolDiffAdded", `+${diff.added || 0}`) + theme.fg("dim", "/") + theme.fg("toolDiffRemoved", `-${diff.removed || 0}`);
+}
 
-	if (context?.expanded && args?.code) {
-		out += "\n" + theme.fg("dim", "── source ──");
-		out += "\n" + theme.fg("toolOutput", String(args.code).trim());
-	}
+function formatResultOperation(theme, op, isPartial, isError) {
+	const marker = op.ok === false
+		? theme.fg("error", "× ")
+		: isPartial && op.ok !== true
+			? theme.fg("dim", "· ")
+			: isError && op.ok !== true
+				? theme.fg("error", "× ")
+				: theme.fg("success", "✓ ");
+	const tool = theme.fg("syntaxFunction", op.tool.padEnd(7, " "));
+	const targetText = formatOpTarget(op.target, op.tool);
+	const target = targetText ? theme.fg("muted", targetText) : theme.fg("dim", "done");
+	const stats = formatDiffStats(theme, op.diff);
+	return stats ? `${marker}${tool}${stats} ${target}` : `${marker}${tool} ${target}`;
+}
 
-	if (context?.isError) comp.setTone("error");
-	else if (context?.isPartial) comp.setTone("pending");
-	else comp.setTone("success");
-	comp.setFraming(true);
-	comp.setText(out);
-	return comp;
+function boundedResult(value) {
+	let text;
+	try {
+		text = isString(value) ? value : JSON.stringify(value, null, 2);
+	} catch {
+		text = String(value);
+	}
+	const lines = cleanBlockText(text).split("\n");
+	const clipped = lines.slice(0, 24).join("\n");
+	const suffix = lines.length > 24 ? `\n… ${lines.length - 24} more lines` : "";
+	return (clipped + suffix).slice(0, 4000);
 }
 
-function buildResultBody(theme, { payload, context, expanded }) {
+function buildResultBody(theme, { payload, context, args, expanded, isPartial, isError }) {
 	let out = "";
 	const trace = payload?.trace || context?.state?.trace || [];
-	const diffs = trace.filter((t) => t?.diff && isObject(t.diff)).map((t) => t.diff);
-
-	if (diffs.length > 0) {
-		const maxDiffsShown = expanded ? diffs.length : 2;
-		const shownDiffs = diffs.slice(0, maxDiffsShown);
-		for (const diff of shownDiffs) {
-			const box = renderDiffBox(diff, theme, 120);
-			if (box) out += (out ? "\n\n" : "") + box;
-		}
-		if (!expanded && diffs.length > maxDiffsShown) {
-			const remaining = diffs.length - maxDiffsShown;
-			out +=
-				"\n\n" +
-				theme.fg(
-					"dim",
-					`… ${remaining} more file edit${remaining === 1 ? "" : "s"} (press Enter to expand)`,
-				);
+	const tracedOps = operationsFromTrace(trace);
+	const ops = tracedOps.length > 0
+		? tracedOps
+		: extractOperationsFromCode(args?.code).map((op) => displayOperation(op.tool, op.target)).filter(Boolean);
+	const maxOps = expanded ? 12 : 8;
+	const maxDiffLines = expanded ? 24 : 8;
+	const visibleOps = ops.slice(0, maxOps);
+	for (const [index, op] of visibleOps.entries()) {
+		if (index > 0) out += "\n│";
+		const isLast = index === visibleOps.length - 1 && ops.length <= maxOps;
+		const branch = isLast ? "└─" : "├─";
+		out += (out ? "\n" : "") + `${branch} ${formatResultOperation(theme, op, isPartial, isError)}`;
+		if (op.diff && isObject(op.diff)) {
+			const continuation = isLast ? "   " : "│  ";
+			for (const row of formatDiffRows(op.diff, theme, maxDiffLines)) out += `\n${continuation}${row}`;
 		}
 	}
+	if (ops.length > maxOps) out += `\n│\n└─ ${theme.fg("dim", `… ${ops.length - maxOps} more calls`)}`;
 
 	if (expanded) {
-		const resVal = payload?.result;
-		if (resVal !== undefined) {
-			let formatted;
-			try {
-				formatted = isString(resVal) ? resVal : JSON.stringify(resVal, null, 2);
-			} catch {
-				formatted = String(resVal);
-			}
+		if (payload?.result !== undefined) {
 			out += (out ? "\n" : "") + theme.fg("dim", "── result ──");
-			out += "\n" + theme.fg("toolOutput", formatted);
+			out += "\n" + theme.fg("toolOutput", boundedResult(payload.result));
 		}
-		if (payload?.logs?.length) {
+		if (!isError && payload?.logs?.length) {
 			out += (out ? "\n" : "") + theme.fg("dim", "── logs ──");
-			for (const log of payload.logs) out += `\n  ${theme.fg("dim", String(log))}`;
+			for (const log of payload.logs.slice(0, 24)) out += `\n  ${theme.fg("dim", cleanBlockText(log))}`;
 		}
 	}
-	return out;
+	return { body: out, opCount: ops.length };
+}
+
+class UnifiedResultCard {
+	set(theme, model) {
+		this.theme = theme;
+		this.model = model;
+	}
+	invalidate() {}
+	render(width = 80) {
+		const { theme, model } = this;
+		if (!theme || !model) return [];
+		const header = novaStatusLine(theme, {
+			icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
+			title: "nova",
+			description: model.description,
+		});
+		const lines = model.body ? model.body.split("\n") : [];
+		return novaFramedBlock(theme, (frameWidth) => ({
+			header,
+			sections: lines.length > 0 ? [{ lines }] : [],
+			state: model.isError ? "error" : model.isPartial ? "pending" : "success",
+			borderColor: model.isError ? "error" : "borderMuted",
+			width: frameWidth,
+		})).render(width);
+	}
 }
 
 export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextArg) {
-	const { result, expanded, isPartial, theme, context, options, host } = normalizeResultRenderArgs(
+	const { result, expanded, isPartial, theme, context, args, options, host } = normalizeResultRenderArgs(
 		resultArg,
 		optionsArg,
 		themeArg,
@@ -620,102 +463,33 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 
 	const payload = result?.details;
 	if (context?.state && payload) {
-		let changed = false;
 		if (Array.isArray(payload.trace) && context.state.trace !== payload.trace) {
 			context.state.trace = payload.trace;
-			changed = true;
 		}
 		if (payload.wallMs != null && context.state.wallMs !== payload.wallMs) {
 			context.state.wallMs = payload.wallMs;
-			changed = true;
-		}
-		if (context.state.timer != null && !isPartial) {
-			clearTimeout(context.state.timer);
-			context.state.timer = null;
 		}
-		if (changed) context.invalidate?.();
 	}
 
 	const isErr = result?.isError || payload?.ok === false;
-	const useOmp = shouldUseOmpFrame(host);
-
-	if (useOmp) {
-		if (isPartial && !isErr) {
-			// Streaming partials stay quiet until body content exists — same as Pi.
-			const partialBody = buildResultBody(theme, { payload, context, expanded });
-			if (!partialBody.trim()) {
-				return {
-					render: () => [],
-					invalidate() {},
-				};
-			}
-			return renderOmpResultCard(theme, {
-				isErr: false,
-				payload,
-				expanded,
-				bodyText: partialBody,
-				isPartial: true,
-				spinnerFrame: options?.spinnerFrame,
-			});
-		}
-		if (isErr) {
-			return renderOmpResultCard(theme, {
-				isErr: true,
-				payload,
-				expanded,
-				bodyText: "",
-				isPartial: false,
-				spinnerFrame: options?.spinnerFrame,
-			});
-		}
-		const out = buildResultBody(theme, { payload, context, expanded });
-		if (!out.trim()) {
-			return {
-				render: () => [],
-				invalidate() {},
-			};
-		}
-		return renderOmpResultCard(theme, {
-			isErr: false,
-			payload,
-			expanded,
-			bodyText: out,
-			isPartial: false,
-			spinnerFrame: options?.spinnerFrame,
-		});
-	}
-
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
-	if (options) options.lastComponent = comp;
-	else if (context) context.lastComponent = comp;
-
-	if (isPartial) {
-		comp.setText("");
-		return comp;
-	}
+	const view = buildResultBody(theme, { payload, context, args, expanded, isPartial, isError: isErr });
 
+	let body = view.body;
 	if (isErr) {
-		let out = theme.fg("error", "✗ error");
-		if (payload?.error) {
-			out += `\n  ${theme.fg("error", String(payload.error))}`;
-		}
+		body += (body ? "\n" : "") + theme.fg("error", payload?.error ? cleanBlockText(payload.error) : "error");
 		if (expanded && payload?.logs?.length) {
-			out += `\n${theme.fg("dim", "── logs ──")}`;
-			for (const log of payload.logs) out += `\n  ${theme.fg("dim", String(log))}`;
+			body += `\n${theme.fg("dim", "── logs ──")}`;
+			for (const log of payload.logs.slice(0, 24)) body += `\n${theme.fg("dim", cleanBlockText(log))}`;
 		}
-		comp.setTone("error");
-		comp.setFraming(true);
-		comp.setText(out);
-		return comp;
-	}
-
-	const out = buildResultBody(theme, { payload, context, expanded });
-	if (!out.trim()) {
-		comp.setText("");
-		return comp;
 	}
-	comp.setTone("success");
-	comp.setFraming(true);
-	comp.setText(out);
+	const wall = payload?.wallMs != null ? `${payload.wallMs}ms` : "";
+	const calls = view.opCount > 0 ? `${view.opCount} call${view.opCount === 1 ? "" : "s"}` : "";
+	const status = isErr ? "failed" : isPartial ? "running" : calls ? "" : "complete";
+	const description = [calls, status, wall].filter(Boolean).join(" · ");
+	const previous = host === "omp" ? options?.lastComponent : context?.lastComponent;
+	const comp = previous instanceof UnifiedResultCard ? previous : new UnifiedResultCard();
+	if (host === "omp" && options) options.lastComponent = comp;
+	else if (context) context.lastComponent = comp;
+	comp.set(theme, { body, description, isError: isErr, isPartial });
 	return comp;
 }