pi-supernova 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+### Fixed
+
+- Native adapters are now included in `nova.search` / `nova.describe` with schemas matching the callable adapter, even when the host catalog omits parameters or the adapter name.
+
+## [0.0.3] - 2026-09-03
+
+### Changed
+
+- OMP TUI: nova cards now use the same rounded `framedBlock` + status-line chrome as native write/edit (Pi keeps the muted violet wash).
+
+## [0.0.2] - 2026-09-03
+
+### Fixed
+
+- OMP TUI: accept `(args, options, theme)` render signature so the custom nova card shows instead of the raw JSON args dump.
+
 ## [0.0.1] - 2026-09-03
 
 ### Added

package/catalog.js

@@ -1,6 +1,84 @@
 
 import { isString, isObject } from "./decode.js";
 
+export const NATIVE_TOOL_DEFINITIONS = [
+  {
+    name: "read",
+    description: "Read UTF-8 workspace files by path, or resolve a concept query to source. Supports path arrays, offset, and limit.",
+    parameters: { type: "object", properties: {
+      path: { type: "string", description: "Workspace-relative file path or concept query" },
+      target: { anyOf: [{ type: "string" }, { type: "array" }], description: "File path/query or array of paths" },
+      offset: { type: "number", description: "One-based starting line" },
+      limit: { type: "number", description: "Maximum lines to return" },
+    } },
+  },
+  {
+    name: "write", description: "Write UTF-8 content to a workspace file.",
+    parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] },
+  },
+  {
+    name: "edit", description: "Apply unique text replacements, or a unified diff, to a workspace file.",
+    parameters: { type: "object", properties: {
+      path: { type: "string" }, oldText: { type: "string" }, newText: { type: "string" }, edits: { type: "array" }, patch: { type: "string" },
+    }, required: ["path"] },
+  },
+  {
+    name: "apply_patch", description: "Apply a unified diff to one workspace file.",
+    parameters: { type: "object", properties: { path: { type: "string" }, patch: { type: "string" } }, required: ["patch"] },
+  },
+  {
+    name: "snap", description: "Resolve a concept query to the most relevant workspace source location.",
+    parameters: { type: "object", properties: { query: { type: "string" }, path: { type: "string" } }, required: ["query"] },
+  },
+  {
+    name: "surface", description: "Extract a structural outline from a workspace source file.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+  },
+  {
+    name: "bash", description: "Run a shell command inside the workspace and capture bounded output.",
+    parameters: { type: "object", properties: { command: { type: "string" }, cwd: { type: "string" }, timeoutMs: { type: "number" } }, required: ["command"] },
+  },
+  {
+    name: "grep", description: "Search workspace file contents by pattern.",
+    parameters: { type: "object", properties: {
+      pattern: { type: "string" }, path: { type: "string" }, glob: { type: "string" }, caseSensitive: { type: "boolean" },
+    }, required: ["pattern"] },
+  },
+  {
+    name: "glob", description: "List workspace files matching a glob pattern.",
+    parameters: { type: "object", properties: { pattern: { type: "string" } }, required: ["pattern"] },
+  },
+  {
+    name: "find", description: "List workspace files, optionally constrained by path and pattern.",
+    parameters: { type: "object", properties: { path: { type: "string" }, pattern: { type: "string" }, glob: { type: "string" } } },
+  },
+  {
+    name: "ls", description: "List direct entries in a workspace directory.",
+    parameters: { type: "object", properties: { path: { type: "string" } } },
+  },
+];
+
+export function mergeNativeToolDefinitions(tools, capturedNames = []) {
+  const nativeByName = new Map(NATIVE_TOOL_DEFINITIONS.map((tool) => [tool.name, tool]));
+  const captured = new Set(capturedNames);
+  const seen = new Set();
+  const merged = [];
+
+  for (const tool of tools || []) {
+    const fallback = nativeByName.get(tool?.name);
+    merged.push(fallback && !captured.has(tool.name)
+      ? { ...tool, ...fallback, sourceInfo: { path: "<native:" + tool.name + ">" } }
+      : tool);
+    if (tool?.name) seen.add(tool.name);
+  }
+  for (const fallback of NATIVE_TOOL_DEFINITIONS) {
+    if (!seen.has(fallback.name)) {
+      merged.push({ ...fallback, sourceInfo: { path: "<native:" + fallback.name + ">" } });
+    }
+  }
+  return merged;
+}
+
 function normalizeTool(tool) {
   if (!tool || !isObject(tool)) return null;
   const name = isString(tool.name) ? tool.name : "";

package/index.js

@@ -12,7 +12,7 @@ try {
 }
 
 import { isString, isFunction } from "./decode.js";
-import { buildCatalog, searchCatalog, describeTool } from "./catalog.js";
+import { buildCatalog, searchCatalog, describeTool, mergeNativeToolDefinitions } from "./catalog.js";
 import { loadConfig } from "./config.js";
 import { createHostBridge } from "./host-bridge.js";
 import { runGuestProgram } from "./runtime.js";
@@ -61,7 +61,8 @@ export default function piSupernova(pi) {
     } catch {
       tools = [];
     }
-    catalog = buildCatalog(tools, config.excludeTools || []);
+    const discoverable = mergeNativeToolDefinitions(tools, bridge.executors.keys());
+    catalog = buildCatalog(discoverable, config.excludeTools || []);
     return catalog;
   }
 
