pi-supernova 0.0.8 → 0.0.15

package/ledger.js

@@ -0,0 +1,178 @@
+// Seen-ledger: the model's context window is a memory. Nothing that already reached the
+// model in this session is sent again verbatim. A run of identical lines (≥ MIN_RUN, with
+// enough substantive lines) collapses to one marker that cites the earlier program and,
+// when the lines came from a file, path:a–b, so one read(path, a, n) recovers them.
+//
+// This is not compression: every collapsed line already exists, verbatim, in the model's
+// context. Changed lines are never collapsed, so a re-read after an edit shows exactly the
+// delta. Lines the current program read with an explicit offset/limit are pinned and always
+// shown: that is the model asking for a specific window on purpose.
+
+const MIN_RUN = 6;
+const MIN_SUBSTANTIVE = 4;
+const MAX_CANDIDATES = 8;
+const DEFAULT_WINDOW = 40;
+const MAX_STORED_LINES = 200_000;
+
+function hashLine(line) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < line.length; i++) {
+    h ^= line.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+function substantive(line) {
+  return line.trim().length >= 8;
+}
+
+export class SeenLedger {
+  constructor({ window = DEFAULT_WINDOW } = {}) {
+    this.window = window;
+    this.results = new Map(); // call → { hashes: Uint32Array, lines: string[] }
+    this.occurrences = new Map(); // hash → [{ call, index }]
+    this.origins = new Map(); // hash → { path, line }  (provenance recorded by the bridge)
+    this.pinned = new Set(); // "path:line" pinned by the current program
+    this.storedLines = 0;
+    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
+  }
+
+  reset() {
+    this.results.clear();
+    this.occurrences.clear();
+    this.origins.clear();
+    this.pinned.clear();
+    this.storedLines = 0;
+    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
+  }
+
+  beginProgram(call) {
+    this.pinned.clear();
+    this.stats.programs++;
+    for (const old of [...this.results.keys()]) {
+      if (old <= call - this.window) this.forget(old);
+    }
+  }
+
+  forget(call) {
+    const entry = this.results.get(call);
+    if (!entry) return;
+    for (let i = 0; i < entry.hashes.length; i++) {
+      const list = this.occurrences.get(entry.hashes[i]);
+      if (!list) continue;
+      const kept = list.filter((o) => o.call !== call);
+      if (kept.length) this.occurrences.set(entry.hashes[i], kept);
+      else this.occurrences.delete(entry.hashes[i]);
+    }
+    this.storedLines -= entry.hashes.length;
+    this.results.delete(call);
+  }
+
+  /** Provenance for lines the bridge is about to hand to the program: file text, outlines, evidence spans. */
+  recordOrigin(path, firstLine, lines, pin = false) {
+    for (let i = 0; i < lines.length; i++) {
+      if (!substantive(lines[i])) continue;
+      this.origins.set(hashLine(lines[i]), { path, line: firstLine + i });
+      if (pin) this.pinned.add(path + ":" + (firstLine + i));
+    }
+  }
+
+  isPinned(hash) {
+    const o = this.origins.get(hash);
+    return o !== undefined && this.pinned.has(o.path + ":" + o.line);
+  }
+
+  /** Length of the identical run between lines[i…] and earlier result `cand`, stopping at pinned lines. */
+  runLength(hashes, cand, i) {
+    const earlier = this.results.get(cand.call);
+    if (!earlier) return 0;
+    let k = 0;
+    while (i + k < hashes.length && cand.index + k < earlier.hashes.length && earlier.hashes[cand.index + k] === hashes[i + k] && !this.isPinned(hashes[i + k])) k++;
+    return k;
+  }
+
+  /** Longest earlier run starting at lines[i]; null when shorter than MIN_RUN or not substantive enough. */
+  longestRun(hashes, lines, i) {
+    const candidates = this.occurrences.get(hashes[i]);
+    if (!candidates) return null;
+    let best = null;
+    for (const cand of candidates.slice(-MAX_CANDIDATES)) {
+      const length = this.runLength(hashes, cand, i);
+      if (length >= MIN_RUN && (!best || length > best.length)) best = { call: cand.call, index: cand.index, length };
+    }
+    if (!best) return null;
+    const substantiveCount = lines.slice(i, i + best.length).filter(substantive).length;
+    return substantiveCount >= MIN_SUBSTANTIVE ? best : null;
+  }
+
+  /** "path:a–b" when every line of the run has consecutive provenance in one file, else "". */
+  citation(hashes, i, length) {
+    const first = this.origins.get(hashes[i]);
+    if (!first) return "";
+    let expectLine = first.line;
+    for (let k = 0; k < length; k++) {
+      const o = this.origins.get(hashes[i + k]);
+      if (o) {
+        if (o.path !== first.path || o.line < expectLine) return "";
+        expectLine = o.line + 1;
+      } else {
+        expectLine++;
+      }
+    }
+    return first.path + ":" + first.line + "–" + (expectLine - 1);
+  }
+
+  /**
+   * Collapse runs already shown; returns the text to send and remembers exactly that text as call N.
+   */
+  dedupe(text, call) {
+    const lines = text.split("\n");
+    if (lines.length < MIN_RUN) {
+      this.stats.returnedChars += text.length;
+      this.remember(call, lines);
+      return text;
+    }
+    const hashes = new Uint32Array(lines.length);
+    for (let i = 0; i < lines.length; i++) hashes[i] = hashLine(lines[i]);
+    const out = [];
+    let collapsedChars = 0;
+    for (let i = 0; i < lines.length; ) {
+      const run = substantive(lines[i]) ? this.longestRun(hashes, lines, i) : null;
+      if (!run) {
+        out.push(lines[i]);
+        i++;
+        continue;
+      }
+      const cite = this.citation(hashes, i, run.length);
+      out.push("⋯ " + run.length + " lines same as #" + run.call + (cite ? " · " + cite : "") + " ⋯");
+      for (let k = 0; k < run.length; k++) collapsedChars += lines[i + k].length + 1;
+      this.stats.collapsedRuns++;
+      i += run.length;
+    }
+    const sent = out.join("\n");
+    this.stats.returnedChars += sent.length;
+    this.stats.collapsedChars += collapsedChars;
+    this.remember(call, out);
+    return sent;
+  }
+
+  remember(call, lines) {
+    if (this.storedLines + lines.length > MAX_STORED_LINES) {
+      for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
+        this.forget(old);
+        if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
+      }
+    }
+    const hashes = new Uint32Array(lines.length);
+    for (let i = 0; i < lines.length; i++) {
+      hashes[i] = hashLine(lines[i]);
+      if (!substantive(lines[i])) continue;
+      let list = this.occurrences.get(hashes[i]);
+      if (!list) this.occurrences.set(hashes[i], (list = []));
+      list.push({ call, index: i });
+    }
+    this.results.set(call, { hashes });
+    this.storedLines += lines.length;
+  }
+}

