pi-supernova 0.0.5 → 0.0.6

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [0.0.6] - 2026-09-03
+
+### Changed
+
+- Pi and OMP now share one self-owned framed result card. The hidden call slot prevents duplicate lifecycle cards, and connected rows preserve visual separation between calls.
+
+### Fixed
+
+- Edit, write, and patch calls now show bounded line-numbered removed/added hunks while collapsed, with a larger budget when expanded; captured host executors propagate their native diff metadata into the same UI.
+
+- Direct `nova.snap()` and `nova.surface()` helpers now return structured objects instead of host result envelopes.
+- Package metadata now matches the official Pi package contract: every `files` entry exists, and only the actually imported `typebox` host dependency remains declared as a peer.
+
 ## [0.0.5] - 2026-09-03
 
 ### Fixed

package/README.md

@@ -48,17 +48,19 @@ async () => {
 
 Globals: `nova` / `tools`, `parallel`, `pipeline`, `console`, plus shorthand `read`, `write`, `edit`, `patch`, `surface`, `snap`, `bash`, and `exec`.
 
-Terminal card (muted violet / grey-blue — not a raw JSON args dump):
+Unified Pi/OMP card with bounded mutation diffs visible while collapsed:
 
 ```text
-╭─── nova: 3 calls · 84ms ───────────────────────╮
-│ ✓ read    packages/pi-supernova/host-bridge.js │
-│ ✓ edit    packages/pi-supernova/diff.js +2/-1  │
-│ ✓ snap    "render lifecycle" → packages        │
-╰────────────────────────────────────────────────╯
+╭─── nova: 2 calls · 84ms ───────────────────────────────╮
+│ ├─ ✓ read    packages/pi-supernova/host-bridge.js       │
+│ │                                                       │
+│ └─ ✓ edit   +1/-1 packages/pi-supernova/diff.js         │
+│       -143 │ - const oldValue = before;                 │
+│       +143 │ + const newValue = after;                  │
+╰─────────────────────────────────────────────────────────╯
 ```
 
-Collapsed cards keep this command ledger visible. Press Enter to inspect bounded diff hunks, logs, and the returned value.
+Collapsed cards show bounded edit/write/patch hunks immediately. Press Enter for a larger hunk budget, logs, and the returned value.
 
 ---
 

package/diff.js

@@ -2,12 +2,12 @@
 import { isString } from "./decode.js";
 
 export function buildEditDiff(filePath, originalText, oldText, newText) {
-  const fileLines = isString(originalText) ? originalText.split("\n") : [];
+  const fileLines = contentLines(originalText);
   const idx = isString(originalText) ? originalText.indexOf(oldText) : -1;
 
   const startLine = idx >= 0 ? originalText.slice(0, idx).split("\n").length : 1;
-  const oldLines = oldText.split("\n");
-  const newLines = newText.split("\n");
+  const oldLines = contentLines(oldText);
+  const newLines = contentLines(newText);
 
   const lines = [];
   if (startLine > 1 && fileLines.length >= startLine - 1) {
@@ -21,9 +21,9 @@ export function buildEditDiff(filePath, originalText, oldText, newText) {
     lines.push({ type: "add", lineNum: startLine + i, text: newLines[i] });
   }
 
-  const afterLine = startLine + oldLines.length;
-  if (fileLines.length >= afterLine) {
-    lines.push({ type: "context", lineNum: afterLine, text: fileLines[afterLine - 1] });
+  const afterSourceLine = startLine + oldLines.length;
+  if (fileLines.length >= afterSourceLine) {
+    lines.push({ type: "context", lineNum: startLine + newLines.length, text: fileLines[afterSourceLine - 1] });
   }
 
   return {
@@ -61,61 +61,53 @@ export function buildPatchDiff(filePath, patchText) {
   const lines = [];
   let added = 0;
   let removed = 0;
-  let currentLineNum = 1;
+  let oldLineNum = 1;
+  let newLineNum = 1;
   let inHunk = false;
 
-  for (const pLine of patchLines) {
-    const headerMatch = /^@@\s+-(\d+)/.exec(pLine);
+  for (const patchLine of patchLines) {
+    const headerMatch = /^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)/.exec(patchLine);
     if (headerMatch) {
-      currentLineNum = parseInt(headerMatch[1], 10);
+      oldLineNum = Number(headerMatch[1]);
+      newLineNum = Number(headerMatch[2]);
       inHunk = true;
       continue;
     }
-    if (!inHunk || pLine.startsWith("\\")) continue;
-    if (pLine.startsWith("-")) {
+    if (!inHunk || patchLine.startsWith("\\")) continue;
+    if (patchLine.startsWith("-")) {
       removed += 1;
-      lines.push({ type: "remove", lineNum: currentLineNum, text: pLine.slice(1) });
-      currentLineNum += 1;
-    } else if (pLine.startsWith("+")) {
+      lines.push({ type: "remove", lineNum: oldLineNum, text: patchLine.slice(1) });
+      oldLineNum += 1;
+    } else if (patchLine.startsWith("+")) {
       added += 1;
-      lines.push({ type: "add", lineNum: currentLineNum, text: pLine.slice(1) });
-    } else if (pLine.startsWith(" ")) {
-      lines.push({ type: "context", lineNum: currentLineNum, text: pLine.slice(1) });
-      currentLineNum += 1;
+      lines.push({ type: "add", lineNum: newLineNum, text: patchLine.slice(1) });
+      newLineNum += 1;
+    } else if (patchLine.startsWith(" ")) {
+      lines.push({ type: "context", lineNum: newLineNum, text: patchLine.slice(1) });
+      oldLineNum += 1;
+      newLineNum += 1;
     }
   }
 
-  return {
-    path: filePath,
-    op: "apply_patch",
-    added,
-    removed,
-    lines,
-  };
+  return { path: filePath, op: "apply_patch", added, removed, lines };
 }
 
-export function buildWriteDiff(filePath, previousText, newText) {
-  const newLines = isString(newText) ? newText.split("\n") : [];
-  const oldLines = isString(previousText) ? previousText.split("\n") : [];
-
-  if (oldLines.length === 0 || (oldLines.length === 1 && oldLines[0] === "")) {
-    const sampleCount = Math.min(newLines.length, 6);
-    const lines = [];
-    for (let i = 0; i < sampleCount; i++) {
-      lines.push({ type: "add", lineNum: i + 1, text: newLines[i] });
-    }
-    return {
-      path: filePath,
-      op: "write",
-      added: newLines.length,
-      removed: 0,
-      lines,
-    };
-  }
+function contentLines(text) {
+  if (!isString(text) || text.length === 0) return [];
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
 
-  const sampleCount = Math.min(newLines.length, 6);
+export function buildWriteDiff(filePath, previousText, newText) {
+  const newLines = contentLines(newText);
+  const oldLines = contentLines(previousText);
+  const maxStoredLines = 64;
   const lines = [];
-  for (let i = 0; i < sampleCount; i++) {
+  for (let i = 0; i < oldLines.length && lines.length < maxStoredLines; i++) {
+    lines.push({ type: "remove", lineNum: i + 1, text: oldLines[i] });
+  }
+  for (let i = 0; i < newLines.length && lines.length < maxStoredLines; i++) {
     lines.push({ type: "add", lineNum: i + 1, text: newLines[i] });
   }
   return {
@@ -123,6 +115,7 @@ export function buildWriteDiff(filePath, previousText, newText) {
     op: "write",
     added: newLines.length,
     removed: oldLines.length,
+    displayLineCount: oldLines.length + newLines.length,
     lines,
   };
 }

package/host-bridge.js

@@ -3,7 +3,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
 import { packageHostResult } from "./bottleneck.js";
-import { isString, isNumber, isFunction } from "./decode.js";
+import { isString, isNumber, isFunction, isObject } from "./decode.js";
 import { isMutatingTool, runParallelWave } from "./parallel.js";
 import { extractStructuralSurface } from "./surface.js";
 import { buildEditDiff, buildMultiEditDiff, buildPatchDiff, buildWriteDiff } from "./diff.js";
@@ -740,6 +740,18 @@ export function createHostBridge({ pi, config, getCwd }) {
     vfs.clear();
   }
 
+  function resultDiff(response) {
+    let details = response?.details;
+    if (isString(details)) {
+      try {
+        details = JSON.parse(details);
+      } catch {
+        return undefined;
+      }
+    }
+    return isObject(details) ? details.diff : undefined;
+  }
+
   function notifyCall(record) {
     if (!callListener) return;
     try {
@@ -766,13 +778,27 @@ export function createHostBridge({ pi, config, getCwd }) {
 
     const record = { name, args: args || {}, time: Date.now() };
     trace.push(record);
+    notifyCall(record);
 
     try {
       const exec = executors.get(name);
       if (exec) {
+        let fallbackDiff;
+        if (name === "write" && isString(args?.path) && isString(args?.content)) {
+          const target = await resolveWorkspacePath(getCwd(), args.path, "write", false);
+          let previous = "";
+          try {
+            previous = await vfs.read(target);
+          } catch (error) {
+            if (error?.code !== "ENOENT") throw error;
+          }
+          fallbackDiff = buildWriteDiff(target, previous, args.content);
+        }
         if (isMutatingTool(name, config)) await vfs.prepareExternalMutation(name);
         const res = await exec(`supernova:${name}:${callCount}`, args || {}, activeSignal, undefined, activeCtx);
+        const diff = resultDiff(res) || fallbackDiff;
         record.ok = res?.isError !== true && res?.details?.ok !== false;
+        if (diff && record.ok) record.diff = diff;
         notifyCall(record);
         return res;
       }
@@ -780,8 +806,9 @@ export function createHostBridge({ pi, config, getCwd }) {
       const native = natives[name];
       if (native) {
         const res = await native(args || {}, activeSignal);
-        if (res?.details?.diff) record.diff = res.details.diff;
+        const diff = resultDiff(res);
         record.ok = res?.isError !== true && res?.details?.ok !== false;
+        if (diff && record.ok) record.diff = diff;
         notifyCall(record);
         return res;
       }

package/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { isString, isFunction } from "./decode.js";
+import { isString, isFunction, isObject } from "./decode.js";
 import { buildCatalog, searchCatalog, describeTool, mergeNativeToolDefinitions } from "./catalog.js";
 import { loadConfig } from "./config.js";
 import { createHostBridge } from "./host-bridge.js";
@@ -30,6 +30,18 @@ try {
 function result(text, details) {
   return { content: [{ type: "text", text }], details };
 }
+function unwrapStructuredResult(response, operation) {
+  if (response?.ok === false) {
+    throw new Error(response.value || response.error || `${operation} failed`);
+  }
+  const value = isObject(response) && "value" in response ? response.value : response;
+  if (!isString(value)) return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
 
 const TOOL_DESCRIPTION = `Execute JavaScript that orchestrates host tools in one shot (Code Mode).
 
@@ -101,10 +113,10 @@ export default function piSupernova(pi) {
         }
       },
       async surface(filePath) {
-        return bridge.call("surface", { path: filePath });
+        return unwrapStructuredResult(await bridge.call("surface", { path: filePath }), "surface");
       },
       async snap(query, targetPath) {
-        return bridge.call("snap", { query, path: targetPath });
+        return unwrapStructuredResult(await bridge.call("snap", { query, path: targetPath }), "snap");
       },
       has(name) {
         return bridge.hasExecutor(name) || catalog.some((t) => t.name === name);
@@ -134,8 +146,8 @@ export default function piSupernova(pi) {
         }),
       ),
     }),
-    // "self" = we own chrome. OMP uses native framedBlock (write/edit look);
-    // Pi keeps the muted violet SafeText wash. "default" falls back to raw JSON.
+    // One self-owned result frame is shared by Pi and OMP; renderCall stays empty
+    // so separate call/result slots cannot duplicate the lifecycle card.
     renderShell: "self",
     mergeCallAndResult: true,
     renderCall: renderSupernovaCall,
@@ -163,6 +175,15 @@ export default function piSupernova(pi) {
         }
       });
 
+      if (isFunction(onUpdate)) {
+        try {
+          onUpdate({
+            content: [{ type: "text", text: "" }],
+            details: { trace: [], running: true },
+          });
+        } catch {}
+      }
+
       const runConfig = {
         ...config,
         timeoutMs: Number.isInteger(params?.timeoutMs) ? params.timeoutMs : config.timeoutMs,

package/omp-frame.js

@@ -1,11 +1,12 @@
 /**
- * OMP-style rounded tool chrome for supernova.
+ * Shared Pi/OMP rounded tool chrome for supernova.
  *
  * Intentionally self-contained — never dynamic-imports `@oh-my-pi/pi-coding-agent`
- * (that hung OMP plugin load). Geometry matches native write/edit framedBlock.
+ * (that hung OMP plugin load). Portable geometry matches native edit/write cards.
  */
 
-import { clampLine, measureWidth, wrapPlainToWidth } from "./render-measure.js";
+import { clampLine, measureWidth } from "./render-measure.js";
+import { isFunction, isString } from "./decode.js";
 
 const DEFAULT_BOX = {
 	topLeft: "╭",
@@ -18,14 +19,6 @@ const DEFAULT_BOX = {
 	teeRight: "├",
 };
 
-export function hasHostFramedBlock() {
-	return false;
-}
-
-export async function ensureOmpChrome() {
-	// No-op: portable frame only. Kept so call sites stay stable.
-}
-
 function boxOf(theme) {
 	const b = theme?.boxRound;
 	if (b && b.topLeft && b.horizontal && b.vertical) return b;
@@ -36,7 +29,7 @@ function borderPaint(theme, state, borderColor) {
 	const key =
 		borderColor ||
 		(state === "error" ? "error" : state === "warning" ? "warning" : state === "running" || state === "pending" ? "accent" : "dim");
-	if (theme && typeof theme.fg === "function") {
+	if (theme && isFunction(theme.fg)) {
 		try {
 			return (text) => theme.fg(key, text);
 		} catch {
@@ -74,21 +67,21 @@ function padLine(line, width, bgFn) {
 
 function bgFnForState(theme, state) {
 	if (!state || !theme) return undefined;
-	if (typeof theme.bg === "function") {
+	if (isFunction(theme.bg)) {
 		const key =
 			state === "error" ? "toolErrorBg" : state === "pending" || state === "running" ? "toolPendingBg" : "toolSuccessBg";
 		try {
 			const probe = theme.bg(key, "x");
-			if (typeof probe !== "string") return undefined;
+			if (!isString(probe)) return undefined;
 			return (text) => {
 				const painted = theme.bg(key, text);
-				return typeof painted === "string" ? painted : text;
+				return isString(painted) ? painted : text;
 			};
 		} catch {
 			return undefined;
 		}
 	}
-	if (typeof theme.getBgAnsi === "function") {
+	if (isFunction(theme.getBgAnsi)) {
 		try {
 			const key =
 				state === "error" ? "toolErrorBg" : state === "pending" || state === "running" ? "toolPendingBg" : "toolSuccessBg";
@@ -102,7 +95,7 @@ function bgFnForState(theme, state) {
 	return undefined;
 }
 
-export function renderPortableFrame(theme, { header, sections = [], state = "pending", borderColor, width }) {
+function renderPortableFrame(theme, { header, sections = [], state = "pending", borderColor, width }) {
 	const w = Math.max(1, width | 0);
 	if (w < 8) {
 		const rawLines = [header];
@@ -156,7 +149,7 @@ export function renderPortableFrame(theme, { header, sections = [], state = "pen
 	return lines;
 }
 
-export function createPortableFramedComponent(theme, build) {
+function createPortableFramedComponent(theme, build) {
 	let cacheWidth;
 	let cacheKey;
 	let cacheLines;
@@ -188,11 +181,3 @@ export function novaStatusLine(theme, options) {
 	return statusHeader(theme, options);
 }
 
-export function wrapPlainLines(text, width) {
-	const w = Math.max(1, width | 0);
-	const out = [];
-	for (const line of String(text ?? "").split("\n")) {
-		for (const chunk of wrapPlainToWidth(line, w)) out.push(chunk);
-	}
-	return out.length ? out : [""];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
   "type": "module",
   "author": "AdityaVG13",
@@ -57,24 +57,15 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "peerDependenciesMeta": {
-    "@earendil-works/pi-coding-agent": {
-      "optional": true
-    },
-    "@earendil-works/pi-tui": {
-      "optional": true
-    },
     "typebox": {
       "optional": true
     }
   },
   "devDependencies": {
-    "typebox": "^1.0.0",
-    "@earendil-works/pi-tui": "^0.84.0"
+    "typebox": "^1.0.0"
   },
   "publishConfig": {
     "access": "public"

package/render-measure.js

@@ -1,5 +1,5 @@
 /**
- * Width / truncate primitives shared by render.js and omp-frame.js.
+ * Width / truncate primitives used by the compact renderer.
  * Self-contained so path-install never depends on a host truncate that can
  * append ellipsis after cutting to maxWidth (Pi 92>91 crash class).
  */

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 [];
@@ -213,72 +130,55 @@ 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 = 6;
-	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", `- ${cleanInlineText(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", `+ ${cleanInlineText(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", `  ${cleanInlineText(item.text)}`);
-			row = `${gut}${sep}${txt}`;
+			body.push(`${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffContext", `  ${cleanInlineText(item.text)}`)}`);
 		}
-		body.push(row);
 	}
-
-	if (diff.lines.length > maxShown) {
-		const remaining = diff.lines.length - maxShown;
-		body.push(theme.fg("dim", `      │ … ${remaining} more lines`));
+	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;
+}
 
-	return `${header}\n${divider}\n${body.join("\n")}\n${divider}`;
+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}`;
+}
+
+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) {
-	return stripVTControlCharacters(String(value ?? ""))
-		.replace(/\r\n?/g, "\n")
-		.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, "")
-		.replace(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "");
+	const normalized = stripVTControlCharacters(String(value ?? "")).replace(/\r\n?/g, "\n");
+	return stripUnsafeControls(normalized).replace(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "");
 }
 
 function cleanInlineText(value) {
@@ -304,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);
 }
 
 /**
@@ -314,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,
@@ -341,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";
@@ -365,19 +263,18 @@ 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,
@@ -391,8 +288,8 @@ export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs
 	}
 	// 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,
@@ -424,174 +321,42 @@ function operationTarget(item) {
 	return "";
 }
 
+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;
+		}
+		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 };
+}
+
 function operationsFromTrace(trace) {
 	if (!Array.isArray(trace)) return [];
 	return trace
-		.map((item) => displayOperation(item?.name || "tool", operationTarget(item), item?.diff, item?.ok))
-		.filter(Boolean);
-}
-
-function collectCallOps(args, context) {
-	const traced = operationsFromTrace(context?.state?.trace);
-	if (traced.length > 0) return traced;
-	return extractOperationsFromCode(args?.code)
-		.map((op) => displayOperation(op.tool, op.target))
+		.map((item) => displayOperation(item?.name || "tool", operationTarget(item), normalizeTraceDiff(item), item?.ok))
 		.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`;
-	}
-	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(7, " "));
-	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.length} call${ops.length === 1 ? "" : "s"}`;
-	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 ──"));
-			const sourceLines = cleanBlockText(code).trim().split("\n");
-			for (const line of sourceLines.slice(0, 24)) bodyLines.push(theme.fg("toolOutput", line));
-			if (sourceLines.length > 24) bodyLines.push(theme.fg("dim", `… ${sourceLines.length - 24} more lines`));
-		}
-		return {
-			header,
-			sections: bodyLines.length > 0 ? [{ lines: bodyLines }] : [],
-			state: "pending",
-			borderColor: "borderMuted",
-			width,
-		};
-	});
-}
-
-function renderOmpResultCard(theme, { isErr, payload, expanded, bodyText, isPartial, spinnerFrame, opCount = 0 }) {
-	if (isErr) {
-		const errLines = String(bodyText || "").trim() ? String(bodyText).split("\n") : [];
-		if (payload?.error) errLines.push(theme.fg("error", cleanBlockText(payload.error)));
-		if (expanded && payload?.logs?.length) {
-			errLines.push(theme.fg("dim", "── logs ──"));
-			for (const log of payload.logs.slice(0, 24)) errLines.push(theme.fg("dim", cleanBlockText(log)));
-		}
-		const wall = payload?.wallMs != null ? `${payload.wallMs}ms` : "";
-		const calls = opCount > 0 ? `${opCount} call${opCount === 1 ? "" : "s"}` : "";
-		const header = novaStatusLine(theme, {
-			icon: "error",
-			title: "nova",
-			description: [calls, "failed", wall].filter(Boolean).join(" · "),
-		});
-		return novaFramedBlock(theme, (width) => ({
-			header,
-			sections: errLines.length > 0 ? [{ lines: errLines }] : [],
-			state: "error",
-			borderColor: "error",
-			width,
-		}));
-	}
-
-	const wall = payload?.wallMs != null ? `${payload.wallMs}ms` : "";
-	const calls = opCount > 0 ? `${opCount} call${opCount === 1 ? "" : "s"}` : "";
-	const description = [calls, isPartial ? "running" : "", wall].filter(Boolean).join(" · ");
-	const header = novaStatusLine(theme, {
-		icon: isPartial ? "running" : undefined,
-		spinnerFrame,
-		title: "nova",
-		description: description || 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,
-	}));
-}
-
 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;
-
-	// 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)}`;
-		}
-	}
-
-	if (context?.expanded && args?.code) {
-		out += "\n" + theme.fg("dim", "── source ──");
-		out += "\n" + theme.fg("toolOutput", cleanBlockText(args.code).trim());
-	}
-
-	if (context?.isError) comp.setTone("error");
-	else if (context?.isPartial) comp.setTone("pending");
-	else comp.setTone("success");
-	comp.setFraming(true);
-	comp.setText(out);
+	comp.setText("");
 	return comp;
 }
 
@@ -611,7 +376,8 @@ function formatResultOperation(theme, op, isPartial, isError) {
 	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");
-	return `${marker}${tool} ${target}${formatDiffStats(theme, op.diff)}`;
+	const stats = formatDiffStats(theme, op.diff);
+	return stats ? `${marker}${tool}${stats} ${target}` : `${marker}${tool} ${target}`;
 }
 
 function boundedResult(value) {
@@ -635,21 +401,21 @@ function buildResultBody(theme, { payload, context, args, expanded, isPartial, i
 		? tracedOps
 		: extractOperationsFromCode(args?.code).map((op) => displayOperation(op.tool, op.target)).filter(Boolean);
 	const maxOps = expanded ? 12 : 8;
-	for (const op of ops.slice(0, maxOps)) {
-		out += (out ? "\n" : "") + formatResultOperation(theme, op, isPartial, isError);
+	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${theme.fg("dim", `… ${ops.length - maxOps} more calls`)}`;
+	if (ops.length > maxOps) out += `\n│\n└─ ${theme.fg("dim", `… ${ops.length - maxOps} more calls`)}`;
 
 	if (expanded) {
-		const diffs = ops.filter((op) => op.diff && isObject(op.diff)).map((op) => op.diff);
-		const maxDiffs = 4;
-		if (diffs.length > 0) out += (out ? "\n" : "") + theme.fg("dim", "── changes ──");
-		for (const diff of diffs.slice(0, maxDiffs)) {
-			const box = renderDiffBox(diff, theme, 120);
-			if (box) out += "\n" + box;
-		}
-		if (diffs.length > maxDiffs) out += `\n${theme.fg("dim", `… ${diffs.length - maxDiffs} more changed files`)}`;
-
 		if (payload?.result !== undefined) {
 			out += (out ? "\n" : "") + theme.fg("dim", "── result ──");
 			out += "\n" + theme.fg("toolOutput", boundedResult(payload.result));
@@ -662,6 +428,31 @@ function buildResultBody(theme, { payload, context, args, expanded, isPartial, i
 	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, args, options, host } = normalizeResultRenderArgs(
 		resultArg,
@@ -672,58 +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 view = buildResultBody(theme, { payload, context, args, expanded, isPartial, isError: isErr });
 
-	if (shouldUseOmpFrame(host)) {
-		return renderOmpResultCard(theme, {
-			isErr,
-			payload,
-			expanded,
-			bodyText: view.body,
-			isPartial: isPartial && !isErr,
-			spinnerFrame: options?.spinnerFrame,
-			opCount: view.opCount,
-		});
-	}
-
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
-	if (options) options.lastComponent = comp;
-	else if (context) context.lastComponent = comp;
-
-	const wall = payload?.wallMs != null ? `${payload.wallMs}ms` : "";
-	const calls = view.opCount > 0 ? `${view.opCount} call${view.opCount === 1 ? "" : "s"}` : "complete";
-	let out = theme.fg("toolTitle", theme.bold("nova"));
-	out += " " + theme.fg("dim", `· ${[calls, isErr ? "failed" : isPartial ? "running" : "", wall].filter(Boolean).join(" · ")}`);
-	if (view.body) out += `\n  ${view.body.replaceAll("\n", "\n  ")}`;
-
+	let body = view.body;
 	if (isErr) {
-		out += `\n  ${theme.fg("error", payload?.error ? cleanBlockText(payload.error) : "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.slice(0, 24)) out += `\n  ${theme.fg("dim", cleanBlockText(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");
-	} else {
-		comp.setTone(isPartial ? "pending" : "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;
 }