pi-supernova 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -2,9 +2,32 @@
 
 ## [Unreleased]
 
+## [0.0.6] - 2026-09-03
+
+### Changed
+
+- Pi and OMP now share one self-owned framed result card. The hidden call slot prevents duplicate lifecycle cards, and connected rows preserve visual separation between calls.
+
+### Fixed
+
+- Edit, write, and patch calls now show bounded line-numbered removed/added hunks while collapsed, with a larger budget when expanded; captured host executors propagate their native diff metadata into the same UI.
+
+- Direct `nova.snap()` and `nova.surface()` helpers now return structured objects instead of host result envelopes.
+- Package metadata now matches the official Pi package contract: every `files` entry exists, and only the actually imported `typebox` host dependency remains declared as a peer.
+
+## [0.0.5] - 2026-09-03
+
 ### Fixed
 
 - 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.
+- `snap` discovers explicitly targeted hidden paths outside `.git` and sees files written earlier in the same speculative invocation.
+- Top-level `snap()` and `surface()` helpers return structured objects, enabling an immediate `edit(hit.path, ...)` handoff.
+- Live command activity remains visible across partial updates and final merged cards.
+- Collapsed cards show a compact, correctly labeled call ledger with paths and change counts; diff hunks are bounded and shown only when expanded.
+- Multi-replacement edits report only the changed hunks instead of presenting the entire file as replaced.
+- Syntax errors now roll back the outer VFS transaction instead of leaking speculative depth into the next Supernova call.
+- Root-level Snap searches continue to ignore hidden files; hidden discovery is enabled only when the caller explicitly targets a hidden search root, while Git metadata remains excluded.
+- Command cards cover custom tools, mark failed traces accurately, sanitize terminal controls, and remain width-safe for narrow terminals and wide emoji.
 
 ## [0.0.4] - 2026-09-03
 

package/README.md

@@ -46,16 +46,22 @@ async () => {
 }
 ```
 
-Globals: `nova` / `tools`, `parallel`, `pipeline`, `console`, plus shorthand `read` / `write` / `edit` / `bash` / …
+Globals: `nova` / `tools`, `parallel`, `pipeline`, `console`, plus shorthand `read`, `write`, `edit`, `patch`, `surface`, `snap`, `bash`, and `exec`.
 
-Terminal card (muted violet / grey-blue — not a raw JSON args dump):
+Unified Pi/OMP card with bounded mutation diffs visible while collapsed:
 
 ```text