package/omp-frame.js

@@ -1,7 +1,7 @@
 /**
  * Shared Pi/OMP rounded tool chrome for supernova.
  *
- * Intentionally self-contained — never dynamic-imports `@oh-my-pi/pi-coding-agent`
+ * Intentionally self-contained: never dynamic-imports `@oh-my-pi/pi-coding-agent`
  * (that hung OMP plugin load). Portable geometry matches native edit/write cards.
  */
 
@@ -43,30 +43,15 @@ function borderPaint(theme, state, borderColor) {
 	return (text) => text;
 }
 
-function resolveStatusIcon({ icon, iconOverride, state }) {
-	if (iconOverride !== undefined) return undefined;
-	if (icon !== undefined) return icon;
-	return state === "error" ? "error" : undefined;
-}
-
-const STATUS_GLYPH = { error: "✗ ", running: "… " };
-const STATUS_COLOR = { error: "error", running: "dim" };
-
-function statusPrefix(theme, resolvedIcon, iconOverride, spinnerFrame) {
-	if (iconOverride) return `${iconOverride} `;
-	const key = resolvedIcon === "error" ? "error" : resolvedIcon === "running" || spinnerFrame ? "running" : undefined;
-	const glyph = STATUS_GLYPH[key];
-	if (!glyph) return "";
-	return theme?.fg ? theme.fg(STATUS_COLOR[key], glyph) : glyph;
-}
+const STATUS_PREFIX = { error: ["error", "✗ "], running: ["dim", "… "] };
 
