pi-supernova 0.7.1 → 0.8.1

package/src/output/format.js

@@ -1,4 +1,4 @@
-import { isString, isObject } from "../shared/decode.js";
+import { isString, isObject, mapChangedChildren } from "../shared/decode.js";
 
 function normalizeText(text) {
   return isString(text) ? text : String(text ?? "");
@@ -109,33 +109,41 @@ function formatRawStringArray(value) {
   return raw.length < escapedSize ? raw : null;
 }
 
-function shouldFrameRaw(input) {
-  return isString(input) && input.includes("\n") && !hasUnpairedSurrogate(input) && JSON.stringify(input).length - input.length > 64;
+function rawStringSize(input) {
+  if (!isString(input) || !input.includes("\n") || hasUnpairedSurrogate(input)) return 0;
+  const size = JSON.stringify(input).length;
+
+  return size - input.length > 64 ? size : 0;
 }
 
-function visitRawStrings(input, strings) {
-  if (shouldFrameRaw(input)) {
-    const index = strings.push(input) - 1;
+function visitRawStrings(input, acc) {
+  const size = rawStringSize(input);
+
+  if (size) {
+    const index = acc.strings.push(input) - 1;
+    acc.escapedChars += size;
 
     return { [RAW_TEXT]: "raw[" + index + "]" };
   }
 
-  if (Array.isArray(input)) return input.map(child => visitRawStrings(child, strings));
-
-  if (isObject(input)) return Object.fromEntries(Object.entries(input).map(([key, child]) => [key, visitRawStrings(child, strings)]));
-
-  return input;
+  return mapChangedChildren(input, visitRawStrings, acc);
 }
 
-function framedReturn(value, escaped) {
-  const strings = [];
-  const referencedValue = visitRawStrings(value, strings);
+function framedReturn(value) {
+  const acc = { strings: [], escapedChars: 0 };
+  const referencedValue = visitRawStrings(value, acc);
+  const { strings } = acc;
 
-  if (!strings.length) return escaped;
+  if (!strings.length) return formatValue(value);
   // Keep every key, value, duplicate string and byte. References are unquoted
   // expressions, so literal "raw[0]" values and header-like source cannot collide.
   const framed = formatValue(referencedValue) + "\nraw strings[" + strings.length + "]\n" + strings.map((text, i) => "raw[" + i + "] " + text.length + " UTF-16 units\n" + text + "\n").join("");
 
+  // The ordinary rendering contains at least these complete escaped literals.
+  // If framing beats even that lower bound, do not build the discarded rendering.
+  if (framed.length < acc.escapedChars) return framed;
+  const escaped = formatValue(value);
+
   return framed.length < escaped.length ? framed : escaped;
 }
 
@@ -146,7 +154,7 @@ export function formatReturn(value) {
 
   if (rawArray !== null) return rawArray;
 
-  return framedReturn(value, formatValue(value));
+  return framedReturn(value);
 }
 
 const RAW_TEXT = Symbol("raw text reference");

package/src/runtime/guest-worker.js

@@ -242,7 +242,7 @@ async function runSpeculation(fn, token, checkpointScope, drainReads, enqueueHos
 
     if (began) await enqueueHost(() => rpc("speculateRollback", []));
 
-    return { ok: false, committed: false, error: err instanceof Error ? err.message : String(err) };
+    throw err;
   }
 }
 

package/src/runtime/program-batch.js

@@ -28,42 +28,56 @@ export function programBatchText(results, total, stopped = "", failed = 0) {
     }).join("");
 }
 
-function assertProgramEntry(p) {
+function assertProgramEntry(p, defaults = {}) {
+  const source = p?.code === undefined && p?.file === undefined ? defaults : p;
+
   if (!isObject(p) || Array.isArray(p) || Object.keys(p).some(key => !["code","file","data"].includes(key)) ||
-      ((p.code === undefined) === (p.file === undefined)) || !isString(p.code ?? p.file) || !(p.code ?? p.file).trim()) {
-    throw new Error("each program requires code OR file, with optional data; no nested batches or per-entry timeouts; no programs ran");
+      ((source.code === undefined) === (source.file === undefined)) || !isString(source.code ?? source.file) || !(source.code ?? source.file).trim()) {
+    throw new Error("each program requires code OR file (own or shared), with optional data; no nested batches or per-entry timeouts; no programs ran");
   }
 }
 
-function encodeBatchPayload(params) {
-  const hasDefault = params.data !== undefined;
-  let encoded;
+const objectData = value => isObject(value) && !Array.isArray(value);
 
-  try { encoded = JSON.stringify(hasDefault ? {programs:params.programs,data:params.data} : params.programs); } catch { throw new Error("programs and data must be JSON-serializable; no programs ran"); }
+function applyBatchDefaults(parsed, mergeData) {
+  if (mergeData && !objectData(parsed.data)) throw new Error("mergeData requires top-level object data; no programs ran");
+  const source = parsed.code !== undefined ? {code:parsed.code} : parsed.file !== undefined ? {file:parsed.file} : {};
 
-  return { hasDefault, encoded };
-}
+  return parsed.programs.map(program => {
+    assertProgramEntry(program, source);
+    const entry = program.code === undefined && program.file === undefined ? {...source,...program} : program;
 
-function applyDefaultData(parsed, hasDefault) {
-  if (!hasDefault) return parsed;
-  if (!Object.hasOwn(parsed,"data")) throw new Error("data must be JSON-serializable; no programs ran");
+    if (mergeData) {
+      if (program.data !== undefined && !objectData(program.data)) throw new Error("mergeData requires object data in every explicit entry; no programs ran");
+      // Shallow own-property overlay, including literal __proto__ keys. The
+      // runtime snapshots data again per guest; no mutable heap is shared.
+      entry.data = {...parsed.data,...program.data};
+    } else if (program.data === undefined && Object.hasOwn(parsed,"data")) entry.data = parsed.data;
 
-  // The runtime snapshots data separately for each fresh guest. An explicit
-  // entry replaces the default wholesale; falsy values are not missing values.
-  return parsed.programs.map(program => program.data === undefined ? {...program,data:parsed.data} : program);
+    return entry;
+  });
 }
 
 function parseBatchPayload(params, config) {
-  if (["code","file"].some(key => params[key] !== undefined)) throw new Error("programs cannot combine with top-level code or file; no programs ran");
-
   if (!Array.isArray(params.programs) || !params.programs.length || params.programs.length > 32) throw new Error("programs requires 1..32 entries; no programs ran");
+  if (params.mergeData !== undefined && params.mergeData !== true && params.mergeData !== false) throw new Error("mergeData must be boolean; no programs ran");
+  const defaults = Object.fromEntries(["code","file","data"].filter(key => params[key] !== undefined).map(key => [key,params[key]]));
 
-  for (const p of params.programs) assertProgramEntry(p);
-  const { hasDefault, encoded } = encodeBatchPayload(params);
+  if (defaults.code !== undefined || defaults.file !== undefined) assertProgramEntry(defaults);
+  for (const p of params.programs) assertProgramEntry(p, defaults);
+  const hasDefaults = Object.keys(defaults).length > 0;
+  let encoded;
+
+  try { encoded = JSON.stringify(hasDefaults ? {programs:params.programs,...defaults} : params.programs); } catch { throw new Error("programs and defaults must be JSON-serializable; no programs ran"); }
 
-  if (encoded.length > (config.maxCodeChars ?? 48000)) throw new Error("programs JSON exceeds the code character budget; no programs ran");
+  if (encoded.length > (config.maxCodeChars ?? 48000)) throw new Error("programs JSON exceeds the code character budget (including shared code/file/data); no programs ran");
+  const parsed = hasDefaults ? JSON.parse(encoded) : {programs:JSON.parse(encoded)};
 
-  return applyDefaultData(JSON.parse(encoded), hasDefault);
+  if (Object.hasOwn(defaults,"data") && !Object.hasOwn(parsed,"data")) throw new Error("data must be JSON-serializable; no programs ran");
+
+  // Validate and expand every entry before executing any. Defaults count once
+  // against admission, not once for each independent guest receiving a copy.
+  return applyBatchDefaults(parsed, params.mergeData === true);
 }
 
 function batchTimeoutMs(params, config) {
@@ -132,6 +146,10 @@ class ProgramBatch {
     }
   }
 
+  /** Elapsed and limit: 'deadline or cancellation' alone cannot tell them apart. */
+  deadlineNote() {
+    return " (ran " + Math.round(performance.now() - this.started) + "ms of " + this.timeout + "ms)";
+  }
   takeSettled(result, i) {
     this.results.push(result);
     this.trace.push(...(result.details?.trace ?? []));
@@ -156,7 +174,7 @@ class ProgramBatch {
       this.takeSettled(settled[i], i);
     }
 
-    if (settled.includes(undefined) || this.combined.aborted || performance.now() >= this.deadline) this.stopped = "batch deadline or cancellation; earlier commits remain";
+    if (settled.includes(undefined) || this.combined.aborted || performance.now() >= this.deadline) this.stopped = "batch deadline or cancellation; earlier commits remain" + this.deadlineNote();
   }
 
   sequentialStop(result, i) {
@@ -171,14 +189,15 @@ class ProgramBatch {
 
     if (result.details?.logTruncated) stopped ||= "batch log budget exceeded; remaining programs did not run; earlier commits remain";
 
-    if (this.combined.aborted || performance.now() >= this.deadline) stopped ||= "batch deadline or cancellation; earlier commits remain";
+    // The deadline explains a killed program better than "program N failed".
+    if (this.combined.aborted || performance.now() >= this.deadline) stopped = "batch deadline or cancellation; earlier commits remain" + this.deadlineNote();
 
     return stopped;
   }
 
   async runSequential() {
     for (const [i, program] of this.programs.entries()) {
-      if (this.combined.aborted || performance.now() >= this.deadline) { this.stopped = "deadline or cancellation; remaining programs did not run"; break; }
+      if (this.combined.aborted || performance.now() >= this.deadline) { this.stopped = "deadline or cancellation; remaining programs did not run" + this.deadlineNote(); break; }
 
       const result = await this.runOne(program, i);
       this.live[i] = [];

package/src/runtime/program-file.js

@@ -34,7 +34,10 @@ export async function readProgramFile(file, cwd, maxChars, signal) {
 
     signal?.throwIfAborted();
     // Do not silently replace invalid bytes in executable source. Preserve BOMs.
-    const code = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Buffer.concat(chunks));
+    let code;
+
+    try { code = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Buffer.concat(chunks)); }
+    catch { throw new Error("program file " + file + " is not valid UTF-8 (encoded data could not be decoded); save it as UTF-8 text"); }
 
     if (code.length > chars) throw tooLarge();
 

package/src/runtime/reference.js

@@ -1,19 +1,15 @@
-// Standing tool description: sent on every request. One nova call, four commands inside.
-export const REFERENCE = `JavaScript async body or arrow with read, write, edit, bash. file:path runs that program file instead. Put Markdown/scripts/argv in data. Guest has no fs/import/require.
-
-read(path|paths, offset?, limit?) → raw text or text[]; read(directory) → entries[]
-read(imagePath) → image (PNG/JPEG/GIF/WebP/BMP)
-read({path,json:".field"}) → parsed JSON; .items[0:3], .items.length, quoted keys, or true; 16 MiB cap; no jq
-raw JSON or selections over budget return {status:"too_large",path,keys} (length for arrays); narrow with json:".field" or slices
-read("symbol or question") → same view as resolve:true
-read({query,resolve:true}) → {status,path,line,text,...}
-read(path,{about}) → matching windows; read({query,evidence:true}) → ranked evidence; read({path,outline:true}) → declarations
-write(path, text) → replace an unread file; write({path,content,append:true}) → append without a prior read. After read use edit; replace:true overrides.
-edit(path,oldText,newText) | edit({path,edits}) → numbered post-edit lines, checks, references
-edit(async () => {...}) → checkpoint: commit on success, rollback on throw
-bash(command,{cwd?,timeoutMs?}) → bounded output; nonzero throws
-bash({command,args}) → literal argv
-
-edit oldText is an exact substring of read(); a miss includes a numbered window. Found is a span, not the file. Check resolve:true status; edit(view,text) replaces that window; edit(view,old,new) is unique inside it. complete:true rejects partial files. Array reads reject failures. Edits stage until success; bash commits preceding writes. Batch known reads, edits, and tests in this program (Promise.all, or programs with parallel:true).
-programs:[{code|file,data?},...] sequential fresh guests, separate commits; top-level data defaults per entry. Stop on failure keeps earlier commits. parallel:true runs disjoint entries concurrently. Separate supernova calls only when the next step needs a model decision.
+// Standing tool description: sent on every request. No result or history compression.
+export const REFERENCE = `JS body/async arrow with read/write/edit/bash; no fs/import/require. file runs workspace scripts. data holds literal text/scripts/argv (≤48000 serialized JSON chars).
+read(path|paths,offset=1,limit?) → raw text/text[]; directories → entries; images: PNG/JPEG/GIF/WebP (≤16 attachments/20 MiB total).
+Path-only: ≤160 lines AND 8192 characters (UTF-16). Use read(path,{offset:1,limit:80}), about, or complete:true (whole file ≤31744 chars). Large JSONL: bounded parser via bash.
+read({path,json:selector}) → parsed JSON; selectors ".field", ".a[0:3]", ".a.length", quoted keys, true; 16 MiB input, no jq. Oversized → {status:"too_large",keys} (arrays: length); narrow selectors.
+read("symbol or question") = read({query,resolve:true}) → view; check status; view.text is a span, not the file.
+read(path,{about}) → windows; read({query,evidence:true}) → ranked evidence; read({path,outline:true}) → declarations.
+write(path,text) replaces unread workspace files; write({path,content,append:true}) appends without reading. After read: edit or replace:true.
+edit(path,oldText,newText) | edit({path,edits:[{oldText,newText}]}) exact unique read text; numbered windows (including misses), checks/references.
+edit(view,text) replaces the span; edit(view,old,new) matches uniquely within it. edit(async()=>{...}) checkpoint merges on success, rolls back/rethrows on failure; catch to recover.
+bash(command,{cwd?,timeoutMs?}) | bash({command,args}) literal argv; bounded output, nonzero throws; inherits program timeout unless overridden.
+Edits stage until success; bash commits first. Array errors abort; Promise.allSettled for optional reads.
+programs:[{code?,file?,data?}] inherits top-level code OR file and data. Entry source overrides; data replaces unless mergeData:true (shallow objects, entry keys win).
+Fresh guests/separate commits; sequential failure stops, prior commits stay. parallel:true for disjoint entries. Batch known work; separate calls only for new decisions.
 `;

package/src/runtime/runtime.js

@@ -6,6 +6,7 @@ import { packageFinalReturn } from "../output/bottleneck.js";
 import { truncateChars } from "../output/format.js";
 import { isFunction, isObject, isString } from "../shared/decode.js";
 import { guestImportMessage, isDeniedGuestImport } from "./guest-deny-imports.js";
+import { errorContext } from "../shared/syntax-context.js";
 
 const WORKER_URL = new URL("./guest-worker.js", import.meta.url);
 
@@ -221,7 +222,7 @@ function admitData(data, cap) {
     const encoded = JSON.stringify(data);
 
     if (encoded === undefined) return { error: "data must be JSON-serializable" };
-    if (encoded.length > cap) return { error: "data exceeds " + cap + " characters; split literal inputs across invocations" };
+    if (encoded.length > cap) return { error: "data exceeds " + cap + " characters (serialized JSON: " + encoded.length + " UTF-16 characters); no commands ran. Split literal inputs across invocations; large text can use write({path,content,append:true}) chunks without omitting content" };
 
     return { data: JSON.parse(encoded) };
   } catch { return { error: "data must be JSON-serializable" }; }
@@ -327,7 +328,7 @@ class GuestRun {
     try { this.onTimeout?.(); } catch {}
 
     this.aborting = false;
-    this.finish(this.fail(ABORT_MESSAGE));
+    this.finish(this.fail(ABORT_MESSAGE + " (ran " + Math.round(this.wall()) + "ms of " + this.timeoutMs + "ms)"));
   }
 
   postResult(message) {
@@ -346,7 +347,12 @@ class GuestRun {
 
   async drainPending(outcome) {
     if (this.pending.size || !outcome.ok) this.cancelHost();
-    await Promise.race([Promise.allSettled(this.pending), new Promise(resolve => setTimeout(resolve, 250))]);
+    if (!this.pending.size) return;
+    let timer;
+
+    try {
+      await Promise.race([Promise.allSettled(this.pending), new Promise(resolve => { timer = setTimeout(resolve, 250); })]);
+    } finally { clearTimeout(timer); }
     if (this.pending.size && outcome.ok) this.hostError ??= "program completed with a host call still running";
   }
 
@@ -429,7 +435,14 @@ class GuestRun {
     if (!this.code.trim()) { this.finish(this.fail("code must be a non-empty string; no commands ran")); return false; }
 
     try { this.prepared = prepareProgram(this.code); }
-    catch (error) { this.finish(this.fail("JavaScript syntax error: " + error.message + "; no commands ran. Put literal file/script content in the tool's data parameter and use write(data.path,data.content) or bash({command,args:data.args}).")); return false; }
+    catch (error) {
+      const guidance = this.file === undefined
+        ? " Put literal file/script content in the tool's data parameter and use write(data.path,data.content) or bash({command,args:data.args})."
+        : " Fix " + this.file + " and re-run.";
+
+      this.finish(this.fail("JavaScript syntax error" + (this.file === undefined ? "" : " in " + this.file) + ": " + error.message + "; no commands ran." + guidance + errorContext(this.code, error)));
+      return false;
+    }
 
     return true;
   }

package/src/shared/decode.js

@@ -19,6 +19,36 @@ export function looksLikePath(target) {
   );
 }
 
+/** Transform children without copying unchanged result trees. Never mutate the input. */
+export function mapChangedChildren(value, visit, context) {
+  const array = Array.isArray(value);
+
+  if (!array && !isObject(value)) return value;
+  let out = value;
+
+  for (const key of array ? value.keys() : Object.keys(value)) {
+    if (array && !(key in value)) continue;
+    const before = value[key];
+    const after = visit(before, context);
+
+    if (Object.is(before, after)) continue;
+    if (out === value) out = array ? value.slice() : { ...value };
+    // Define rather than assign: "__proto__" must remain an ordinary data key.
+    Object.defineProperty(out, key, { value: after, enumerable: true, writable: true, configurable: true });
+  }
+
+  return out;
+}
+
+const MODEL_IMAGE_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+
+/** Reject unsupported attachments before they can poison the next model request. */
+export function assertModelImageMime(mimeType) {
+  if (!MODEL_IMAGE_MIMES.has(mimeType)) {
+    throw new Error("unsupported image attachment type " + mimeType + "; model images require PNG, JPEG, GIF, or WebP. Convert the image to PNG before reading/returning it; no image attached");
+  }
+}
+
 const MAX_DEPTH = 64;
 
 const MAX_TYPED_ARRAY = 4096;

package/src/shared/syntax-context.js

@@ -0,0 +1,31 @@
+/** Bounded source context for parse and syntax diagnostics. */
+
+export function sourceContext(source, line, column) {
+  if (!Number.isInteger(line) || line < 1) return "";
+  const text = String(source).split("\n")[line - 1];
+
+  if (text === undefined) return "";
+  const shown = text.length > 160 ? text.slice(0, 160) : text;
+  const caret = Number.isInteger(column) ? " ".repeat(Math.min(column, shown.length)) + "^" : "";
+
+  return "\n  " + shown + (caret ? "\n  " + caret : "");
+}
+
+/** acorn-style error that carries a loc, when it has one. */
+export function errorContext(source, error) {
+  return sourceContext(source, error?.loc?.line, error?.loc?.column);
+}
+
+/** V8 "(line 5 column 3)" or "at position 42" parse messages → a position. */
+export function parsePosition(message, source) {
+  const located = /\(line (\d+) column (\d+)\)/.exec(String(message));
+
+  if (located) return { line: Number(located[1]), column: Number(located[2]) };
+  const offsetMatch = /at position (\d+)/.exec(String(message));
+
+  if (!offsetMatch) return null;
+  const before = String(source).slice(0, Number(offsetMatch[1]));
+  const lines = before.split("\n");
+
+  return { line: lines.length, column: lines.at(-1).length };
+}

package/src/shared/utf8.js

@@ -0,0 +1,17 @@
+/** Strict decode: binary or non-UTF-8 text must fail loudly, never as U+FFFD. */
+export function decodeUtf8Strict(bytes, target) {
+  try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); }
+  catch {
+    throw new Error("not valid UTF-8 (binary or non-UTF-8 text): " + target + "; inspect or convert it with bash (for example iconv -f latin1 -t utf8 or xxd)");
+  }
+}
+
+/** Prefix window: the byte cut may split a character, so drop one partial tail. */
+export function decodeUtf8Window(bytes) {
+  for (let cut = 0; cut <= 3 && cut < bytes.length; cut++) {
+    try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, bytes.length - cut)); }
+    catch { /* a partial character at the cut is expected */ }
+  }
+
+  return bytes.toString("utf8");
+}

package/src/ui/render.js

@@ -373,6 +373,8 @@ function formatTarget(op, budget) {
 function opMarker(theme, op, isPartial, isError) {
 	if (op.ok === false) return theme.fg("error", "×");
 
+	if (op.mutationAttempt) return theme.fg("warning", "·");
+
 	if (op.ok === true) return theme.fg("success", "✓");
 
 	if (isPartial) return theme.fg("dim", "·");
@@ -430,8 +432,9 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	const duration = theme.fg("dim", durationText.padStart(DURATION_COL));
 	const exit = appendExit(theme, op);
 	const counts = appendDiffCounts(theme, op);
-	const prefix = `${marker} ${tool} ${duration}  ` + exit.text + counts.text;
-	const used = 2 + toolText.length + 1 + DURATION_COL + 2 + exit.width + counts.width;
+	const outcome = op.mutationAttempt ? "attempted " : "";
+	const prefix = `${marker} ${tool} ${duration}  ` + exit.text + counts.text + theme.fg("warning", outcome);
+	const used = 2 + toolText.length + 1 + DURATION_COL + 2 + exit.width + counts.width + outcome.length;
 
 	return opRowSuffix(theme, op, prefix, Math.max(1, width - used));
 }
@@ -460,10 +463,22 @@ function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, is
 	if (ops.length > maxOps) lines.push(theme.fg("dim", `  … ${ops.length - maxOps} more calls`));
 }
 
-function appendError(lines, theme, payload, expanded, width) {
-	const error = "✗ " + (payload?.error ? cleanBlockText(payload.error) : "error");
+function appendError(lines, theme, payload, _expanded, width) {
+	const errors = [payload?.error || "error"];
+	for (const [i, program] of (payload?.programs ?? []).entries()) {
+		if (program.details?.ok === false) errors.push(`program ${i + 1}: ${program.details.error || resultTextContent(program)}`);
+	}
+	for (const error of errors) for (const line of resultLines("✗ " + cleanBlockText(error), width)) lines.push(theme.fg("error", line));
+}
 
-	for (const line of expanded ? resultLines(error, width) : error.split("\n")) lines.push(theme.fg("error", line));
+function appendMutations(lines, theme, payload, width) {
+	const m = payload?.mutations;
+	if (!m || !(m.committed || m.rolledBack || m.external || m.pendingCommits || m.recoveryFailed)) return;
+	const summary = `file versions: committed=${m.committed || 0} rolledBack=${m.rolledBack || 0}`
+		+ (m.external ? `; external calls attempted=${m.external}` : "")
+		+ (m.pendingCommits ? `; pendingCommits=${m.pendingCommits}` : "")
+		+ (m.recoveryFailed ? "; recovery failed: inspect files" : "");
+	for (const line of resultLines(summary, width)) lines.push(theme.fg(m.rolledBack || m.recoveryFailed ? "warning" : "dim", line));
 }
 
 function appendResult(lines, theme, payload, expanded, width) {
@@ -502,17 +517,22 @@ function appendOverflow(lines, theme, trace, maxOps, isPartial) {
 }
 
 function appendEmptyOps(lines, theme, ops, isError, isPartial) {
-	if (ops.length === 0 && !isError && !isPartial) lines.push(theme.fg("dim", "no adapter calls"));
+	if (ops.length === 0 && !isError && !isPartial) lines.push(theme.fg("dim", "JavaScript-only execution"));
 }
 
 function buildBodyLines(theme, width, { payload, context, expanded, isPartial, isError }) {
 	const trace = traceFor(payload, context);
 	const { maxOps, maxDiffLines } = bodyLimits(expanded, isPartial);
 	const ops = operationsFromTrace(visibleTrace(trace, maxOps, isPartial));
+	// Trace success records an operation, not persistence of every staged version.
+	// Mixed rollback/commit counts cannot safely be attributed to individual rows.
+	for (const op of ops) op.mutationAttempt = op.ok === true && ["write", "edit", "patch"].includes(op.tool)
+		&& (isPartial || isError || payload?.mutations?.rolledBack > 0 || payload?.mutations?.recoveryFailed);
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
 	appendOverflow(lines, theme, trace, maxOps, isPartial);
-	appendEmptyOps(lines, theme, ops, isError, isPartial);
+	if (!isPartial) appendMutations(lines, theme, payload, width);
+	if (Array.isArray(payload?.trace)) appendEmptyOps(lines, theme, ops, isError, isPartial);
 	appendTail(lines, theme, payload, expanded, isError, width, ops.length === 0 && !isPartial);
 
 	return { lines, opCount: trace.length };
@@ -594,12 +614,14 @@ function syncState(context, payload) {
 	if (payload.wallMs != null && context.state.wallMs !== payload.wallMs) context.state.wallMs = payload.wallMs;
 }
 
-function errorPayload(result) {
-	return result?.isError ? { ok: false, error: result.content?.flatMap(block => block.type === "text" ? [block.text] : []).join("\n") } : undefined;
+function resultTextContent(result) {
+	return result?.content?.flatMap(block => block.type === "text" ? [block.text] : []).join("\n") || "";
 }
 
-function payloadFromResult(result) {
-	return result?.details ?? errorPayload(result);
+function payloadFromResult(result, hostError) {
+	const payload = result?.details;
+	if (hostError) return {...payload, ok:false, error:payload?.error || resultTextContent(result) || "tool execution failed"};
+	return payload ?? {result:resultTextContent(result)};
 }
 
 function bindResultCard(host, options, context) {
@@ -619,9 +641,11 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 		themeArg,
 		contextArg,
 	);
-	const payload = payloadFromResult(result);
+	// Pi omits isError from result and supplies it through render context.
+	const hostError = result?.isError === true || context?.isError === true || options?.isError === true;
+	const payload = payloadFromResult(result, hostError);
 	syncState(context, payload);
-	const isError = result?.isError || payload?.ok === false;
+	const isError = hostError || payload?.ok === false;
 	const comp = bindResultCard(host, options, context);
 	comp.set(theme, { payload, context, args, expanded, isPartial, isError, host });