-  nova · 84ms
-    ▤ read  packages/pi-supernova/host-bridge.js
-    ✎ edit  packages/pi-supernova/diff.js
+╭─── nova: 2 calls · 84ms ───────────────────────────────╮
+│ ├─ ✓ read    packages/pi-supernova/host-bridge.js       │
+│ │                                                       │
+│ └─ ✓ edit   +1/-1 packages/pi-supernova/diff.js         │
+│       -143 │ - const oldValue = before;                 │
+│       +143 │ + const newValue = after;                  │
+╰─────────────────────────────────────────────────────────╯
 ```
 
+Collapsed cards show bounded edit/write/patch hunks immediately. Press Enter for a larger hunk budget, logs, and the returned value.
+
 ---
 
 ## API
@@ -66,9 +72,14 @@ Terminal card (muted violet / grey-blue — not a raw JSON args dump):
 | `nova.describe(name)` | Parameter summary on demand |
 | `nova.call(name, args)` | Host tool or native adapter |
 | `nova.callMany([{name,args}])` | Auto parallel wave — iterable array with `.mode` / `.results` |
+| `nova.surface(path)` | Structural outline for a source file |
+| `nova.snap(query, searchRoot?)` | Most relevant source path, line, signature, confidence, and context |
+| `nova.has(name)` | Whether a catalog or native tool is callable |
 | `parallel(thunks)` / `pipeline(items, …stages)` | Raw `Promise.all` helpers |
 | `nova.speculate(fn)` | Counterfactual branch (rollback / commit) |
 
+Root Snap searches ignore hidden files. Passing a hidden search root includes hidden files beneath that root; Git metadata is always excluded.
+
 ---
 
 ## Configuration
@@ -126,7 +137,7 @@ Pair with DCE last if you use it: `omp install npm:pi-deferred-context-engine`.
 
 - Guest JS is **unsandboxed**. Adapter path jails are not a boundary against `import("node:fs")`.
 - `bash` / mutating tools flush speculative writes (transaction barrier); error rollback cannot undo that.
-- First public cut (`0.0.1`) — APIs and TUI will iterate.
+- Pre-1.0 package — APIs and TUI may still evolve between minor releases.
 
 ## License
 

package/catalog.js

@@ -28,7 +28,10 @@ export const NATIVE_TOOL_DEFINITIONS = [
   },
   {
     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"] },
+    parameters: { type: "object", properties: {
+      query: { type: "string", description: "Source concept to resolve" },
+      path: { type: "string", description: "Optional workspace search root; explicitly targeting a hidden directory includes its hidden files, but Git metadata is always excluded" },
+    }, required: ["query"] },
   },
   {
     name: "surface", description: "Extract a structural outline from a workspace source file.",

package/diff.js

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

package/host-bridge.js

@@ -3,10 +3,10 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
 import { packageHostResult } from "./bottleneck.js";
-import { isString, isNumber, isFunction } from "./decode.js";
+import { isString, isNumber, isFunction, isObject } from "./decode.js";
 import { isMutatingTool, runParallelWave } from "./parallel.js";
 import { extractStructuralSurface } from "./surface.js";
-import { buildEditDiff, buildPatchDiff, buildWriteDiff } from "./diff.js";
+import { buildEditDiff, buildMultiEditDiff, buildPatchDiff, buildWriteDiff } from "./diff.js";
 import { executeSnap } from "./snap.js";
 
 function textResult(text, details) {
@@ -33,7 +33,7 @@ async function resolveWorkspacePath(cwd, inputPath, opName, allowRoot = false) {
   const resolvedCwd = getResolvedCwd(cwd);
   const target = path.resolve(resolvedCwd, inputPath.trim());
   const rel = path.relative(resolvedCwd, target);
-  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+  if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
     throw new Error(`${opName} path escapes workspace`);
   }
   if (!allowRoot && target === resolvedCwd) {
@@ -54,7 +54,7 @@ async function resolveWorkspacePath(cwd, inputPath, opName, allowRoot = false) {
     }
   }
   const realRel = path.relative(realRoot, probe);
-  if (realRel.startsWith("..") || path.isAbsolute(realRel)) {
+  if (realRel === ".." || realRel.startsWith(`..${path.sep}`) || path.isAbsolute(realRel)) {
     throw new Error(`${opName} path escapes workspace through symlink`);
   }
   return target;
@@ -242,6 +242,14 @@ class CausalVfs {
     return undefined;
   }
 
+  getOverlayPaths() {
+    const paths = new Set();
+    for (const overlay of this.overlays) {
+      for (const target of overlay.keys()) paths.add(target);
+    }
+    return [...paths];
+  }
+
   async read(target) {
     const overlay = this.getOverlay(target);
     if (overlay !== undefined) return overlay;
@@ -501,7 +509,7 @@ function createNativeAdapters(getCwd, vfs, config) {
       const diff =
         matches.length === 1
           ? buildEditDiff(target, content, matches[0].oldText, matches[0].newText)
-          : { ...buildWriteDiff(target, content, updated), op: "edit" };
+          : buildMultiEditDiff(target, content, matches);
       const tag = speculative ? " (speculative)" : "";
       return textResult(`edited ${target}${tag}`, { path: target, speculative, diff });
     },
@@ -537,9 +545,14 @@ function createNativeAdapters(getCwd, vfs, config) {
       }
       if (signal?.aborted) throw new Error("aborted");
       const snapTarget = params?.path ? await resolveWorkspacePath(cwd, params.path, "snap", true) : cwd;
+      const relativeRoot = path.relative(cwd, snapTarget);
+      const includeHidden = Boolean(params?.path) && relativeRoot
+        .split(path.sep)
+        .some((segment) => segment.startsWith(".") && segment.length > 1);
       const res = await executeSnap({
         query: params.query,
         searchDir: snapTarget,
+        includeHidden,
         vfs: {
           read: async (candidate) => {
             // Jail each snap candidate (symlink files must not escape the workspace).
@@ -548,6 +561,7 @@ function createNativeAdapters(getCwd, vfs, config) {
           },
         },
         runCommand: (argv, opts) => runCommand(argv, { cwd: snapTarget, signal, ...opts }),
+        pendingPaths: vfs.getOverlayPaths(),
       });
       return textResult(JSON.stringify(res, null, 2), res);
     },
@@ -726,6 +740,25 @@ export function createHostBridge({ pi, config, getCwd }) {
     vfs.clear();
   }
 
+  function resultDiff(response) {
+    let details = response?.details;
+    if (isString(details)) {
+      try {
+        details = JSON.parse(details);
+      } catch {
+        return undefined;
+      }
+    }
+    return isObject(details) ? details.diff : undefined;
+  }
+
+  function notifyCall(record) {
+    if (!callListener) return;
+    try {
+      callListener(record, [...trace]);
+    } catch {}
+  }
+
   async function invokeRaw(name, args) {
     const maxCalls = config.maxBridgeCalls ?? 256;
     callCount += 1;
@@ -745,34 +778,49 @@ export function createHostBridge({ pi, config, getCwd }) {
 
     const record = { name, args: args || {}, time: Date.now() };
     trace.push(record);
+    notifyCall(record);
 
-    const exec = executors.get(name);
-    if (exec) {
-      if (isMutatingTool(name, config)) await vfs.prepareExternalMutation(name);
-      const res = await exec(`supernova:${name}:${callCount}`, args || {}, activeSignal, undefined, activeCtx);
-      if (callListener) {
-        try {
-          callListener(record, [...trace]);
-        } catch {}
+    try {
+      const exec = executors.get(name);
+      if (exec) {
+        let fallbackDiff;
+        if (name === "write" && isString(args?.path) && isString(args?.content)) {
+          const target = await resolveWorkspacePath(getCwd(), args.path, "write", false);
+          let previous = "";
+          try {
+            previous = await vfs.read(target);
+          } catch (error) {
+            if (error?.code !== "ENOENT") throw error;
+          }
+          fallbackDiff = buildWriteDiff(target, previous, args.content);
+        }
+        if (isMutatingTool(name, config)) await vfs.prepareExternalMutation(name);
+        const res = await exec(`supernova:${name}:${callCount}`, args || {}, activeSignal, undefined, activeCtx);
+        const diff = resultDiff(res) || fallbackDiff;
+        record.ok = res?.isError !== true && res?.details?.ok !== false;
+        if (diff && record.ok) record.diff = diff;
+        notifyCall(record);
+        return res;
       }
-      return res;
-    }
 
-    const native = natives[name];
-    if (native) {
-      const res = await native(args || {}, activeSignal);
-      if (res?.details?.diff) record.diff = res.details.diff;
-      if (callListener) {
-        try {
-          callListener(record, [...trace]);
-        } catch {}
+      const native = natives[name];
+      if (native) {
+        const res = await native(args || {}, activeSignal);
+        const diff = resultDiff(res);
+        record.ok = res?.isError !== true && res?.details?.ok !== false;
+        if (diff && record.ok) record.diff = diff;
+        notifyCall(record);
+        return res;
       }
-      return res;
-    }
 
-    throw new Error(
-      `no executor for tool "${name}" (not captured via registerTool and no native adapter). Use nova.describe to inspect; ensure pi-supernova loads before other extensions, or call a core adapter: ${Object.keys(natives).join(", ")}`,
-    );
+      throw new Error(
+        `no executor for tool "${name}" (not captured via registerTool and no native adapter). Use nova.describe to inspect; ensure pi-supernova loads before other extensions, or call a core adapter: ${Object.keys(natives).join(", ")}`,
+      );
+    } catch (error) {
+      record.ok = false;
+      notifyCall(record);
+      throw error;
+    }
   }
 
   async function call(name, args) {

package/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { isString, isFunction } from "./decode.js";
+import { isString, isFunction, isObject } from "./decode.js";
 import { buildCatalog, searchCatalog, describeTool, mergeNativeToolDefinitions } from "./catalog.js";
 import { loadConfig } from "./config.js";
 import { createHostBridge } from "./host-bridge.js";
@@ -30,6 +30,18 @@ try {
 function result(text, details) {
   return { content: [{ type: "text", text }], details };
 }
+function unwrapStructuredResult(response, operation) {
+  if (response?.ok === false) {
+    throw new Error(response.value || response.error || `${operation} failed`);
+  }
+  const value = isObject(response) && "value" in response ? response.value : response;
+  if (!isString(value)) return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
 
 const TOOL_DESCRIPTION = `Execute JavaScript that orchestrates host tools in one shot (Code Mode).
 
