whale-code 6.5.5 → 6.5.7

package/dist/cli/shared/markdown.js

@@ -5,794 +5,749 @@
  * All chalk instances are rebuilt on theme switch via rebuildMarkdownRenderer().
  * Uses marked + marked-terminal for markdown structure.
  */
+
 import { Marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import chalk from "chalk";
 import { colors } from "./Theme.js";
 import { highlightCode, setRebuildCallback } from "./theme-manager.js";
 import { diffWords } from "diff";
+import { buildPalette, termWidth, contentWidth, toolContentWidth, hyperlink as hyperlinkWithPalette, colorizeFinancials as colorizeFinancialsWithPalette, shortenPathForHeader } from "./markdown-helpers.js";
+
+// Re-export width helpers for consumers that import from markdown.ts
+export { termWidth, contentWidth, toolContentWidth };
+
 // Note: chalk.level is auto-detected by supports-color.
 // Apple_Terminal → level 2 (256-color), iTerm.app v3+ → level 3 (24-bit).
 // Do NOT force level 3 — Terminal.app can't render 24-bit codes (shows gray).
-// ============================================================================
-// Palette factory — rebuilt on theme switch
-// ============================================================================
-function buildPalette() {
-    return {
-        systemBlue: chalk.hex(colors.brand),
-        systemCyan: chalk.hex(colors.info),
-        systemPink: chalk.hex(colors.pink),
-        systemPurple: chalk.hex(colors.purple),
-        systemIndigo: chalk.hex(colors.indigo),
-        systemGreen: chalk.hex(colors.success),
-        systemMint: chalk.hex(colors.mint),
-        systemRed: chalk.hex(colors.error),
-        systemOrange: chalk.hex(colors.warning),
-        text: chalk.hex(colors.text),
-        secondary: chalk.hex(colors.secondary),
-        tertiary: chalk.hex(colors.tertiary),
-        separator: chalk.hex(colors.separator),
-        lavender: chalk.hex(colors.lavender),
-        roseGold: chalk.hex(colors.roseGold),
-    };
-}
+
 let p = buildPalette();
-// ============================================================================
-// Terminal width helpers — single source of truth for layout widths
-// ============================================================================
-function termWidth() {
-    return process.stdout.columns || 80;
-}
-/** Width for top-level assistant text (accounts for MessageList marginLeft=2) */
-export function contentWidth() {
-    return termWidth() - 2;
-}
-/** Width for content nested inside tool results (MessageList=2 + ToolIndicator=2 + safety=2) */
-export function toolContentWidth() {
-    return termWidth() - 6;
-}
-// ============================================================================
-// OSC 8 hyperlinks — only in terminals that support them
-// ============================================================================
-/** Detect if terminal supports OSC 8 clickable hyperlinks */
-const supportsOsc8 = (() => {
-    const tp = process.env.TERM_PROGRAM || "";
-    if (/iterm|wezterm|kitty|hyper|warp|foot|alacritty/i.test(tp))
-        return true;
-    if (process.env.VTE_VERSION)
-        return true; // GNOME Terminal, Tilix
-    if (process.env.WT_SESSION)
-        return true; // Windows Terminal
-    if (process.env.KONSOLE_VERSION)
-        return true; // Konsole
-    // Apple Terminal.app does NOT support OSC 8
-    return false;
-})();
+
+// Thin wrappers that close over module-level palette `p`
+// Source of truth is in markdown-helpers.ts
 function hyperlink(url, text) {
-    // mailto: → clean email address, no protocol prefix, no OSC 8
-    if (url.startsWith("mailto:")) {
-        const email = text || url.slice(7);
-        return p.systemCyan(email);
-    }
-    // tel: → clean phone number
-    if (url.startsWith("tel:")) {
-        return p.systemCyan(text || url.slice(4));
-    }
-    const display = text || url;
-    // OSC 8 clickable links — only where terminal supports them
-    if (supportsOsc8) {
-        return `\x1B]8;;${url}\x07${p.systemCyan.underline(display)}\x1B]8;;\x07`;
-    }
-    // Fallback: colored underlined text (no escape sequences)
-    return p.systemCyan.underline(display);
-}
-// ============================================================================
-// Path helpers
-// ============================================================================
-/** Shorten a file path for code block headers */
-function shortenPathForHeader(fullPath, maxLen = 40) {
-    let fp = fullPath;
-    const cwd = process.cwd();
-    const home = process.env.HOME || "";
-    if (fp.startsWith(cwd + "/"))
-        fp = fp.slice(cwd.length + 1);
-    else if (fp.startsWith(cwd))
-        fp = fp.slice(cwd.length);
-    else if (home && fp.startsWith(home))
-        fp = "~" + fp.slice(home.length);
-    if (fp.length <= maxLen)
-        return fp;
-    const parts = fp.split("/");
-    const file = parts.pop();
-    if (file.length >= maxLen - 4)
-        return "…/" + file.slice(-(maxLen - 4));
-    const parent = parts.pop();
-    return parent ? "…/" + parent + "/" + file : "…/" + file;
+  return hyperlinkWithPalette(url, text, p);
 }
-// ============================================================================
-// Financial coloring
-// ============================================================================
 function colorizeFinancials(str) {
-    return str
-        // NOTE: URL hyperlinking is handled by marked's GFM autolink + link/href handlers.
-        // Do NOT add URL patterns here — it causes links to render 3-5x.
-        // Negative dollar amounts → red  (-$1,234.56) — require digit after $
-        .replace(/(-\$\d[\d,]*\.?\d*)/g, (m) => p.systemRed(m))
-        // Positive dollar amounts → green  ($1,234.56) — require digit after $
-        .replace(/((?:^|[^-])\$\d[\d,]*\.?\d*)/g, (m) => p.systemGreen(m))
-        // Negative percentages → red
-        .replace(/(-\d+\.?\d*%)/g, (m) => p.systemRed(m))
-        // Positive percentages → cyan
-        .replace(/((?:^|[^-])\d+\.?\d*%)/g, (m) => p.systemCyan(m))
-        // Explicit positive → green
-        .replace(/(\+\$?[\d,]+\.?\d*)/g, (m) => p.systemGreen(m))
-        // Financial-specific words → green (no generic words like running/ready/started)
-        .replace(/\b(profit|revenue|gain|in stock|available)\b/gi, (m) => p.systemGreen(m))
-        // Financial/status negatives → red
-        .replace(/\b(loss|deduction|deficit|expense|out of stock|low stock|overdue|expired|cancelled|failed|error|crashed|EADDRINUSE|ENOENT)\b/gi, (m) => p.systemRed(m));
+  return colorizeFinancialsWithPalette(str, p);
 }
+
 // ============================================================================
 // Markdown renderer factory — rebuilt on theme switch
 // ============================================================================
+
 function buildMarkedInstance() {
-    const md = new Marked();
-    md.use(markedTerminal({
-        // Headings — bold blue
-        firstHeading: p.systemBlue.bold,
-        heading: p.systemBlue.bold,
-        // Inline
-        codespan: p.systemPink,
-        strong: p.text.bold,
-        em: p.lavender.italic,
-        // Blocks
-        blockquote: p.secondary.italic,
-        paragraph: (body) => colorizeFinancials(body),
-        hr: () => p.separator("─".repeat(50)),
-        // Links — OSC 8 clickable (single source of truth for URL rendering)
-        // NOTE: Only use `link` handler, NOT `href` — having both causes double-hyperlinking
-        link: (href, _title, text) => hyperlink(href, text !== href ? text : undefined),
-        // Lists — purple bullets, financial-aware
-        list: (body, ordered) => {
-            if (ordered) {
-                let n = 0;
-                return body.replace(/^\* /gm, () => {
-                    n++;
-                    return `${p.systemIndigo(String(n) + ".")} `;
-                });
+  const md = new Marked();
+  md.use(markedTerminal({
+    // Headings — bold blue
+    firstHeading: p.systemBlue.bold,
+    heading: p.systemBlue.bold,
+    // Inline
+    codespan: p.systemPink,
+    strong: p.text.bold,
+    em: p.lavender.italic,
+    // Blocks
+    blockquote: p.secondary.italic,
+    paragraph: body => colorizeFinancials(body),
+    hr: () => p.separator("─".repeat(50)),
+    // Links — OSC 8 clickable (single source of truth for URL rendering)
+    // NOTE: Only use `link` handler, NOT `href` — having both causes double-hyperlinking
+    link: (href, _title, text) => hyperlink(href, text !== href ? text : undefined),
+    // Lists — purple bullets, financial-aware
+    list: (body, ordered) => {
+      if (ordered) {
+        let n = 0;
+        return body.replace(/^\* /gm, () => {
+          n++;
+          return `${p.systemIndigo(String(n) + ".")} `;
+        });
+      }
+      return body.replace(/^\* /gm, `${p.systemPurple("●")} `);
+    },
+    listitem: itemText => {
+      return colorizeFinancials(itemText);
+    },
+    // Layout — adapt to terminal width
+    reflowText: false,
+    showSectionPrefix: false,
+    width: Math.min(120, contentWidth()),
+    tab: 2
+  }));
+
+  // Register chart + table + code block extensions
+  md.use({
+    renderer: {
+      code(token) {
+        const rawLang = token.lang || "";
+        const code = token.text;
+
+        // Parse lang:subtitle (e.g. "typescript:src/foo.ts")
+        const colonIdx = rawLang.indexOf(":");
+        const lang = colonIdx > 0 ? rawLang.slice(0, colonIdx) : rawLang;
+        const subtitle = colonIdx > 0 ? rawLang.slice(colonIdx + 1) : "";
+        if (lang === "chart" || lang === "bar") {
+          return renderBarChart(code);
+        }
+        if (lang === "diff") {
+          return renderDiff(code);
+        }
+        {
+          // Command output mode: bash without subtitle = run_command output
+          // → no line numbers, wider content area, clean indent
+          const isCommandOutput = (lang === "bash" || lang === "terminal") && !subtitle;
+          const highlightLang = lang === "terminal" ? "bash" : lang;
+
+          // Build header: ── lang ── subtitle ──────
+          const cw = contentWidth();
+          const headerWidth = Math.max(20, cw - 6);
+          const displayLang = isCommandOutput ? "bash" : lang;
+          let header;
+          if (displayLang && subtitle) {
+            const shortSub = shortenPathForHeader(subtitle, headerWidth - displayLang.length - 10);
+            const pad = Math.max(2, headerWidth - displayLang.length - shortSub.length - 6);
+            header = p.separator("  ── ") + p.tertiary(displayLang) + p.separator(" ── ") + p.secondary(shortSub) + p.separator(` ${"─".repeat(pad)}`);
+          } else if (displayLang) {
+            const pad = Math.max(2, headerWidth - displayLang.length - 3);
+            header = p.separator("  ── ") + p.tertiary(displayLang) + p.separator(` ${"─".repeat(pad)}`);
+          } else {
+            header = p.separator("  ──" + "─".repeat(headerWidth - 2));
+          }
+
+          // Calculate max line width to prevent wrapping
+          const lineCount = code.split("\n").length;
+          const gutterW = isCommandOutput ? 0 : String(lineCount).length;
+          const gutterOverhead = isCommandOutput ? 4 : 2 + gutterW + 3; // "    " or "  123 │ "
+          const maxLineWidth = Math.max(20, cw - gutterOverhead - 2);
+
+          // Pre-truncate lines BEFORE highlighting (avoids cutting ANSI codes)
+          const truncatedCode = code.split("\n").map(line => {
+            if (line.length > maxLineWidth) {
+              return line.slice(0, maxLineWidth - 1) + "…";
             }
-            return body.replace(/^\* /gm, `${p.systemPurple("●")} `);
-        },
-        listitem: (itemText) => {
-            return colorizeFinancials(itemText);
-        },
-        // Layout — adapt to terminal width
-        reflowText: false,
-        showSectionPrefix: false,
-        width: Math.min(120, contentWidth()),
-        tab: 2,
-    }));
-    // Register chart + table + code block extensions
-    md.use({
-        renderer: {
-            code(token) {
-                const rawLang = token.lang || "";
-                const code = token.text;
-                // Parse lang:subtitle (e.g. "typescript:src/foo.ts")
-                const colonIdx = rawLang.indexOf(":");
-                const lang = colonIdx > 0 ? rawLang.slice(0, colonIdx) : rawLang;
-                const subtitle = colonIdx > 0 ? rawLang.slice(colonIdx + 1) : "";
-                if (lang === "chart" || lang === "bar") {
-                    return renderBarChart(code);
-                }
-                if (lang === "diff") {
-                    return renderDiff(code);
-                }
-                {
-                    // Command output mode: bash without subtitle = run_command output
-                    // → no line numbers, wider content area, clean indent
-                    const isCommandOutput = (lang === "bash" || lang === "terminal") && !subtitle;
-                    const highlightLang = lang === "terminal" ? "bash" : lang;
-                    // Build header: ── lang ── subtitle ──────
-                    const cw = contentWidth();
-                    const headerWidth = Math.max(20, cw - 6);
-                    const displayLang = isCommandOutput ? "bash" : lang;
-                    let header;
-                    if (displayLang && subtitle) {
-                        const shortSub = shortenPathForHeader(subtitle, headerWidth - displayLang.length - 10);
-                        const pad = Math.max(2, headerWidth - displayLang.length - shortSub.length - 6);
-                        header = p.separator("  ── ") + p.tertiary(displayLang) + p.separator(" ── ") + p.secondary(shortSub) + p.separator(` ${"─".repeat(pad)}`);
-                    }
-                    else if (displayLang) {
-                        const pad = Math.max(2, headerWidth - displayLang.length - 3);
-                        header = p.separator("  ── ") + p.tertiary(displayLang) + p.separator(` ${"─".repeat(pad)}`);
-                    }
-                    else {
-                        header = p.separator("  ──" + "─".repeat(headerWidth - 2));
-                    }
-                    // Calculate max line width to prevent wrapping
-                    const lineCount = code.split("\n").length;
-                    const gutterW = isCommandOutput ? 0 : String(lineCount).length;
-                    const gutterOverhead = isCommandOutput ? 4 : (2 + gutterW + 3); // "    " or "  123 │ "
-                    const maxLineWidth = Math.max(20, cw - gutterOverhead - 2);
-                    // Pre-truncate lines BEFORE highlighting (avoids cutting ANSI codes)
-                    const truncatedCode = code.split("\n").map((line) => {
-                        if (line.length > maxLineWidth) {
-                            return line.slice(0, maxLineWidth - 1) + "…";
-                        }
-                        return line;
-                    }).join("\n");
-                    // Highlight with shiki
-                    const highlighted = highlightLang
-                        ? highlightCode(truncatedCode, highlightLang)
-                        : truncatedCode;
-                    const hLines = highlighted.split("\n");
-                    if (isCommandOutput) {
-                        // Command output: no line numbers, 4-space indent
-                        const body = hLines.map(l => "    " + l).join("\n");
-                        return "\n" + header + "\n" + body + "\n";
-                    }
-                    else {
-                        // Code with line numbers + gutter
-                        const numbered = hLines.map((l, i) => {
-                            const num = p.tertiary(String(i + 1).padStart(gutterW));
-                            return "  " + num + p.separator(" │ ") + l;
-                        }).join("\n");
-                        return "\n" + header + "\n" + numbered + "\n";
-                    }
-                }
-            },
-            table(token) {
-                return renderTable(token);
-            },
-        },
-    });
-    return md;
+            return line;
+          }).join("\n");
+
+          // Highlight with shiki
+          const highlighted = highlightLang ? highlightCode(truncatedCode, highlightLang) : truncatedCode;
+          const hLines = highlighted.split("\n");
+          if (isCommandOutput) {
+            // Command output: no line numbers, 4-space indent
+            const body = hLines.map(l => "    " + l).join("\n");
+            return "\n" + header + "\n" + body + "\n";
+          } else {
+            // Code with line numbers + gutter
+            const numbered = hLines.map((l, i) => {
+              const num = p.tertiary(String(i + 1).padStart(gutterW));
+              return "  " + num + p.separator(" │ ") + l;
+            }).join("\n");
+            return "\n" + header + "\n" + numbered + "\n";
+          }
+        }
+      },
+      table(token) {
+        return renderTable(token);
+      }
+    }
+  });
+  return md;
 }
 let md = buildMarkedInstance();
+
 // ============================================================================
 // Diff renderer — background colors + word-level diff (Claude Code parity)
 // ============================================================================
+
 function buildDiffStyles() {
-    return {
-        diffAddedBg: chalk.bgHex(colors.diffAddedBg).white,
-        diffRemovedBg: chalk.bgHex(colors.diffRemovedBg).white,
-        diffWordAdded: chalk.bgHex(colors.diffWordAdded).whiteBright.bold,
-        diffWordRemoved: chalk.bgHex(colors.diffWordRemoved).whiteBright.bold,
-    };
+  return {
+    diffAddedBg: chalk.bgHex(colors.diffAddedBg).white,
+    diffRemovedBg: chalk.bgHex(colors.diffRemovedBg).white,
+    diffWordAdded: chalk.bgHex(colors.diffWordAdded).whiteBright.bold,
+    diffWordRemoved: chalk.bgHex(colors.diffWordRemoved).whiteBright.bold
+  };
 }
 let d = buildDiffStyles();
+
 /** Compute word-level diff between two lines using the `diff` library. */
 function wordDiff(oldLine, newLine) {
-    const changes = diffWords(oldLine, newLine);
-    const oldSegs = [];
-    const newSegs = [];
-    for (const change of changes) {
-        if (change.added) {
-            newSegs.push({ text: change.value, changed: true });
-        }
-        else if (change.removed) {
-            oldSegs.push({ text: change.value, changed: true });
-        }
-        else {
-            oldSegs.push({ text: change.value, changed: false });
-            newSegs.push({ text: change.value, changed: false });
-        }
-    }
-    // If >60% of either line changed, fall back to full-line highlight
-    const oldChanged = oldSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
-    const newChanged = newSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
-    if ((oldLine.length > 0 && oldChanged / oldLine.length > 0.6) ||
-        (newLine.length > 0 && newChanged / newLine.length > 0.6)) {
-        return { old: [{ text: oldLine, changed: true }], new: [{ text: newLine, changed: true }] };
-    }
-    return { old: oldSegs, new: newSegs };
+  const changes = diffWords(oldLine, newLine);
+  const oldSegs = [];
+  const newSegs = [];
+  for (const change of changes) {
+    if (change.added) {
+      newSegs.push({
+        text: change.value,
+        changed: true
+      });
+    } else if (change.removed) {
+      oldSegs.push({
+        text: change.value,
+        changed: true
+      });
+    } else {
+      oldSegs.push({
+        text: change.value,
+        changed: false
+      });
+      newSegs.push({
+        text: change.value,
+        changed: false
+      });
+    }
+  }
+
+  // If >60% of either line changed, fall back to full-line highlight
+  const oldChanged = oldSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
+  const newChanged = newSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
+  if (oldLine.length > 0 && oldChanged / oldLine.length > 0.6 || newLine.length > 0 && newChanged / newLine.length > 0.6) {
+    return {
+      old: [{
+        text: oldLine,
+        changed: true
+      }],
+      new: [{
+        text: newLine,
+        changed: true
+      }]
+    };
+  }
+  return {
+    old: oldSegs,
+    new: newSegs
+  };
 }
+
 /** Render segments with word-level highlighting */
 function renderSegments(segs, wordStyle, lineStyle) {
-    return segs.map(s => s.changed ? wordStyle(s.text) : lineStyle(s.text)).join("");
+  return segs.map(s => s.changed ? wordStyle(s.text) : lineStyle(s.text)).join("");
 }
 function renderDiff(code) {
-    const lines = code.split("\n");
-    const tw = toolContentWidth();
-    const segments = [];
-    let oldLineNo = 1, newLineNo = 1;
-    let seenDiff = false;
-    for (const line of lines) {
-        // Skip file headers (--- a/file, +++ b/file)
-        if (line.startsWith("---") || line.startsWith("+++"))
-            continue;
-        // Hunk header — extract line numbers
-        const hunkMatch = line.match(/^@@\s*-(\d+)(?:,\d+)?\s*\+(\d+)(?:,\d+)?\s*@@/);
-        if (hunkMatch) {
-            oldLineNo = parseInt(hunkMatch[1]);
-            newLineNo = parseInt(hunkMatch[2]);
-            seenDiff = true;
-            continue;
-        }
-        // Skip non-diff header lines (e.g., "File edited:", "Applied N edits")
-        if (!seenDiff && !line.startsWith("-") && !line.startsWith("+") && !line.startsWith(" ")) {
-            continue;
-        }
-        seenDiff = true;
-        if (line.startsWith("-")) {
-            segments.push({ type: "remove", content: line.slice(1), lineNo: oldLineNo });
-            oldLineNo++;
-        }
-        else if (line.startsWith("+")) {
-            segments.push({ type: "add", content: line.slice(1), lineNo: newLineNo });
-            newLineNo++;
-        }
-        else {
-            const content = line.startsWith(" ") ? line.slice(1) : line;
-            segments.push({ type: "context", content, lineNo: newLineNo });
-            oldLineNo++;
-            newLineNo++;
-        }
-    }
-    if (segments.length === 0)
-        return code; // fallback
-    // Gutter width from max line number
-    const maxLineNo = segments.reduce((max, s) => Math.max(max, s.lineNo), 0);
-    const gutterW = Math.max(3, String(maxLineNo).length);
-    const out = [];
-    let i = 0;
-    while (i < segments.length) {
-        const seg = segments[i];
-        if (seg.type === "remove") {
-            // Collect consecutive removes
-            const removes = [];
-            while (i < segments.length && segments[i].type === "remove") {
-                removes.push(segments[i]);
-                i++;
-            }
-            // Collect consecutive adds
-            const adds = [];
-            while (i < segments.length && segments[i].type === "add") {
-                adds.push(segments[i]);
-                i++;
-            }
-            // Pair for word-level diff
-            const pairCount = Math.min(removes.length, adds.length);
-            for (let j = 0; j < removes.length; j++) {
-                const r = removes[j];
-                const rPrefix = `${String(r.lineNo).padStart(gutterW)} - `;
-                if (j < pairCount) {
-                    const a = adds[j];
-                    const aPrefix = `${String(a.lineNo).padStart(gutterW)} + `;
-                    const wd = wordDiff(r.content, a.content);
-                    // Removed line with word highlights
-                    const rPad = Math.max(0, tw - rPrefix.length - r.content.length);
-                    out.push(d.diffRemovedBg(rPrefix) + renderSegments(wd.old, d.diffWordRemoved, d.diffRemovedBg) + d.diffRemovedBg(" ".repeat(rPad)));
-                    // Added line with word highlights
-                    const aPad = Math.max(0, tw - aPrefix.length - a.content.length);
-                    out.push(d.diffAddedBg(aPrefix) + renderSegments(wd.new, d.diffWordAdded, d.diffAddedBg) + d.diffAddedBg(" ".repeat(aPad)));
-                }
-                else {
-                    // Unpaired remove
-                    const raw = rPrefix + r.content;
-                    const pad = Math.max(0, tw - raw.length);
-                    out.push(d.diffRemovedBg(raw + " ".repeat(pad)));
-                }
-            }
-            // Unpaired adds
-            for (let j = pairCount; j < adds.length; j++) {
-                const a = adds[j];
-                const prefix = `${String(a.lineNo).padStart(gutterW)} + `;
-                const raw = prefix + a.content;
-                const pad = Math.max(0, tw - raw.length);
-                out.push(d.diffAddedBg(raw + " ".repeat(pad)));
-            }
-            continue;
-        }
-        if (seg.type === "add") {
-            // Standalone add (no preceding remove)
-            const prefix = `${String(seg.lineNo).padStart(gutterW)} + `;
-            const raw = prefix + seg.content;
-            const pad = Math.max(0, tw - raw.length);
-            out.push(d.diffAddedBg(raw + " ".repeat(pad)));
-            i++;
-            continue;
-        }
-        // Context line — dim line number, plain content, no background
-        const prefix = p.tertiary(`${String(seg.lineNo).padStart(gutterW)}   `);
-        out.push(prefix + seg.content);
+  const lines = code.split("\n");
+  const tw = toolContentWidth();
+
+  // Parse into segments from unified diff format
+
+  const segments = [];
+  let oldLineNo = 1,
+    newLineNo = 1;
+  let seenDiff = false;
+  for (const line of lines) {
+    // Skip file headers (--- a/file, +++ b/file)
+    if (line.startsWith("---") || line.startsWith("+++")) continue;
+
+    // Hunk header — extract line numbers
+    const hunkMatch = line.match(/^@@\s*-(\d+)(?:,\d+)?\s*\+(\d+)(?:,\d+)?\s*@@/);
+    if (hunkMatch) {
+      oldLineNo = parseInt(hunkMatch[1]);
+      newLineNo = parseInt(hunkMatch[2]);
+      seenDiff = true;
+      continue;
+    }
+
+    // Skip non-diff header lines (e.g., "File edited:", "Applied N edits")
+    if (!seenDiff && !line.startsWith("-") && !line.startsWith("+") && !line.startsWith(" ")) {
+      continue;
+    }
+    seenDiff = true;
+    if (line.startsWith("-")) {
+      segments.push({
+        type: "remove",
+        content: line.slice(1),
+        lineNo: oldLineNo
+      });
+      oldLineNo++;
+    } else if (line.startsWith("+")) {
+      segments.push({
+        type: "add",
+        content: line.slice(1),
+        lineNo: newLineNo
+      });
+      newLineNo++;
+    } else {
+      const content = line.startsWith(" ") ? line.slice(1) : line;
+      segments.push({
+        type: "context",
+        content,
+        lineNo: newLineNo
+      });
+      oldLineNo++;
+      newLineNo++;
+    }
+  }
+  if (segments.length === 0) return code; // fallback
+
+  // Gutter width from max line number
+  const maxLineNo = segments.reduce((max, s) => Math.max(max, s.lineNo), 0);
+  const gutterW = Math.max(3, String(maxLineNo).length);
+  const out = [];
+  let i = 0;
+  while (i < segments.length) {
+    const seg = segments[i];
+    if (seg.type === "remove") {
+      // Collect consecutive removes
+      const removes = [];
+      while (i < segments.length && segments[i].type === "remove") {
+        removes.push(segments[i]);
         i++;
-    }
-    return out.join("\n") + "\n";
+      }
+      // Collect consecutive adds
+      const adds = [];
+      while (i < segments.length && segments[i].type === "add") {
+        adds.push(segments[i]);
+        i++;
+      }
+
+      // Pair for word-level diff
+      const pairCount = Math.min(removes.length, adds.length);
+      for (let j = 0; j < removes.length; j++) {
+        const r = removes[j];
+        const rPrefix = `${String(r.lineNo).padStart(gutterW)} - `;
+        if (j < pairCount) {
+          const a = adds[j];
+          const aPrefix = `${String(a.lineNo).padStart(gutterW)} + `;
+          const wd = wordDiff(r.content, a.content);
+
+          // Removed line with word highlights
+          const rPad = Math.max(0, tw - rPrefix.length - r.content.length);
+          out.push(d.diffRemovedBg(rPrefix) + renderSegments(wd.old, d.diffWordRemoved, d.diffRemovedBg) + d.diffRemovedBg(" ".repeat(rPad)));
+
+          // Added line with word highlights
+          const aPad = Math.max(0, tw - aPrefix.length - a.content.length);
+          out.push(d.diffAddedBg(aPrefix) + renderSegments(wd.new, d.diffWordAdded, d.diffAddedBg) + d.diffAddedBg(" ".repeat(aPad)));
+        } else {
+          // Unpaired remove
+          const raw = rPrefix + r.content;
+          const pad = Math.max(0, tw - raw.length);
+          out.push(d.diffRemovedBg(raw + " ".repeat(pad)));
+        }
+      }
+
+      // Unpaired adds
+      for (let j = pairCount; j < adds.length; j++) {
+        const a = adds[j];
+        const prefix = `${String(a.lineNo).padStart(gutterW)} + `;
+        const raw = prefix + a.content;
+        const pad = Math.max(0, tw - raw.length);
+        out.push(d.diffAddedBg(raw + " ".repeat(pad)));
+      }
+      continue;
+    }
+    if (seg.type === "add") {
+      // Standalone add (no preceding remove)
+      const prefix = `${String(seg.lineNo).padStart(gutterW)} + `;
+      const raw = prefix + seg.content;
+      const pad = Math.max(0, tw - raw.length);
+      out.push(d.diffAddedBg(raw + " ".repeat(pad)));
+      i++;
+      continue;
+    }
+
+    // Context line — dim line number, plain content, no background
+    const prefix = p.tertiary(`${String(seg.lineNo).padStart(gutterW)}   `);
+    out.push(prefix + seg.content);
+    i++;
+  }
+  return out.join("\n") + "\n";
 }
+
 // ============================================================================
 // Bar chart renderer — ```chart code blocks
 // ============================================================================
+
 function buildBarGradient() {
-    return [
-        chalk.hex(colors.purple),
-        chalk.hex(colors.indigo),
-        chalk.hex(colors.brand),
-        chalk.hex(colors.info),
-        chalk.hex(colors.teal),
-        chalk.hex(colors.success),
-        chalk.hex(colors.warning),
-        chalk.hex(colors.pink),
-    ];
+  return [chalk.hex(colors.purple), chalk.hex(colors.indigo), chalk.hex(colors.brand), chalk.hex(colors.info), chalk.hex(colors.teal), chalk.hex(colors.success), chalk.hex(colors.warning), chalk.hex(colors.pink)];
 }
 let barGradient = buildBarGradient();
 function renderBarChart(code) {
-    const lines = code.trim().split("\n").filter(l => l.trim());
-    // Optional title — first line without "label: number" pattern
-    let title = "";
-    let dataLines = lines;
-    if (lines.length > 1 && !/:\s*[$\-+]?[\d,]+/.test(lines[0])) {
-        title = lines[0].trim();
-        dataLines = lines.slice(1);
-    }
-    // Parse "Label: $1,234.56" or "Label: 42%" or "Label: 1000"
-    const entries = [];
-    for (const line of dataLines) {
-        const m = line.match(/^(.+?):\s*([+\-]?\$?[\d,]+\.?\d*%?)\s*$/);
-        if (!m)
-            continue;
-        const label = m[1].trim();
-        const raw = m[2].trim();
-        const value = Math.abs(parseFloat(raw.replace(/[$,%]/g, "")));
-        if (!isNaN(value))
-            entries.push({ label, value, raw });
-    }
-    if (entries.length === 0)
-        return code;
-    const maxVal = Math.max(...entries.map(e => e.value));
-    const maxRaw = Math.max(...entries.map(e => e.raw.length));
-    const cw = contentWidth();
-    // Responsive label width — truncate labels to fit
-    const idealLabelW = Math.max(...entries.map(e => e.label.length));
-    // Fixed overhead: indent(2) + gap(2) + gap(2) + value(maxRaw) + safety(2)
-    const fixedOverhead = 2 + 2 + 2 + maxRaw + 2;
-    const spaceForLabelAndBar = cw - fixedOverhead;
-    // Allocate: label gets up to half, bar gets the rest (min 4)
-    const maxLabelW = Math.min(idealLabelW, Math.max(6, Math.floor(spaceForLabelAndBar * 0.4)));
-    const barWidth = Math.max(4, spaceForLabelAndBar - maxLabelW);
-    // If even 4-char bars don't fit, fall back to compact list (no bars)
-    const compact = spaceForLabelAndBar < 12;
-    const out = [];
-    if (title) {
-        const displayTitle = title.length > cw - 4 ? title.slice(0, cw - 5) + "…" : title;
-        out.push(`  ${p.systemBlue.bold(displayTitle)}`);
-        out.push("");
-    }
-    function colorVal(raw) {
-        return raw.includes("$") ? p.systemGreen(raw)
-            : raw.includes("%") ? p.systemCyan(raw)
-                : p.systemMint(raw);
-    }
-    if (compact) {
-        // Compact mode: just "label  value" with color dot
-        for (let i = 0; i < entries.length; i++) {
-            const e = entries[i];
-            const color = barGradient[i % barGradient.length];
-            const labelStr = e.label.length > cw - maxRaw - 8
-                ? e.label.slice(0, cw - maxRaw - 9) + "…"
-                : e.label;
-            out.push(`  ${color("●")} ${p.secondary(labelStr)}  ${colorVal(e.raw)}`);
-        }
-    }
-    else {
-        for (let i = 0; i < entries.length; i++) {
-            const e = entries[i];
-            const ratio = maxVal > 0 ? e.value / maxVal : 0;
-            const filled = Math.round(ratio * barWidth);
-            const color = barGradient[i % barGradient.length];
-            const labelStr = e.label.length > maxLabelW
-                ? e.label.slice(0, maxLabelW - 1) + "…"
-                : e.label;
-            const label = p.secondary(labelStr.padStart(maxLabelW));
-            const bar = color("█".repeat(filled)) + chalk.hex("#2C2C2E")("░".repeat(barWidth - filled));
-            const val = colorVal(e.raw.padStart(maxRaw));
-            out.push(`  ${label}  ${bar}  ${val}`);
-        }
-    }
-    return "\n" + out.join("\n") + "\n";
+  const lines = code.trim().split("\n").filter(l => l.trim());
+
+  // Optional title — first line without "label: number" pattern
+  let title = "";
+  let dataLines = lines;
+  if (lines.length > 1 && !/:\s*[$\-+]?[\d,]+/.test(lines[0])) {
+    title = lines[0].trim();
+    dataLines = lines.slice(1);
+  }
+
+  // Parse "Label: $1,234.56" or "Label: 42%" or "Label: 1000"
+  const entries = [];
+  for (const line of dataLines) {
+    const m = line.match(/^(.+?):\s*([+\-]?\$?[\d,]+\.?\d*%?)\s*$/);
+    if (!m) continue;
+    const label = m[1].trim();
+    const raw = m[2].trim();
+    const value = Math.abs(parseFloat(raw.replace(/[$,%]/g, "")));
+    if (!isNaN(value)) entries.push({
+      label,
+      value,
+      raw
+    });
+  }
+  if (entries.length === 0) return code;
+  const maxVal = Math.max(...entries.map(e => e.value));
+  const maxRaw = Math.max(...entries.map(e => e.raw.length));
+  const cw = contentWidth();
+
+  // Responsive label width — truncate labels to fit
+  const idealLabelW = Math.max(...entries.map(e => e.label.length));
+  // Fixed overhead: indent(2) + gap(2) + gap(2) + value(maxRaw) + safety(2)
+  const fixedOverhead = 2 + 2 + 2 + maxRaw + 2;
+  const spaceForLabelAndBar = cw - fixedOverhead;
+
+  // Allocate: label gets up to half, bar gets the rest (min 4)
+  const maxLabelW = Math.min(idealLabelW, Math.max(6, Math.floor(spaceForLabelAndBar * 0.4)));
+  const barWidth = Math.max(4, spaceForLabelAndBar - maxLabelW);
+
+  // If even 4-char bars don't fit, fall back to compact list (no bars)
+  const compact = spaceForLabelAndBar < 12;
+  const out = [];
+  if (title) {
+    const displayTitle = title.length > cw - 4 ? title.slice(0, cw - 5) + "…" : title;
+    out.push(`  ${p.systemBlue.bold(displayTitle)}`);
+    out.push("");
+  }
+  function colorVal(raw) {
+    return raw.includes("$") ? p.systemGreen(raw) : raw.includes("%") ? p.systemCyan(raw) : p.systemMint(raw);
+  }
+  if (compact) {
+    // Compact mode: just "label  value" with color dot
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const color = barGradient[i % barGradient.length];
+      const labelStr = e.label.length > cw - maxRaw - 8 ? e.label.slice(0, cw - maxRaw - 9) + "…" : e.label;
+      out.push(`  ${color("●")} ${p.secondary(labelStr)}  ${colorVal(e.raw)}`);
+    }
+  } else {
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const ratio = maxVal > 0 ? e.value / maxVal : 0;
+      const filled = Math.round(ratio * barWidth);
+      const color = barGradient[i % barGradient.length];
+      const labelStr = e.label.length > maxLabelW ? e.label.slice(0, maxLabelW - 1) + "…" : e.label;
+      const label = p.secondary(labelStr.padStart(maxLabelW));
+      const bar = color("█".repeat(filled)) + chalk.hex("#2C2C2E")("░".repeat(barWidth - filled));
+      const val = colorVal(e.raw.padStart(maxRaw));
+      out.push(`  ${label}  ${bar}  ${val}`);
+    }
+  }
+  return "\n" + out.join("\n") + "\n";
 }