-function statusHeader(theme, { title, description, state, spinnerFrame, icon, iconOverride }) {
-	const resolvedIcon = resolveStatusIcon({ icon, iconOverride, state });
+function statusHeader(theme, { title, description, state, icon }) {
+	const resolved = icon ?? (state === "error" ? "error" : undefined);
+	const prefixSpec = STATUS_PREFIX[resolved];
+	const prefix = prefixSpec ? (theme?.fg ? theme.fg(prefixSpec[0], prefixSpec[1]) : prefixSpec[1]) : "";
 	const titleText = theme?.fg ? theme.fg("accent", title) : title;
 	const descText = description ? (theme?.fg ? theme.fg("muted", description) : description) : "";
-	const prefix = statusPrefix(theme, resolvedIcon, iconOverride, spinnerFrame);
-	if (!descText) return `${prefix}${titleText}`;
-	return `${prefix}${titleText}: ${descText}`;
+	return descText ? `${prefix}${titleText}: ${descText}` : `${prefix}${titleText}`;
 }
 
 function padLine(line, width, bgFn) {

package/outline.js

@@ -0,0 +1,80 @@
+import { WorkspaceIndex } from "./repo-index.js";
+import { tokenizeQuery } from "./snap.js";
+import { stem } from "./evidence.js";
+
+// read(path, { about }): one call, whole-file structure, only the relevant bodies expanded.
+// L0 (names) and L1 (signatures + line ranges) for every declaration; L2 (full text) for the
+// spans that match the question, within a character budget. The model reads a 600-line file
+// in ~15% of its tokens and knows the exact read(path, offset, limit) to issue for anything folded.
+
+const OUTLINE_DEFAULTS = { maxChars: 8000, maxExpanded: 6, headerLines: 30, maxRefs: 5, references: null };
+
+
+function relevance(span, lower, stems) {
+  if (stems.length === 0) return 0;
+  const nameLower = span.name.toLowerCase();
+  let score = 0;
+  for (const s of stems) if (nameLower.includes(s)) score += 40;
+  for (let i = span.start - 1; i < span.end; i++) {
+    let hits = 0;
+    for (const s of stems) if (lower[i].includes(s)) hits++;
+    score += hits * hits * 5;
+  }
+  return score;
+}
+
+function chooseExpanded(spans, lower, stems, raw, opts) {
+  const scored = spans.map((s, i) => ({ i, r: relevance(s, lower, stems), chars: raw.slice(s.start - 1, s.end).join("\n").length }));
+  scored.sort((a, b) => b.r - a.r || a.i - b.i);
+  const expanded = new Set();
+  let budget = opts.maxChars;
+  // Weak-match cutoff (as fff's weak-match detector): stop once relevance falls below 40% of the best span.
+  const floor = stems.length > 0 ? Math.max(1, scored[0].r * 0.4) : 0;
+  for (const { i, r, chars } of scored) {
+    if (expanded.size >= opts.maxExpanded || r < floor) break;
+    if (chars > budget) continue;
+    expanded.add(i);
+    budget -= chars;
+  }
+  return expanded;
+}
+
+function foldedLine(span) {
+  const body = span.end - span.start;
+  const sig = span.signature.replace(/\s*\{\s*$/, "");
+  return String(span.start).padStart(5) + " " + sig + (body > 0 ? " … " + body + " lines" : "");
+}
+
+function expandedBlock(span, raw, opts) {
+  const out = [];
+  for (let l = span.start; l <= span.end; l++) out.push(String(l).padStart(5) + " " + raw[l - 1]);
+  const refs = opts.references ? opts.references(span.name, span.start) : [];
+  // Who uses this declaration: the relation a reader would otherwise grep for next.
+  if (refs.length) out.push("      // used by: " + refs.slice(0, opts.maxRefs).join(", ") + (refs.length > opts.maxRefs ? " (+" + (refs.length - opts.maxRefs) + ")" : ""));
+  return out.join("\n");
+}
+
+/**
+ * @param entry index entry (text + cached lines/surface)
+ * @param about question or symbol; empty ⇒ pure skeleton (every body folded)
+ */
+export function outlineFile(entry, relPath, about, options = {}) {
+  const opts = { ...OUTLINE_DEFAULTS, ...options };
+  const { raw, lower } = WorkspaceIndex.linesOf(entry);
+  const lineCount = raw.length;
+  const spans = WorkspaceIndex.spansOf(entry).map((s) => ({ ...s, signature: raw[s.start - 1].trim() }));
+  if (spans.length === 0) return null; // no structure: caller falls back to plain text
+  const stems = [...new Set(tokenizeQuery(about || "").tokens.map(stem))];
+  const expanded = chooseExpanded(spans, lower, stems, raw, opts);
+
+  const parts = [];
+  const headerEnd = Math.min(spans[0].start - 1, opts.headerLines);
+  if (headerEnd > 0) {
+    const header = raw.slice(0, headerEnd).filter((l) => l.trim());
+    if (header.length) parts.push(header.map((l, i) => String(i + 1).padStart(5) + " " + l).join("\n"));
+    if (spans[0].start - 1 > opts.headerLines) parts.push("      … " + (spans[0].start - 1 - opts.headerLines) + " more header lines");
+  }
+  for (let i = 0; i < spans.length; i++) parts.push(expanded.has(i) ? expandedBlock(spans[i], raw, opts) : foldedLine(spans[i]));
+  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (about ? " for \"" + about + "\"" : "") + " · read(path, line, count) for a folded body";
+  return { text: title + "\n" + parts.join("\n"), expanded: expanded.size, declarations: spans.length };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.0.8",
+  "version": "0.0.15",
   "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
   "type": "module",
   "author": "AdityaVG13",
@@ -30,6 +30,13 @@
     "parallel.js",
     "runtime.js",
     "guest-worker.js",
+    "repo-index.js",
+    "evidence.js",
+    "fuzzy.js",
+    "outline.js",
+    "ledger.js",
+    "check.js",
+    "search.js",
     "format.js",
     "patch.js",
     "vfs.js",

package/render-measure.js

@@ -9,9 +9,9 @@ import { stripVTControlCharacters } from "node:util";
 const ELLIPSIS = "…";
 
 /**
- * Visible columns — ANSI/OSC stripped, tabs → 3 spaces.
+ * 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).
+ * / pi-tui behavior (emoji & symbols like ⚡ are 2 cols; an undercount is the 92>91 crash).
  */
 export function measureWidth(text) {
 	const raw = String(text ?? "").replace(/\t/g, "   ");
@@ -119,33 +119,6 @@ export function clampLine(line, width) {
 	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) {
-		const { end, lastBreak } = takeChunk(text, i, w);
-		if (end === i) {
-			const ch = text.codePointAt(i) > 0xffff ? text.slice(i, i + 2) : text[i];
-			lines.push(hardTruncate(ch, w));
-			i += ch.length;
-			continue;
-		}
-		let cut = end;
-		if (end < text.length && lastBreak > i + Math.floor(w * 0.35)) cut = lastBreak;
-		lines.push(text.slice(i, cut));
-		i = cut;
-	}
-	return lines;
-}
-
 /**
  * Fit a filesystem path into `budget` columns, keeping the basename visible.
  */
@@ -160,4 +133,3 @@ export function fitPath(pathText, budget) {
 	return hardTruncate(base, w);
 }
 
-export { ELLIPSIS };

package/render.js

@@ -12,124 +12,11 @@
 
 import { stripVTControlCharacters } from "node:util";
 import { isString, isObject, isFunction } from "./decode.js";
-import {
-	measureWidth,
-	hardTruncate,
-	clampLine,
-	wrapPlainToWidth,
-	fitPath,
-} from "./render-measure.js";
+import { measureWidth, hardTruncate, clampLine, fitPath } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 import { formatValue } from "./format.js";
 
-export { measureWidth, hardTruncate, clampLine, wrapPlainToWidth, fitPath };
-
-function fitOutputLines(text, width) {
-	const w = Math.max(1, width | 0);
-	const out = [];
-	for (const line of String(text ?? "")
-		.replace(/\t/g, "   ")
-		.split("\n")) {
-		if (measureWidth(line) <= w) {
-			out.push(line);
-			continue;
-		}
-		// Wrap on plain text so long paths continue on the next line instead of
-		// dying as `packages/pi-supern…`. ANSI is dropped on wrap (crash-safety).
-		const plain = stripVTControlCharacters(line);
-		for (const chunk of wrapPlainToWidth(plain, w)) {
-			out.push(clampLine(chunk, w));
-		}
-	}
-	return out.length > 0 ? out : [""];
-}
-
-/** Compact bounded text; the host supplies the card background and borders. */
-export class SafeText {
-	constructor(text = "") {
-		this.text = text;
-	}
-	setText(text) {
-		this.text = text;
-	}
-	invalidate() {}
-	render(width = 80) {
-		const raw = String(this.text ?? "");
-		return raw.trim() ? fitOutputLines(raw, Math.max(1, width | 0)) : [];
-	}
-}
-
-// Keep names some tests / older call sites may import.
-export const visibleWidth = measureWidth;
-export const truncateToWidth = hardTruncate;
-
-export function extractOperationsFromCode(code) {
-	const trimmed = String(code || "").trim();
-	if (!trimmed) return [];
-
-	const ops = [];
-	const seen = new Set();
-
-	const addOp = (tool, target) => {
-		const key = `${tool}:${target}`;
-		if (!seen.has(key)) {
-			seen.add(key);
-			ops.push({ tool, target });
-		}
-	};
-
-	const callRegex = /nova\.call\s*\(\s*["'`]([a-zA-Z0-9_-]+)["'`](?:\s*,\s*(\{[\s\S]*?\}))?/g;
-	let match;
-	while ((match = callRegex.exec(trimmed)) !== null) {
-		const tool = match[1];
-		let target = "";
-		if (match[2]) {
-			const pathMatch = /path\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const cmdMatch = /command\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const patMatch = /pattern\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			if (pathMatch) target = pathMatch[1];
-			else if (cmdMatch) target = cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + "…" : cmdMatch[1];
-			else if (patMatch) target = patMatch[1];
-		}
-		addOp(tool, target);
-	}
-
-	const callManyRegex = /nova\.callMany\s*\(\s*\[([\s\S]*?)\]\s*\)/g;
-	while ((match = callManyRegex.exec(trimmed)) !== null) {
-		const inner = match[1];
-		const subCalls = inner.matchAll(/name\s*:\s*["'`]([a-zA-Z0-9_-]+)["'`]/g);
-		for (const sub of subCalls) addOp(sub[1], "");
-	}
-
-	const namedCalls = [
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?read\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "read", 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: "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: "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) {
-			addOp(item.tool, item.wrap(match[1]));
-		}
-	}
-
-	if (/nova\.speculate\s*\(/.test(trimmed)) {
-		addOp("speculate", "(branch foam)");
-	}
-
-	return ops;
-}
+export { measureWidth, hardTruncate, clampLine };
 
 function formatDiffRows(diff, theme, maxShown = 6) {
 	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return [];
@@ -178,7 +65,7 @@ function displayOperation(tool, target, diff, ok, item) {
 	const rawName = cleanInlineText(tool);
 	if (!rawName) return null;
 	const normalized = rawName === "apply_patch" ? "patch" : rawName;
-	return { tool: normalized, target, diff, ok, ms: item?.ms, exitCode: item?.exitCode, time: item?.time };
+	return { tool: normalized, target, diff, ok, ms: item?.ms, exitCode: item?.exitCode, time: item?.time, error: item?.error };
 }
 
 function isTheme(value) {
@@ -217,7 +104,7 @@ export function normalizeCallRenderArgs(a, b, c) {
 /**
  * Dual-host renderResult args:
  *   Pi:  (result, {expanded,isPartial}, theme, context)
- *   OMP: (result, {expanded,isPartial}, theme, args)  — 4th is args, not 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
  * fourth argument's context-versus-args shape.
@@ -237,7 +124,7 @@ function detectResultHost(options, ctxOrArgs) {
 	return "pi";
 }
 
-export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
+function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
 	if (isTheme(themeOrCtx)) {
 		const opts = isObject(options) ? options : {};
 		const context = contextFrom(opts, ctxOrArgs);
@@ -271,6 +158,11 @@ export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs
 	throw new Error("supernova renderResult: theme missing (expected Pi or OMP signature)");
 }
 
+function batchTarget(paths) {
+	const names = paths.map((p) => String(p).replace(/\\/g, "/").split("/").pop());
+	return `${paths.length} files: ${names.join(", ")}`;
+}
+
 const OPERATION_TARGETS = [
 	[(item) => item?.name === "snap", (item, args) => {
 		const query = args.query ? `"${args.query}"` : "";
@@ -278,6 +170,7 @@ const OPERATION_TARGETS = [
 		return `${query} → ${args.path}`;
 	}],
 	[(item) => item?.name === "search", (item, args) => (args.query ? `"${args.query}"` : "")],
+	[(item, args) => Array.isArray(args.path), (item, args) => batchTarget(args.path)],
 	[(item, args) => args.path, (item, args) => String(args.path)],
 	[(item) => item?.diff?.path, (item) => String(item.diff.path)],
 	[(item, args) => args.target && isString(args.target), (item, args) => args.target],
@@ -327,20 +220,21 @@ function operationsFromTrace(trace) {
 		.filter(Boolean);
 }
 
+// The call slot is always empty: the result card owns the whole lifecycle in both hosts.
+const EMPTY_CALL = { render: () => [], invalidate() {} };
+
 export function renderSupernovaCall(a, b, c) {
 	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;
+	if (options) options.lastComponent = EMPTY_CALL;
+	else if (context) context.lastComponent = EMPTY_CALL;
+	return EMPTY_CALL;
 }
 
 const TOOL_COL = 7;
 const DURATION_COL = 6;
 const PREVIEW_LINES = 24;
 
-export function formatDuration(ms) {
+function formatDuration(ms) {
 	if (!Number.isFinite(ms) || ms < 0) return "";
 	if (ms < 1000) return `${Math.round(ms)}ms`;
 	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
@@ -405,15 +299,15 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 		prefix += theme.fg("toolDiffAdded", added) + theme.fg("dim", "/") + theme.fg("toolDiffRemoved", removed) + " ";
 		used += added.length + 1 + removed.length + 1;
 	}
-	const target = formatTarget(op, Math.max(1, width - used));
-	return prefix + (target ? theme.fg("muted", target) : theme.fg("dim", "done"));
+	const budget = Math.max(1, width - used);
+	const target = formatTarget(op, budget);
+	if (target) return prefix + theme.fg("muted", target);
+	if (op.ok === false && op.error) return prefix + theme.fg("error", clampLine(cleanInlineText(op.error), budget));
+	return prefix.trimEnd();
 }
 
-function operationsFor(payload, context, args) {
-	const trace = payload?.trace || context?.state?.trace || [];
-	const traced = operationsFromTrace(trace);
-	if (traced.length > 0) return traced;
-	return extractOperationsFromCode(args?.code).map((op) => displayOperation(op.tool, op.target)).filter(Boolean);
+function operationsFor(payload, context) {
+	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
 }
 
 function resultLines(value, maxLines) {
@@ -466,32 +360,34 @@ class UnifiedResultCard {
 	set(theme, model) {
 		this.theme = theme;
 		this.model = model;
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	invalidate() {
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	render(width = 80) {
 		const { theme, model } = this;
 		if (!theme || !model) return [];
-		if (!this.frame) {
-			this.frame = novaFramedBlock(theme, (frameWidth) => {
-				const contentWidth = Math.max(1, frameWidth - 4);
-				const view = buildBodyLines(theme, contentWidth, model);
-				return {
-					header: novaStatusLine(theme, {
-						icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
-						title: "nova",
-						description: describeCard(model, view.opCount),
-					}),
-					sections: view.lines.length > 0 ? [{ lines: view.lines }] : [],
+		if (this.cache?.width === width) return this.cache.lines;
+		const view = buildBodyLines(theme, Math.max(1, width - 4), model);
+		const header = novaStatusLine(theme, {
+			icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
+			title: "nova",
+			description: describeCard(model, view.opCount),
+		});
+		// A program with no host calls has nothing to frame: one status line, no empty box.
+		const lines = view.lines.length === 0
+			? [clampLine(header, width)]
+			: novaFramedBlock(theme, () => ({
+					header,
+					sections: [{ lines: view.lines }],
 					state: model.isError ? "error" : model.isPartial ? "pending" : "success",
-					borderColor: model.isError ? "error" : "borderMuted",
-					width: frameWidth,
-				};
-			});
-		}
-		return this.frame.render(width);
+					// borderMuted is invisible on OMP's card background; dim matches the duration column.
+					borderColor: model.isError ? "error" : "dim",
+					width,
+				})).render(width);
+		this.cache = { width, lines };
+		return lines;
 	}
 }