@@ -38,8 +50,12 @@ Inside the program you get:
   nova.describe(name)          — full parameter summary on demand
   nova.call(name, args)        — invoke a host tool (or native adapter)
   nova.callMany([{name,args}]) — Auto parallel wave (serial if any mutating)
+  nova.snap(query, root?)       — resolve a concept to a source location
+  nova.surface(path)            — structural source outline
+  nova.has(name)                — test host-tool availability
   parallel(thunks) / pipeline(items, ...stages)
 
+Shorthand globals: read, write, edit, patch, exec, snap, surface.
 Prefer search→describe→call. Keep intermediates in the program; return a shaped value.
 Schemas are NOT dumped into the system prompt — discover them inside the runtime.`;
 
@@ -97,10 +113,10 @@ export default function piSupernova(pi) {
         }
       },
       async surface(filePath) {
-        return bridge.call("surface", { path: filePath });
+        return unwrapStructuredResult(await bridge.call("surface", { path: filePath }), "surface");
       },
       async snap(query, targetPath) {
-        return bridge.call("snap", { query, path: targetPath });
+        return unwrapStructuredResult(await bridge.call("snap", { query, path: targetPath }), "snap");
       },
       has(name) {
         return bridge.hasExecutor(name) || catalog.some((t) => t.name === name);
@@ -130,8 +146,8 @@ export default function piSupernova(pi) {
         }),
       ),
     }),
-    // "self" = we own chrome. OMP uses native framedBlock (write/edit look);
-    // Pi keeps the muted violet SafeText wash. "default" falls back to raw JSON.
+    // One self-owned result frame is shared by Pi and OMP; renderCall stays empty
+    // so separate call/result slots cannot duplicate the lifecycle card.
     renderShell: "self",
     mergeCallAndResult: true,
     renderCall: renderSupernovaCall,
@@ -159,11 +175,21 @@ export default function piSupernova(pi) {
         }
       });
 
+      if (isFunction(onUpdate)) {
+        try {
+          onUpdate({
+            content: [{ type: "text", text: "" }],
+            details: { trace: [], running: true },
+          });
+        } catch {}
+      }
+
       const runConfig = {
         ...config,
         timeoutMs: Number.isInteger(params?.timeoutMs) ? params.timeoutMs : config.timeoutMs,
       };
 
+      const runStartedAt = performance.now();
       let outcome;
       try {
         outcome = await runGuestProgram({
@@ -173,7 +199,15 @@ export default function piSupernova(pi) {
           signal: runController.signal,
           onTimeout: abortRun,
         });
+      } catch (error) {
+        outcome = {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+          logs: [],
+          wallMs: Math.round(performance.now() - runStartedAt),
+        };
       } finally {
+        bridge.setCallListener(null);
         signal?.removeEventListener("abort", abortRun);
       }
 

package/omp-frame.js

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

package/package.json

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