+
+// ============================================================================
+// Table renderer — polished TUI tables with theme-aware styling
+// ============================================================================
+
+// Row tone detection for background tinting
+
 function getRowTone(cells) {
-    for (const cell of cells) {
-        const t = cell.trim();
-        if (/^-\$[\d,]+/.test(t) || /^-\d+\.?\d*%/.test(t))
-            return "negative";
-        if (/^\+\d/.test(t) || /^\+\$/.test(t))
-            return "positive";
-        if (/^`?[✕✗]/.test(t) || /cancelled|failed|rejected|error|out of stock|low stock/i.test(t))
-            return "negative";
-        if (/^`?[✓●]/.test(t) || /completed|received|approved|active|success|paid|published/i.test(t))
-            return "positive";
-    }
-    return "neutral";
+  for (const cell of cells) {
+    const t = cell.trim();
+    if (/^-\$[\d,]+/.test(t) || /^-\d+\.?\d*%/.test(t)) return "negative";
+    if (/^\+\d/.test(t) || /^\+\$/.test(t)) return "positive";
+    if (/^`?[✕✗]/.test(t) || /cancelled|failed|rejected|error|out of stock|low stock/i.test(t)) return "negative";
+    if (/^`?[✓●]/.test(t) || /completed|received|approved|active|success|paid|published/i.test(t)) return "positive";
+  }
+  return "neutral";
 }