@@ -127,9 +128,10 @@ export default function piSupernova(pi) {
         }),
       ),
     }),
-    // "self" = we paint a muted violet/grey-blue card (see SafeText framing).
-    // "default" uses the host's loud green tool panels and can fall back to raw JSON args.
+    // "self" = we own chrome. OMP uses native framedBlock (write/edit look);
+    // Pi keeps the muted violet SafeText wash. "default" falls back to raw JSON.
     renderShell: "self",
+    mergeCallAndResult: true,
     renderCall: renderSupernovaCall,
     renderResult: renderSupernovaResult,
     async execute(_id, params, signal, onUpdate, ctx) {

package/omp-frame.js

@@ -0,0 +1,234 @@
+/**
+ * OMP-native tool chrome for supernova.
+ *
+ * Prefer host `framedBlock` + `renderStatusLine` from
+ * `@oh-my-pi/pi-coding-agent/tui` (same path read/write/edit use). Fall back to a
+ * portable rounded frame that matches that look when the import is unavailable
+ * (Pi path-install / unit tests).
+ */
+
+import { clampLine, measureWidth, wrapPlainToWidth } from "./render-measure.js";
+
+const DEFAULT_BOX = {
+	topLeft: "╭",
+	topRight: "╮",
+	bottomLeft: "╰",
+	bottomRight: "╯",
+	horizontal: "─",
+	vertical: "│",
+	teeLeft: "┤",
+	teeRight: "├",
+};
+
+let hostFramedBlock = null;
+let hostRenderStatusLine = null;
+let hostMarkFramed = null;
+let hostResolved = false;
+
+export async function ensureOmpChrome() {
+	if (hostResolved) return;
+	hostResolved = true;
+	for (const spec of ["@oh-my-pi/pi-coding-agent/tui", "@oh-my-pi/pi-coding-agent/tui/index.js"]) {
+		try {
+			const tui = await import(spec);
+			if (typeof tui.framedBlock === "function") hostFramedBlock = tui.framedBlock;
+			if (typeof tui.renderStatusLine === "function") hostRenderStatusLine = tui.renderStatusLine;
+			if (typeof tui.markFramedBlockComponent === "function") hostMarkFramed = tui.markFramedBlockComponent;
+			if (hostFramedBlock && hostRenderStatusLine) return;
+		} catch {
+			// Pi / tests / plain node — use portable frame.
+		}
+	}
+}
+
+/** Kick off resolution at module load (extension hosts support top-level await). */
+await ensureOmpChrome();
+
+export function hasHostFramedBlock() {
+	return typeof hostFramedBlock === "function" && typeof hostRenderStatusLine === "function";
+}
+
+function boxOf(theme) {
+	const b = theme?.boxRound;
+	if (b && b.topLeft && b.horizontal && b.vertical) return b;
+	return DEFAULT_BOX;
+}
+
+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") {
+		try {
+			return (text) => theme.fg(key, text);
+		} catch {
+			/* fall through */
+		}
+	}
+	return (text) => text;
+}
+
+function statusHeader(theme, { title, description, state, spinnerFrame, icon, iconOverride }) {
+	// Match native Write/Edit: framed call heads omit the pending hourglass; only
+	// pass an icon when the caller sets one (error / running / success glyph).
+	const resolvedIcon =
+		iconOverride !== undefined
+			? undefined
+			: icon !== undefined
+				? icon
+				: state === "error"
+					? "error"
+					: undefined;
+	if (hostRenderStatusLine) {
+		return hostRenderStatusLine(
+			{
+				icon: resolvedIcon,
+				iconOverride,
+				spinnerFrame,
+				title,
+				description,
+			},
+			theme,
+		);
+	}
+	const titleText = theme?.fg ? theme.fg("accent", title) : title;
+	const descText = description ? (theme?.fg ? theme.fg("muted", description) : description) : "";
+	const prefix = state === "error" ? (theme?.fg ? theme.fg("error", "✗ ") : "✗ ") : "";
+	return descText ? `${prefix}${titleText}: ${descText}` : `${prefix}${titleText}`;
+}
+
+function padLine(line, width, bgFn) {
+	const w = Math.max(0, width | 0);
+	const vis = measureWidth(line);
+	const pad = Math.max(0, w - vis);
+	const padded = line + " ".repeat(pad);
+	return bgFn ? bgFn(padded) : padded;
+}
+
+function bgFnForState(theme, state) {
+	if (!state || !theme) return undefined;
+	if (typeof theme.bg === "function") {
+		const key =
+			state === "error" ? "toolErrorBg" : state === "pending" || state === "running" ? "toolPendingBg" : "toolSuccessBg";
+		try {
+			const probe = theme.bg(key, "x");
+			if (typeof probe !== "string") return undefined;
+			return (text) => {
+				const painted = theme.bg(key, text);
+				return typeof painted === "string" ? painted : text;
+			};
+		} catch {
+			return undefined;
+		}
+	}
+	if (typeof theme.getBgAnsi === "function") {
+		try {
+			const key =
+				state === "error" ? "toolErrorBg" : state === "pending" || state === "running" ? "toolPendingBg" : "toolSuccessBg";
+			const ansi = theme.getBgAnsi(key);
+			if (!ansi) return undefined;
+			return (text) => `${ansi}${text}\x1b[49m`;
+		} catch {
+			return undefined;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Portable rounded frame matching OMP output-block geometry.
+ */
+export function renderPortableFrame(theme, { header, sections = [], state = "pending", borderColor, width }) {
+	const w = Math.max(8, width | 0);
+	const box = boxOf(theme);
+	const border = borderPaint(theme, state, borderColor);
+	const bgFn = bgFnForState(theme, state);
+	const h = box.horizontal;
+	const v = box.vertical;
+	const cap = h.repeat(3);
+
+	const paintBar = (leftChar, rightChar, label) => {
+		const left = `${leftChar}${cap}`;
+		const right = rightChar;
+		if (!label) {
+			const fill = Math.max(0, w - measureWidth(left) - measureWidth(right));
+			return padLine(`${border(left)}${border(h.repeat(fill))}${border(right)}`, w, bgFn);
+		}
+		const rawLabel = ` ${label} `;
+		const maxLabel = Math.max(0, w - measureWidth(left) - measureWidth(right));
+		const trimmed = clampLine(rawLabel, maxLabel);
+		const fill = Math.max(0, w - measureWidth(left) - measureWidth(trimmed) - measureWidth(right));
+		return padLine(`${border(left)}${trimmed}${border(h.repeat(fill))}${border(right)}`, w, bgFn);
+	};
+
+	const contentWidth = Math.max(1, w - 2 - 2); // borders + 1-col pad each side
+	const lines = [];
+	lines.push(paintBar(box.topLeft, box.topRight, header));
+
+	const normalized = sections.length > 0 ? sections : [{ lines: [] }];
+	for (const section of normalized) {
+		if (section.label) {
+			lines.push(paintBar(box.teeRight || "├", box.teeLeft || "┤", section.label));
+		}
+		for (const raw of section.lines || []) {
+			for (const piece of String(raw).split("\n")) {
+				const body = clampLine(piece, contentWidth);
+				const pad = Math.max(0, contentWidth - measureWidth(body));
+				const inner = `${body}${" ".repeat(pad)}`;
+				lines.push(padLine(`${border(v)} ${inner} ${border(v)}`, w, bgFn));
+			}
+		}
+	}
+
+	lines.push(paintBar(box.bottomLeft, box.bottomRight, null));
+	return lines;
+}
+
+export function createPortableFramedComponent(theme, build) {
+	let cacheWidth;
+	let cacheKey;
+	let cacheLines;
+	const comp = {
+		render(width) {
+			const opts = build(width);
+			const key = `${opts.state}|${opts.borderColor}|${opts.header}|${(opts.sections || [])
+				.map((s) => (s.lines || []).join("\n"))
+				.join("||")}`;
+			if (cacheLines && cacheWidth === width && cacheKey === key) return cacheLines;
+			cacheLines = renderPortableFrame(theme, opts);
+			cacheWidth = width;
+			cacheKey = key;
+			return cacheLines;
+		},
+		invalidate() {
+			cacheLines = undefined;
+			cacheKey = undefined;
+			cacheWidth = undefined;
+		},
+	};
+	if (hostMarkFramed) return hostMarkFramed(comp);
+	return comp;
+}
+
+/**
+ * Build a framed nova card. Uses host framedBlock when available (OMP).
+ */
+export function novaFramedBlock(theme, build) {
+	if (hostFramedBlock) {
+		return hostFramedBlock(theme, build);
+	}
+	return createPortableFramedComponent(theme, build);
+}
+
+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.1",
+  "version": "0.0.3",
   "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
   "type": "module",
   "author": "AdityaVG13",
@@ -37,6 +37,8 @@
     "snap.js",
     "diff.js",
     "render.js",
+    "render-measure.js",
+    "omp-frame.js",
     "surface.js",
     "decode.js"
   ],

package/render-measure.js

@@ -0,0 +1,143 @@
+/**
+ * Width / truncate primitives shared by render.js and omp-frame.js.
+ * Self-contained so path-install never depends on a host truncate that can
+ * append ellipsis after cutting to maxWidth (Pi 92>91 crash class).
+ */
+
+import { stripVTControlCharacters } from "node:util";
+
+const ELLIPSIS = "…";
+
+/**
+ * Visible columns — ANSI/OSC stripped, tabs → 3 spaces.
+ * ASCII-fast; non-ASCII uses a wide-char heuristic aligned with typical terminal
+ * / pi-tui behavior (emoji & symbols like ⚡ are 2 cols — undercount ⇒ 92>91 crash).
+ */
+export function measureWidth(text) {
+	const raw = String(text ?? "").replace(/\t/g, "   ");
+	if (raw.length === 0) return 0;
+	const plain = raw.includes("\x1b") ? stripVTControlCharacters(raw) : raw;
+	if (/^[\x20-\x7e]*$/.test(plain)) return plain.length;
+	let width = 0;
+	for (const ch of plain) {
+		width += codePointWidth(ch.codePointAt(0));
+	}
+	return width;
+}
+
+function codePointWidth(cp) {
+	if (cp <= 0x1f || (cp >= 0x7f && cp <= 0x9f)) return 0;
+	// Fullwidth / wide ranges (CJK, Hangul, emoji blocks we actually emit).
+	if (cp >= 0x1100 && cp <= 0x115f) return 2;
+	if (cp === 0x2329 || cp === 0x232a) return 2;
+	if (cp >= 0x2e80 && cp <= 0xa4cf) return 2;
+	if (cp >= 0xac00 && cp <= 0xd7a3) return 2;
+	if (cp >= 0xf900 && cp <= 0xfaff) return 2;
+	if (cp >= 0xfe10 && cp <= 0xfe19) return 2;
+	if (cp >= 0xfe30 && cp <= 0xfe6f) return 2;
+	if (cp >= 0xff00 && cp <= 0xff60) return 2;
+	if (cp >= 0xffe0 && cp <= 0xffe6) return 2;
+	if (cp >= 0x1f300 && cp <= 0x1f64f) return 2;
+	if (cp >= 0x1f900 && cp <= 0x1f9ff) return 2;
+	if (cp >= 0x20000 && cp <= 0x3fffd) return 2;
+	// Ambiguous emoji/symbols pi-tui treats as wide (⚡ U+26A1 was the 92>91 footgun).
+	if (cp === 0x26a1 || cp === 0x2b50 || cp === 0x2728) return 2;
+	return 1;
+}
+
+/**
+ * Truncate so the result's visible width is ALWAYS ≤ maxWidth, ellipsis included.
+ * Strips ANSI in the truncated region (crash-safety > color fidelity on overflow).
+ */
+export function hardTruncate(text, maxWidth, ellipsis = ELLIPSIS) {
+	const w = Math.max(0, maxWidth | 0);
+	if (w === 0) return "";
+	const raw = String(text ?? "").replace(/\t/g, "   ");
+	if (measureWidth(raw) <= w) return raw;
+
+	const ell = String(ellipsis);
+	const ellW = measureWidth(ell);
+	if (ellW >= w) {
+		if (ellW === 0) return "";
+		return ell.slice(0, w);
+	}
+
+	const budget = w - ellW;
+	const plain = stripVTControlCharacters(raw);
+	let out = "";
+	let visible = 0;
+	for (const ch of plain) {
+		const cw = measureWidth(ch);
+		if (visible + cw > budget) break;
+		out += ch;
+		visible += cw;
+	}
+	return out + ell;
+}
+
+/**
+ * Absolute clamp used by every renderer. Loops + hard truncate; never returns > width.
+ */
+export function clampLine(line, width) {
+	const w = Math.max(1, width | 0);
+	let out = String(line ?? "").replace(/\t/g, "   ");
+	if (measureWidth(out) <= w) return out;
+	out = hardTruncate(out, w, ELLIPSIS);
+	if (measureWidth(out) <= w) return out;
+	const plain = stripVTControlCharacters(out);
+	if (plain.length <= w) return plain;
+	if (w === 1) return ELLIPSIS;
+	return plain.slice(0, Math.max(0, w - 1)) + ELLIPSIS;
+}
+
+/**
+ * Wrap plain text to width, preferring breaks after `/` or space so paths stay readable.
+ * Every returned chunk is ≤ width (no ellipsis — caller clamps if needed).
+ */
+export function wrapPlainToWidth(plain, width) {
+	const w = Math.max(1, width | 0);
+	const text = String(plain ?? "");
+	if (text.length === 0) return [""];
+	if (measureWidth(text) <= w) return [text];
+
+	const lines = [];
+	let i = 0;
+	while (i < text.length) {
+		let end = i;
+		let visible = 0;
+		let lastBreak = -1;
+		while (end < text.length) {
+			const ch = text[end];
+			const cw = measureWidth(ch);
+			if (visible + cw > w) break;
+			visible += cw;
+			if (ch === "/" || ch === " ") lastBreak = end + 1;
+			end++;
+		}
+		if (end === i) {
+			end = i + 1;
+		} else if (end < text.length && lastBreak > i + Math.floor(w * 0.35)) {
+			end = lastBreak;
+		}
+		lines.push(text.slice(i, end));
+		i = end;
+	}
+	return lines.length > 0 ? lines : [""];
+}
+
+/**
+ * Fit a filesystem path into `budget` columns, keeping the basename visible.
+ */
+export function fitPath(pathText, budget) {
+	const w = Math.max(1, budget | 0);
+	let p = String(pathText ?? "").replace(/\\/g, "/");
+	if (measureWidth(p) <= w) return p;
+
+	const parts = p.split("/").filter(Boolean);
+	const base = parts.length > 0 ? parts[parts.length - 1] : p;
+	const suffix = parts.length > 1 ? `…/${base}` : base;
+	if (measureWidth(suffix) <= w) return suffix;
+	return hardTruncate(base, w);
+}
+
+export { ELLIPSIS };

package/render.js

@@ -5,150 +5,23 @@
  * (classic failure: 92 > 91). Path-install often cannot resolve @earendil-works/pi-tui,
  * 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).
  */
 
 import { stripVTControlCharacters } from "node:util";
 import { isString, isObject } from "./decode.js";
+import {
+	measureWidth,
+	hardTruncate,
+	clampLine,
+	wrapPlainToWidth,
+	fitPath,
+} from "./render-measure.js";
+import { ensureOmpChrome, hasHostFramedBlock, novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 
-const ELLIPSIS = "…";
-
-/**
- * Visible columns — ANSI/OSC stripped, tabs → 3 spaces.
- * ASCII-fast; non-ASCII uses a wide-char heuristic aligned with typical terminal
- * / pi-tui behavior (emoji & symbols like ⚡ are 2 cols — undercount ⇒ 92>91 crash).
- */
-export function measureWidth(text) {
-	const raw = String(text ?? "").replace(/\t/g, "   ");
-	if (raw.length === 0) return 0;
-	const plain = raw.includes("\x1b") ? stripVTControlCharacters(raw) : raw;
-	if (/^[\x20-\x7e]*$/.test(plain)) return plain.length;
-	let width = 0;
-	for (const ch of plain) {
-		width += codePointWidth(ch.codePointAt(0));
-	}
-	return width;
-}
-
-function codePointWidth(cp) {
-	if (cp <= 0x1f || (cp >= 0x7f && cp <= 0x9f)) return 0;
-	// Fullwidth / wide ranges (CJK, Hangul, emoji blocks we actually emit).
-	if (cp >= 0x1100 && cp <= 0x115f) return 2;
-	if (cp === 0x2329 || cp === 0x232a) return 2;
-	if (cp >= 0x2e80 && cp <= 0xa4cf) return 2;
-	if (cp >= 0xac00 && cp <= 0xd7a3) return 2;
-	if (cp >= 0xf900 && cp <= 0xfaff) return 2;
-	if (cp >= 0xfe10 && cp <= 0xfe19) return 2;
-	if (cp >= 0xfe30 && cp <= 0xfe6f) return 2;
-	if (cp >= 0xff00 && cp <= 0xff60) return 2;
-	if (cp >= 0xffe0 && cp <= 0xffe6) return 2;
-	if (cp >= 0x1f300 && cp <= 0x1f64f) return 2;
-	if (cp >= 0x1f900 && cp <= 0x1f9ff) return 2;
-	if (cp >= 0x20000 && cp <= 0x3fffd) return 2;
-	// Ambiguous emoji/symbols pi-tui treats as wide (⚡ U+26A1 was the 92>91 footgun).
-	if (cp === 0x26a1 || cp === 0x2b50 || cp === 0x2728) return 2;
-	return 1;
-}
-
-/**
- * Truncate so the result's visible width is ALWAYS ≤ maxWidth, ellipsis included.
- * Strips ANSI in the truncated region (crash-safety > color fidelity on overflow).
- */
-export function hardTruncate(text, maxWidth, ellipsis = ELLIPSIS) {
-	const w = Math.max(0, maxWidth | 0);
-	if (w === 0) return "";
-	const raw = String(text ?? "").replace(/\t/g, "   ");
-	if (measureWidth(raw) <= w) return raw;
-
-	const ell = String(ellipsis);
-	const ellW = measureWidth(ell);
-	if (ellW >= w) {
-		// Degenerate: return as many ellipsis columns as fit.
-		if (ellW === 0) return "";
-		return ell.slice(0, w);
-	}
-
-	const budget = w - ellW;
-	const plain = stripVTControlCharacters(raw);
-	let out = "";
-	let visible = 0;
-	for (const ch of plain) {
-		const cw = measureWidth(ch);
-		if (visible + cw > budget) break;
-		out += ch;
-		visible += cw;
-	}
-	return out + ell;
-}
-
-/**
- * Absolute clamp used by every renderer. Loops + hard truncate; never returns > width.
- * Exported for tests and as the single choke point for the Pi crash contract.
- */
-export function clampLine(line, width) {
-	const w = Math.max(1, width | 0);
-	let out = String(line ?? "").replace(/\t/g, "   ");
-	if (measureWidth(out) <= w) return out;
-	out = hardTruncate(out, w, ELLIPSIS);
-	// Belt-and-suspenders: if anything still disagrees, force plain slice.
-	if (measureWidth(out) <= w) return out;
-	const plain = stripVTControlCharacters(out);
-	if (plain.length <= w) return plain;
-	if (w === 1) return ELLIPSIS;
-	return plain.slice(0, Math.max(0, w - 1)) + ELLIPSIS;
-}
-
-/**
- * Wrap plain text to width, preferring breaks after `/` or space so paths stay readable.
- * Every returned chunk is ≤ width (no ellipsis — caller clamps if needed).
- */
-export function wrapPlainToWidth(plain, width) {
-	const w = Math.max(1, width | 0);
-	const text = String(plain ?? "");
-	if (text.length === 0) return [""];
-	if (measureWidth(text) <= w) return [text];
-
-	const lines = [];
-	let i = 0;
-	while (i < text.length) {
-		let end = i;
-		let visible = 0;
-		let lastBreak = -1;
-		while (end < text.length) {
-			const ch = text[end];
-			const cw = measureWidth(ch);
-			if (visible + cw > w) break;
-			visible += cw;
-			// Only soft-break on path/word separators — never mid-filename (`host-` / `bridge`).
-			if (ch === "/" || ch === " ") lastBreak = end + 1;
-			end++;
-		}
-		if (end === i) {
-			// Single wide char edge case — force one column advance.
-			end = i + 1;
-		} else if (end < text.length && lastBreak > i + Math.floor(w * 0.35)) {
-			end = lastBreak;
-		}
-		lines.push(text.slice(i, end));
-		i = end;
-	}
-	return lines.length > 0 ? lines : [""];
-}
-
-/**
- * Fit a filesystem path into `budget` columns, keeping the basename visible.
- * `packages/pi-supernova/host-bridge.js` → `…/host-bridge.js` when narrow.
- */
-export function fitPath(pathText, budget) {
-	const w = Math.max(1, budget | 0);
-	let p = String(pathText ?? "").replace(/\\/g, "/");
-	if (measureWidth(p) <= w) return p;
-
-	const parts = p.split("/").filter(Boolean);
-	const base = parts.length > 0 ? parts[parts.length - 1] : p;
-	const suffix = parts.length > 1 ? `…/${base}` : base;
-	if (measureWidth(suffix) <= w) return suffix;
-	return hardTruncate(base, w);
-}
+export { measureWidth, hardTruncate, clampLine, wrapPlainToWidth, fitPath };
 
 function fitOutputLines(text, width) {
 	const w = Math.max(1, width | 0);
@@ -418,13 +291,113 @@ function formatOpTarget(raw, tool) {
 	return text.replace(/\\/g, "/");
 }
 
-export function renderSupernovaCall(args, theme, context) {
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
+function isTheme(value) {
+	return !!value && typeof value === "object" && typeof value.fg === "function";
+}
 
-	let ops = [];
+/**
+ * Dual-host renderCall args:
+ *   Pi:  (args, theme, context)
+ *   OMP: (args, options/renderState, theme)
+ */
+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 = {};
+		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 context = {
+			...options,
+			state: options.state,
+			expanded: options.expanded,
+			isPartial: options.isPartial,
+			executionStarted: options.executionStarted,
+			argsComplete: options.argsComplete,
+			lastComponent: options.lastComponent,
+			invalidate: options.invalidate,
+		};
+		return { args: a, theme: c, context, host: "omp", options };
+	}
+	throw new Error("supernova renderCall: theme missing (expected Pi or OMP signature)");
+}
+
+/**
+ * Dual-host renderResult args:
+ *   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.
+ */
+function detectResultHost(options, ctxOrArgs) {
+	if (isTheme(options)) return "pi";
+	if (
+		ctxOrArgs &&
+		typeof ctxOrArgs === "object" &&
+		("lastComponent" in ctxOrArgs || "invalidate" in ctxOrArgs)
+	) {
+		return "pi";
+	}
+	if (
+		ctxOrArgs &&
+		typeof ctxOrArgs === "object" &&
+		("code" in ctxOrArgs || "timeoutMs" in ctxOrArgs)
+	) {
+		return "omp";
+	}
+	if (hasHostFramedBlock()) return "omp";
+	return "pi";
+}
+
+export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
+	if (isTheme(themeOrCtx)) {
+		const opts = options && typeof options === "object" ? options : {};
+		let context;
+		if (
+			ctxOrArgs &&
+			typeof ctxOrArgs === "object" &&
+			!isTheme(ctxOrArgs) &&
+			("lastComponent" in ctxOrArgs || "state" in ctxOrArgs || "invalidate" in ctxOrArgs)
+		) {
+			context = ctxOrArgs;
+		} else {
+			context = { ...(opts.state ? { state: opts.state } : {}), lastComponent: opts.lastComponent };
+		}
+		if (!context.state || typeof context.state !== "object") context.state = {};
+		return {
+			result,
+			expanded: !!opts.expanded,
+			isPartial: !!opts.isPartial,
+			theme: themeOrCtx,
+			context,
+			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 = {};
+		return {
+			result,
+			expanded: !!context.expanded,
+			isPartial: !!context.isPartial,
+			theme: options,
+			context,
+			host: "pi",
+			options: {},
+		};
+	}
+	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) {
-		ops = stateTrace
+		return stateTrace
 			.map((item) => {
 				const tool = item?.name || "tool";
 				let target = "";
@@ -434,12 +407,24 @@ export function renderSupernovaCall(args, theme, context) {
 				return displayOperation(tool, target);
 			})
 			.filter(Boolean);
-	} else {
-		ops = extractOperationsFromCode(args?.code)
-			.map((op) => displayOperation(op.tool, op.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`;
+	}
+	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) {
@@ -448,16 +433,116 @@ export function renderSupernovaCall(args, theme, context) {
 			context.invalidate?.();
 		}, 100);
 	}
+}
 
-	let timeStr = "";
-	if (state?.wallMs != null) {
-		timeStr = `${state.wallMs}ms`;
-	} else if (state?.startedAt != null) {
-		const elapsed = Math.round(performance.now() - state.startedAt);
-		timeStr = elapsed >= 1000 ? `${(elapsed / 1000).toFixed(1)}s` : `${elapsed}ms`;
+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" || hasHostFramedBlock();
+}
+
+/**
+ * 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)));
+		}
+		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,
+		}));
 	}
 
-	// Compact aesthetic — never dump raw JSON args (the stock Pi tool fallback).
+	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,
+	}));
+}
+
+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)) {
+		void ensureOmpChrome();
+		return renderOmpCallCard(theme, {
+			ops,
+			timeStr,
+			expanded: !!context?.expanded,
+			code: args?.code,
+		});
+	}
+
+	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}`);
@@ -467,12 +552,7 @@ export function renderSupernovaCall(args, theme, context) {
 		out += " " + theme.fg("dim", "· composing");
 	} else {
 		for (const op of ops) {
-			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) : "";
-			out += `\n  ${bullet}${toolName}${target}`;
+			out += `\n  ${formatOpBodyLine(theme, op)}`;
 		}
 	}
 
@@ -489,50 +569,8 @@ export function renderSupernovaCall(args, theme, context) {
 	return comp;
 }
 
-export function renderSupernovaResult(result, { expanded, isPartial }, theme, context) {
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
-
-	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?.();
-	}
-
-	if (isPartial) {
-		comp.setText("");
-		return comp;
-	}
-	const isErr = result?.isError || payload?.ok === false;
-
-	if (isErr) {
-		let out = theme.fg("error", "✗ error");
-		if (payload?.error) {
-			out += `\n  ${theme.fg("error", String(payload.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))}`;
-		}
-		comp.setTone("error");
-		comp.setFraming(true);
-		comp.setText(out);
-		return comp;
-	}
-
+function buildResultBody(theme, { payload, context, expanded }) {
 	let out = "";
-
 	const trace = payload?.trace || context?.state?.trace || [];
 	const diffs = trace.filter((t) => t?.diff && isObject(t.diff)).map((t) => t.diff);
 
@@ -540,7 +578,6 @@ export function renderSupernovaResult(result, { expanded, isPartial }, theme, co
 		const maxDiffsShown = expanded ? diffs.length : 2;
 		const shownDiffs = diffs.slice(0, maxDiffsShown);
 		for (const diff of shownDiffs) {
-			// Build unconstrained; SafeText.render(terminalWidth) is the hard clamp.
 			const box = renderDiffBox(diff, theme, 120);
 			if (box) out += (out ? "\n\n" : "") + box;
 		}
@@ -572,7 +609,110 @@ export function renderSupernovaResult(result, { expanded, isPartial }, theme, co
 			for (const log of payload.logs) out += `\n  ${theme.fg("dim", String(log))}`;
 		}
 	}
+	return out;
+}
+
+export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextArg) {
+	const { result, expanded, isPartial, theme, context, options, host } = normalizeResultRenderArgs(
+		resultArg,
+		optionsArg,
+		themeArg,
+		contextArg,
+	);
+
+	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) {
+		void ensureOmpChrome();
+		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;
+	}
+
+	if (isErr) {
+		let out = theme.fg("error", "✗ error");
+		if (payload?.error) {
+			out += `\n  ${theme.fg("error", String(payload.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))}`;
+		}
+		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;