pi-supernova 0.0.11 → 0.0.15

package/index.js

@@ -4,16 +4,11 @@ import { buildCatalog, searchCatalog, describeTool, mergeNativeToolDefinitions }
 import { loadConfig } from "./config.js";
 import { createHostBridge } from "./host-bridge.js";
 import { runGuestProgram, warmGuestWorker } from "./runtime.js";
-import {
-  extractOperationsFromCode,
-  renderSupernovaCall,
-  renderSupernovaResult,
-  SafeText,
-} from "./render.js";
+import { renderSupernovaCall, renderSupernovaResult } from "./render.js";
 
-export { extractOperationsFromCode, renderSupernovaCall, renderSupernovaResult, SafeText };
+export { renderSupernovaCall, renderSupernovaResult };
 
-// Sync only — never top-level await. Dynamic import of host/deps hung OMP plugin load.
+// Sync only, never top-level await. Dynamic import of host/deps hung OMP plugin load.
 const require = createRequire(import.meta.url);
 let Type;
 try {
@@ -71,48 +66,44 @@ function progressEmitter(onUpdate) {
   return emit;
 }
 
+function sessionStats({ programs, returnedChars, collapsedChars, collapsedRuns }) {
+  const total = returnedChars + collapsedChars;
+  const pct = total ? Math.round((collapsedChars / total) * 100) : 0;
+  return `this session: ${programs} programs · ~${Math.round(returnedChars / 4)} tokens returned · ~${Math.round(collapsedChars / 4)} already-seen tokens not re-sent (${pct}%, ${collapsedRuns} runs)`;
+}
+
 function logsBlock(outcome, tail = "") {
   return outcome.logs?.length ? `\n--- logs\n${outcome.logs.join("\n")}${tail}` : "";
 }
 
-function errorText(outcome) {
-  return `error ${outcome.wallMs}ms: ${outcome.error}${logsBlock(outcome)}`;
+function errorText(outcome, call) {
+  return `error #${call} ${outcome.wallMs}ms: ${outcome.error}${logsBlock(outcome)}`;
 }
 
-function successText(outcome) {
+function successText(outcome, call) {
   const truncated = outcome.returnTruncated ? " [return truncated]" : "";
-  const hint = outcome.undefinedReturn ? " (no return statement — add \`return\` to get a value)" : "";
-  return `ok ${outcome.wallMs}ms${truncated}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
-}
-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 hint = outcome.undefinedReturn ? " (no return statement; add \`return\` to get a value)" : "";
+  return `ok #${call} ${outcome.wallMs}ms${truncated}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
 }
-
 const TOOL_DESCRIPTION = `Run one JavaScript program that composes host tools. Async body or arrow; \`return\` a small shaped value (compact literal, capped; strings raw; console.log is captured).
 
 Globals (async):
-read(path|paths, offset?, limit?) → text | text[]
-write(path, text) · edit(path, oldText, newText) · patch(path, unifiedDiff)
+read(path|paths, offset?, limit?) → text | text[] · read(path, {about}) → whole-file outline, only relevant bodies expanded
+write(path, text) · edit(path, oldText, newText) → post-edit lines (no re-read needed) · patch(path, unifiedDiff)
 bash(cmd, {cwd?, timeoutMs?}) → output, throws on non-zero exit · exec(cmd, argv?) quotes argv
-evidence(query, {k?}) → {spans: [{path, lines, name, text}]} top-K spans that answer a question — use before read
+evidence(query, {k?}) → {spans: [{path, lines, name, text}]} top-K spans that answer a question; use before read
 snap(query, root?) → {path, line, signature, context} · surface(path) → {items: [{name, kind, line}]}
 nova.call(name, args) → {ok, value} for any host tool · nova.callMany([{name, args}]) parallel when read-only
 nova.search(query) → [{name, description}] · nova.describe(name) → parameters · nova.has(name) sync
-parallel(thunks) · pipeline(items, ...stages)`;
+parallel(thunks) · pipeline(items, ...stages)
+
+Already-seen lines collapse to "⋯ N lines same as #12 · path:a–b ⋯"; read(path, a, n) re-shows them.`;
 
 export default function piSupernova(pi) {
   const config = loadConfig();
   let cwd = process.cwd();
   let catalog = [];
+  let programSeq = 0;
 
   const bridge = createHostBridge({
     pi,
@@ -164,12 +155,6 @@ export default function piSupernova(pi) {
         const cat = catalog.length ? catalog : refreshCatalog();
         return [...new Set([...cat.map((t) => t.name), ...bridge.executors.keys(), ...Object.keys(bridge.natives)])];
       },
-      async surface(filePath) {
-        return unwrapStructuredResult(await bridge.call("surface", { path: filePath }), "surface");
-      },
-      async snap(query, targetPath) {
-        return unwrapStructuredResult(await bridge.call("snap", { query, path: targetPath }), "snap");
-      },
     };
   }
 
@@ -179,7 +164,7 @@ export default function piSupernova(pi) {
     description: TOOL_DESCRIPTION,
     promptSnippet: "Compose host tools in one JavaScript program",
     promptGuidelines: [
-      "Use supernova for multi-step tool work: loops, filtering, parallel reads, read→edit chains. To understand code, call evidence(question) and read only the returned spans; read whole files only to edit them. Return a compact shaped value; keep raw tool output inside the program.",
+      "Use supernova for multi-step tool work: loops, filtering, parallel reads, read→edit chains. To understand code: evidence(question) across the repo, or read(path, {about: question}) for one file: full structure, only relevant bodies expanded. Plain read(path) only for lines you will edit. Return a compact shaped value; keep raw tool output inside the program.",
     ],
     parameters: Type.Object({
       code: Type.String({ description: "JavaScript program: async body or arrow function." }),
@@ -202,6 +187,8 @@ export default function piSupernova(pi) {
       bridge.resetCallBudget();
       refreshCatalog();
       bridge.beginSpeculation();
+      const call = ++programSeq;
+      bridge.ledger.beginProgram(call);
       const emitProgress = progressEmitter(onUpdate);
       bridge.setCallListener((_record, allTrace) => emitProgress(allTrace));
       emitProgress([]);
@@ -218,10 +205,10 @@ export default function piSupernova(pi) {
       const trace = bridge.getTrace();
       if (!outcome.ok) {
         bridge.rollbackSpeculation();
-        return result(errorText(outcome), { ok: false, error: outcome.error, wallMs: outcome.wallMs, logs: outcome.logs, trace });
+        return result(bridge.ledger.dedupe(errorText(outcome, call), call), { ok: false, error: outcome.error, wallMs: outcome.wallMs, logs: outcome.logs, trace });
       }
       await bridge.commitSpeculation();
-      return result(successText(outcome), {
+      return result(bridge.ledger.dedupe(successText(outcome, call), call), {
         ok: true,
         wallMs: outcome.wallMs,
         returnTruncated: outcome.returnTruncated,
@@ -253,6 +240,9 @@ export default function piSupernova(pi) {
 
   pi.on("session_start", (_event, ctx) => {
     if (ctx && isString(ctx.cwd) && ctx.cwd) cwd = ctx.cwd;
+    // A new session is a new model context: nothing has been seen yet.
+    bridge.ledger.reset();
+    programSeq = 0;
     refreshCatalog();
     warmGuestWorker(config).catch(() => {});
   });
@@ -265,9 +255,10 @@ export default function piSupernova(pi) {
       const natives = Object.keys(bridge.natives).sort();
       const lines = [
         `pi-supernova catalog: ${catalog.length} tools`,
-        `captured executors: ${captured.length ? captured.join(", ") : "(none yet — load this package early)"}`,
+        `captured executors: ${captured.length ? captured.join(", ") : "(none yet; load this package early)"}`,
         `native adapters: ${natives.join(", ")}`,
         `timeoutMs=${config.timeoutMs} maxCallResultChars=${config.maxCallResultChars} maxReturnChars=${config.maxReturnChars} maxBridgeCalls=${config.maxBridgeCalls} maxHeapMb=${config.maxHeapMb}`,
+        sessionStats(bridge.ledger.stats),
       ];
       ctx.ui.notify(lines.join("\n"), "info");
     },

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.11",
+  "version": "0.0.15",
   "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
   "type": "module",
   "author": "AdityaVG13",
@@ -32,6 +32,11 @@
     "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 };