+
 /** Detect if a column is numeric (for right-alignment) */
 function isNumericColumn(rows, colIndex) {
-    let numericCount = 0;
-    let total = 0;
-    for (const row of rows) {
-        const val = (row[colIndex] || "").trim();
-        if (!val)
-            continue;
-        total++;
-        if (/^[+\-]?\$?[\d,]+\.?\d*%?$/.test(val))
-            numericCount++;
-    }
-    return total > 0 && numericCount / total > 0.5;
+  let numericCount = 0;
+  let total = 0;
+  for (const row of rows) {
+    const val = (row[colIndex] || "").trim();
+    if (!val) continue;
+    total++;
+    if (/^[+\-]?\$?[\d,]+\.?\d*%?$/.test(val)) numericCount++;
+  }
+  return total > 0 && numericCount / total > 0.5;
 }
+
 /** Blend two hex colors by ratio (0 = colorA, 1 = colorB) */
 function blendHex(a, b, ratio) {
-    const parse = (h) => {
-        const c = h.replace("#", "");
-        return [parseInt(c.slice(0, 2), 16), parseInt(c.slice(2, 4), 16), parseInt(c.slice(4, 6), 16)];
-    };
-    const [ar, ag, ab] = parse(a);
-    const [br, bg, bb] = parse(b);
-    const r = Math.round(ar + (br - ar) * ratio);
-    const g = Math.round(ag + (bg - ag) * ratio);
-    const bv = Math.round(ab + (bb - ab) * ratio);
-    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${bv.toString(16).padStart(2, "0")}`;
+  const parse = h => {
+    const c = h.replace("#", "");
+    return [parseInt(c.slice(0, 2), 16), parseInt(c.slice(2, 4), 16), parseInt(c.slice(4, 6), 16)];
+  };
+  const [ar, ag, ab] = parse(a);
+  const [br, bg, bb] = parse(b);
+  const r = Math.round(ar + (br - ar) * ratio);
+  const g = Math.round(ag + (bg - ag) * ratio);
+  const bv = Math.round(ab + (bb - ab) * ratio);
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${bv.toString(16).padStart(2, "0")}`;
 }
 function colorizeCell(val, isHeader) {
-    const trimmed = val.trim();
-    if (!trimmed)
-        return p.text("");
-    if (isHeader)
-        return p.systemBlue.bold(trimmed);
-    // Badge format: `✓ status` or `◆ status` or `○ status` or `✕ status`
-    const badgeMatch = trimmed.match(/^`([✓●◆○✕◦])\s+(.+)`$/);
-    if (badgeMatch) {
-        const [, icon, label] = badgeMatch;
-        if (icon === "✓" || icon === "●")
-            return p.systemGreen(`${icon} ${label}`);
-        if (icon === "◆")
-            return p.systemCyan(`${icon} ${label}`);
-        if (icon === "○")
-            return p.systemOrange(`${icon} ${label}`);
-        if (icon === "✕")
-            return p.systemRed(`${icon} ${label}`);
-        return p.secondary(`${icon} ${label}`);
-    }
-    // Inline code (UUID, SKU, transfer number)
-    if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
-        return p.systemPurple(trimmed.slice(1, -1));
-    }
-    // Bold text
-    if (trimmed.startsWith("**") && trimmed.endsWith("**")) {
-        return p.text.bold(trimmed.slice(2, -2));
-    }
-    // Negative values → red
-    if (/^-\$?[\d,]+\.?\d*$/.test(trimmed) || /^-\d+\.?\d*%$/.test(trimmed)) {
-        return p.systemRed(trimmed);
-    }
-    // Positive financial → green
-    if (/^\+?\$[\d,]+\.?\d*$/.test(trimmed) || /^\$[\d,]+\.?\d*$/.test(trimmed)) {
-        return p.systemGreen(trimmed);
-    }
-    // Percentages → cyan
-    if (/^\d+\.?\d*%$/.test(trimmed)) {
-        return p.systemCyan(trimmed);
-    }
-    // Plain numbers → mint
-    if (/^[\d,]+\.?\d*$/.test(trimmed)) {
-        return p.systemMint(trimmed);
-    }
-    // Status words
-    if (/^(active|success|complete|approved|in stock|available)/i.test(trimmed)) {
-        return p.systemGreen(trimmed);
-    }
-    if (/^(inactive|error|failed|cancelled|out of stock|low|overdue|expired)/i.test(trimmed)) {
-        return p.systemRed(trimmed);
-    }
-    if (/^(pending|draft|processing)/i.test(trimmed)) {
-        return p.systemOrange(trimmed);
-    }
-    return p.text(trimmed);
+  const trimmed = val.trim();
+  if (!trimmed) return p.text("");
+  if (isHeader) return p.systemBlue.bold(trimmed);
+
+  // Badge format: `✓ status` or `◆ status` or `○ status` or `✕ status`
+  const badgeMatch = trimmed.match(/^`([✓●◆○✕◦])\s+(.+)`$/);
+  if (badgeMatch) {
+    const [, icon, label] = badgeMatch;
+    if (icon === "✓" || icon === "●") return p.systemGreen(`${icon} ${label}`);
+    if (icon === "◆") return p.systemCyan(`${icon} ${label}`);
+    if (icon === "○") return p.systemOrange(`${icon} ${label}`);
+    if (icon === "✕") return p.systemRed(`${icon} ${label}`);
+    return p.secondary(`${icon} ${label}`);
+  }
+
+  // Inline code (UUID, SKU, transfer number)
+  if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
+    return p.systemPurple(trimmed.slice(1, -1));
+  }
+
+  // Bold text
+  if (trimmed.startsWith("**") && trimmed.endsWith("**")) {
+    return p.text.bold(trimmed.slice(2, -2));
+  }
+
+  // Negative values → red
+  if (/^-\$?[\d,]+\.?\d*$/.test(trimmed) || /^-\d+\.?\d*%$/.test(trimmed)) {
+    return p.systemRed(trimmed);
+  }
+  // Positive financial → green
+  if (/^\+?\$[\d,]+\.?\d*$/.test(trimmed) || /^\$[\d,]+\.?\d*$/.test(trimmed)) {
+    return p.systemGreen(trimmed);
+  }
+  // Percentages → cyan
+  if (/^\d+\.?\d*%$/.test(trimmed)) {
+    return p.systemCyan(trimmed);
+  }
+  // Plain numbers → mint
+  if (/^[\d,]+\.?\d*$/.test(trimmed)) {
+    return p.systemMint(trimmed);
+  }
+  // Status words
+  if (/^(active|success|complete|approved|in stock|available)/i.test(trimmed)) {
+    return p.systemGreen(trimmed);
+  }
+  if (/^(inactive|error|failed|cancelled|out of stock|low|overdue|expired)/i.test(trimmed)) {
+    return p.systemRed(trimmed);
+  }
+  if (/^(pending|draft|processing)/i.test(trimmed)) {
+    return p.systemOrange(trimmed);
+  }
+  return p.text(trimmed);
 }
 function renderTable(token) {
-    function getCellText(cell) {
-        if (!cell)
-            return "";
-        if (typeof cell === "string")
-            return cell;
-        if (cell.text !== undefined)
-            return String(cell.text);
-        if (cell.tokens) {
-            return cell.tokens.map((t) => t.raw || t.text || "").join("");
-        }
-        return String(cell);
-    }
-    const headers = (token.header || []).map((h) => getCellText(h));
-    const rows = (token.rows || []).map((row) => row.map((cell) => getCellText(cell)));
-    if (headers.length === 0)
-        return "";
-    const cw = contentWidth();
-    const N = headers.length;
-    // ── Check if box table can fit ──
-    // Minimum box table width: indent(2) + borders(N+1) + N * (minCol + 2 padding)
-    const MIN_COL = 3;
-    const minBoxWidth = 2 + (N + 1) + N * (MIN_COL + 2);
-    if (minBoxWidth > cw) {
-        // ── Card layout — graceful fallback for narrow terminals ──
-        return renderTableCards(headers, rows, cw);
-    }
-    // ── Box table layout ──
-    const overhead = 2 + 1 + (N - 1) + 1 + (N * 2);
-    const availableForContent = cw - overhead;
-    const minCol = cw < 70 ? MIN_COL : cw < 90 ? 5 : 6;
-    const maxPerCol = Math.max(minCol, Math.floor(availableForContent / N));
-    // Detect numeric columns for right-alignment
-    const numericCols = headers.map((_, i) => isNumericColumn(rows, i));
-    // Size columns: fit content up to maxPerCol, respect minCol
-    const colWidths = headers.map((h, i) => {
-        const dataMax = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
-        return Math.min(maxPerCol, Math.max(minCol, h.length, dataMax) + 2);
-    });
-    // Double-check total width won't overflow (defensive)
-    const totalWidth = 2 + 1 + colWidths.reduce((s, w) => s + w + 2, 0) + (N - 1) + 1;
-    if (totalWidth > cw) {
-        // Shrink largest columns until we fit
-        let excess = totalWidth - cw;
-        while (excess > 0) {
-            const maxIdx = colWidths.indexOf(Math.max(...colWidths));
-            if (colWidths[maxIdx] <= MIN_COL)
-                break; // can't shrink further
-            colWidths[maxIdx]--;
-            excess--;
-        }
-    }
-    // ── Colors ──
-    const borderColor = blendHex(colors.separator, colors.brand, 0.25);
-    const border = chalk.hex(borderColor);
-    const headerBg = chalk.bgHex(blendHex(colors.panel, colors.brand, 0.15));
-    const evenRowBg = chalk.bgHex(blendHex(colors.panel, colors.text, 0.04));
-    const oddRowBg = chalk.bgHex(colors.panel);
-    const positiveBg = chalk.bgHex(blendHex(colors.panel, colors.success, 0.12));
-    const negativeBg = chalk.bgHex(blendHex(colors.panel, colors.error, 0.12));
-    const out = [];
-    // Top border
-    out.push(border("  ╭" + colWidths.map((w) => "─".repeat(w + 2)).join("┬") + "╮"));
-    // Header row
-    const hdrCells = headers.map((h, i) => {
-        const display = h.length > colWidths[i] ? h.slice(0, colWidths[i] - 1) + "…" : h;
-        const padded = numericCols[i] ? display.padStart(colWidths[i]) : display.padEnd(colWidths[i]);
-        return headerBg(" " + chalk.hex(colors.brand).bold(padded) + " ");
+  function getCellText(cell) {
+    if (!cell) return "";
+    if (typeof cell === "string") return cell;
+    if (cell.text !== undefined) return String(cell.text);
+    if (cell.tokens) {
+      return cell.tokens.map(t => t.raw || t.text || "").join("");
+    }
+    return String(cell);
+  }
+  const headers = (token.header || []).map(h => getCellText(h));
+  const rows = (token.rows || []).map(row => row.map(cell => getCellText(cell)));
+  if (headers.length === 0) return "";
+  const cw = contentWidth();
+  const N = headers.length;
+
+  // ── Check if box table can fit ──
+  // Minimum box table width: indent(2) + borders(N+1) + N * (minCol + 2 padding)
+  const MIN_COL = 3;
+  const minBoxWidth = 2 + (N + 1) + N * (MIN_COL + 2);
+  if (minBoxWidth > cw) {
+    // ── Card layout — graceful fallback for narrow terminals ──
+    return renderTableCards(headers, rows, cw);
+  }
+
+  // ── Box table layout ──
+  const overhead = 2 + 1 + (N - 1) + 1 + N * 2;
+  const availableForContent = cw - overhead;
+  const minCol = cw < 70 ? MIN_COL : cw < 90 ? 5 : 6;
+  const maxPerCol = Math.max(minCol, Math.floor(availableForContent / N));
+
+  // Detect numeric columns for right-alignment
+  const numericCols = headers.map((_, i) => isNumericColumn(rows, i));
+
+  // Size columns: fit content up to maxPerCol, respect minCol
+  const colWidths = headers.map((h, i) => {
+    const dataMax = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
+    return Math.min(maxPerCol, Math.max(minCol, h.length, dataMax) + 2);
+  });
+
+  // Double-check total width won't overflow (defensive)
+  const totalWidth = 2 + 1 + colWidths.reduce((s, w) => s + w + 2, 0) + (N - 1) + 1;
+  if (totalWidth > cw) {
+    // Shrink largest columns until we fit
+    let excess = totalWidth - cw;
+    while (excess > 0) {
+      const maxIdx = colWidths.indexOf(Math.max(...colWidths));
+      if (colWidths[maxIdx] <= MIN_COL) break; // can't shrink further
+      colWidths[maxIdx]--;
+      excess--;
+    }
+  }
+
+  // ── Colors ──
+  const borderColor = blendHex(colors.separator, colors.brand, 0.25);
+  const border = chalk.hex(borderColor);
+  const headerBg = chalk.bgHex(blendHex(colors.panel, colors.brand, 0.15));
+  const evenRowBg = chalk.bgHex(blendHex(colors.panel, colors.text, 0.04));
+  const oddRowBg = chalk.bgHex(colors.panel);
+  const positiveBg = chalk.bgHex(blendHex(colors.panel, colors.success, 0.12));
+  const negativeBg = chalk.bgHex(blendHex(colors.panel, colors.error, 0.12));
+  const out = [];
+
+  // Top border
+  out.push(border("  ╭" + colWidths.map(w => "─".repeat(w + 2)).join("┬") + "╮"));
+
+  // Header row
+  const hdrCells = headers.map((h, i) => {
+    const display = h.length > colWidths[i] ? h.slice(0, colWidths[i] - 1) + "…" : h;
+    const padded = numericCols[i] ? display.padStart(colWidths[i]) : display.padEnd(colWidths[i]);
+    return headerBg(" " + chalk.hex(colors.brand).bold(padded) + " ");
+  }).join(border("│"));
+  out.push(border("  │") + hdrCells + border("│"));
+
+  // Header divider
+  out.push(border("  ├" + colWidths.map(w => "━".repeat(w + 2)).join("┿") + "┤"));
+
+  // Data rows
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    const tone = getRowTone(row);
+    const rowBg = tone === "positive" ? positiveBg : tone === "negative" ? negativeBg : rowIdx % 2 === 0 ? evenRowBg : oddRowBg;
+    const cells = headers.map((_, i) => {
+      const raw = row[i] || "";
+      const display = raw.length > colWidths[i] ? raw.slice(0, colWidths[i] - 1) + "…" : raw;
+      const colored = colorizeCell(display, false);
+      const extraPad = Math.max(0, colWidths[i] - display.length);
+      if (numericCols[i]) {
+        return rowBg(" ".repeat(extraPad) + " " + colored + " ");
+      }
+      return rowBg(" " + colored + " ".repeat(extraPad) + " ");
     }).join(border("│"));
-    out.push(border("  │") + hdrCells + border("│"));
-    // Header divider
-    out.push(border("  ├" + colWidths.map((w) => "━".repeat(w + 2)).join("┿") + "┤"));
-    // Data rows
-    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-        const row = rows[rowIdx];
-        const tone = getRowTone(row);
-        const rowBg = tone === "positive" ? positiveBg
-            : tone === "negative" ? negativeBg
-                : rowIdx % 2 === 0 ? evenRowBg : oddRowBg;
-        const cells = headers.map((_, i) => {
-            const raw = row[i] || "";
-            const display = raw.length > colWidths[i] ? raw.slice(0, colWidths[i] - 1) + "…" : raw;
-            const colored = colorizeCell(display, false);
-            const extraPad = Math.max(0, colWidths[i] - display.length);
-            if (numericCols[i]) {
-                return rowBg(" ".repeat(extraPad) + " " + colored + " ");
-            }
-            return rowBg(" " + colored + " ".repeat(extraPad) + " ");
-        }).join(border("│"));
-        out.push(border("  │") + cells + border("│"));
-    }
-    // Bottom border
-    out.push(border("  ╰" + colWidths.map((w) => "─".repeat(w + 2)).join("┴") + "╯"));
-    return "\n" + out.join("\n") + "\n";
+    out.push(border("  │") + cells + border("│"));
+  }
+
+  // Bottom border
+  out.push(border("  ╰" + colWidths.map(w => "─".repeat(w + 2)).join("┴") + "╯"));
+  return "\n" + out.join("\n") + "\n";
 }
+
 /** Card layout fallback — renders each row as a key: value block. Never overflows. */
 function renderTableCards(headers, rows, cw) {
-    const border = chalk.hex(blendHex(colors.separator, colors.brand, 0.25));
-    const out = [];
-    const innerW = Math.max(8, cw - 6); // indent(2) + border(2) + padding(2)
-    const divider = border("  " + "─".repeat(innerW + 2));
-    // Find longest header for label alignment
-    const maxHdrLen = Math.min(Math.max(...headers.map(h => h.length)), Math.floor(innerW * 0.4));
-    out.push(divider);
-    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-        const row = rows[rowIdx];
-        if (rowIdx > 0)
-            out.push(divider);
-        for (let i = 0; i < headers.length; i++) {
-            const hdr = headers[i].length > maxHdrLen
-                ? headers[i].slice(0, maxHdrLen - 1) + "…"
-                : headers[i];
-            const val = row[i] || "";
-            const maxValLen = innerW - maxHdrLen - 3; // "  label  value"
-            const displayVal = val.length > maxValLen
-                ? val.slice(0, maxValLen - 1) + "…"
-                : val;
-            const labelStr = p.tertiary(hdr.padEnd(maxHdrLen));
-            const valStr = colorizeCell(displayVal, false);
-            out.push(`    ${labelStr}  ${valStr}`);
-        }
-    }
-    out.push(divider);
-    return "\n" + out.join("\n") + "\n";
+  const border = chalk.hex(blendHex(colors.separator, colors.brand, 0.25));
+  const out = [];
+  const innerW = Math.max(8, cw - 6); // indent(2) + border(2) + padding(2)
+  const divider = border("  " + "─".repeat(innerW + 2));
+
+  // Find longest header for label alignment
+  const maxHdrLen = Math.min(Math.max(...headers.map(h => h.length)), Math.floor(innerW * 0.4));
+  out.push(divider);
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    if (rowIdx > 0) out.push(divider);
+    for (let i = 0; i < headers.length; i++) {
+      const hdr = headers[i].length > maxHdrLen ? headers[i].slice(0, maxHdrLen - 1) + "…" : headers[i];
+      const val = row[i] || "";
+      const maxValLen = innerW - maxHdrLen - 3; // "  label  value"
+      const displayVal = val.length > maxValLen ? val.slice(0, maxValLen - 1) + "…" : val;
+      const labelStr = p.tertiary(hdr.padEnd(maxHdrLen));
+      const valStr = colorizeCell(displayVal, false);
+      out.push(`    ${labelStr}  ${valStr}`);
+    }
+  }
+  out.push(divider);
+  return "\n" + out.join("\n") + "\n";
 }
+
 // ============================================================================
 // Rebuild — called on theme switch to refresh all chalk instances
 // ============================================================================
+
 export function rebuildMarkdownRenderer() {
-    p = buildPalette();
-    d = buildDiffStyles();
-    barGradient = buildBarGradient();
-    md = buildMarkedInstance();
+  p = buildPalette();
+  d = buildDiffStyles();
+  barGradient = buildBarGradient();
+  md = buildMarkedInstance();
 }
+
 // Register rebuild callback with theme manager
 setRebuildCallback(rebuildMarkdownRenderer);
+
 // ============================================================================
 // Streaming fence closure — state-tracking approach
 // ============================================================================
+
 /** Extract text outside fenced code blocks */
 function getNonFencedText(input) {
-    const lines = input.split("\n");
-    const parts = [];
-    let inFence = false;
-    for (const line of lines) {
-        if (line.trimStart().startsWith("```")) {
-            inFence = !inFence;
-            continue;
-        }
-        if (!inFence)
-            parts.push(line);
-    }
-    return parts.join("\n");
+  const lines = input.split("\n");
+  const parts = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence) parts.push(line);
+  }
+  return parts.join("\n");
 }
+
 /** Strip complete inline code spans from text */
 function getNonCodeText(t) {
-    return t.replace(/``[^`]*``/g, "").replace(/`[^`\n]*`/g, "");
+  return t.replace(/``[^`]*``/g, "").replace(/`[^`\n]*`/g, "");
 }
+
 /**
  * Close incomplete markdown fences for safe streaming rendering.
  * State-tracking approach: handles nested fences, escaped markers, double-backtick spans.
  */
 export function closeIncompleteFences(input) {
-    let result = input;
-    // 1. Code fences — walk lines, track open/close state
-    let inFence = false;
-    for (const line of result.split("\n")) {
-        const trimmed = line.trimStart();
-        if (trimmed.startsWith("```")) {
-            inFence = !inFence;
-        }
-    }
-    if (inFence) {
-        result += "\n```";
-    }
-    // 2. For inline markers, only examine text OUTSIDE fenced code blocks
-    const outside = getNonFencedText(result);
-    // 3. Inline backticks — remove escaped, remove complete spans, count remainder
-    let forBacktick = outside.replace(/\\`/g, "");
-    forBacktick = forBacktick.replace(/``[^`]*``/g, ""); // double-backtick spans
-    forBacktick = forBacktick.replace(/`[^`\n]*`/g, ""); // single-backtick spans
-    const unmatched = (forBacktick.match(/`/g) || []).length;
-    if (unmatched % 2 !== 0) {
-        result += "`";
-    }
-    // 4. Bold — count ** in non-code text
-    const forBold = getNonCodeText(outside);
-    const boldCount = (forBold.match(/\*\*/g) || []).length;
-    if (boldCount % 2 !== 0) {
-        result += "**";
-    }
-    // 5. Italic — count standalone * (not part of **) with escape awareness
-    const forItalic = forBold.replace(/\*\*/g, "");
-    const italicCount = (forItalic.match(/(?<!\\)\*/g) || []).length;
-    if (italicCount % 2 !== 0) {
-        result += "*";
-    }
-    return result;
+  let result = input;
+
+  // 1. Code fences — walk lines, track open/close state
+  let inFence = false;
+  for (const line of result.split("\n")) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```")) {
+      inFence = !inFence;
+    }
+  }
+  if (inFence) {
+    result += "\n```";
+  }
+
+  // 2. For inline markers, only examine text OUTSIDE fenced code blocks
+  const outside = getNonFencedText(result);
+
+  // 3. Inline backticks — remove escaped, remove complete spans, count remainder
+  let forBacktick = outside.replace(/\\`/g, "");
+  forBacktick = forBacktick.replace(/``[^`]*``/g, ""); // double-backtick spans
+  forBacktick = forBacktick.replace(/`[^`\n]*`/g, ""); // single-backtick spans
+  const unmatched = (forBacktick.match(/`/g) || []).length;
+  if (unmatched % 2 !== 0) {
+    result += "`";
+  }
+
+  // 4. Bold — count ** in non-code text
+  const forBold = getNonCodeText(outside);
+  const boldCount = (forBold.match(/\*\*/g) || []).length;
+  if (boldCount % 2 !== 0) {
+    result += "**";
+  }
+
+  // 5. Italic — count standalone * (not part of **) with escape awareness
+  const forItalic = forBold.replace(/\*\*/g, "");
+  const italicCount = (forItalic.match(/(?<!\\)\*/g) || []).length;
+  if (italicCount % 2 !== 0) {
+    result += "*";
+  }
+  return result;
 }
+
 /**
  * Render markdown to ANSI-styled terminal string.
  * Optionally applies streaming-safe fence closing.
  */
 export function renderMarkdown(input, streaming = false) {
-    const safe = streaming ? closeIncompleteFences(input) : input;
-    const result = md.parse(safe);
-    return result.replace(/\n+$/, "");
+  const safe = streaming ? closeIncompleteFences(input) : input;
+  const result = md.parse(safe);
+  return result.replace(/\n+$/, "");
 }
+//# sourceMappingURL=markdown.js.map