@heyhuynhgiabuu/pi-diff 0.1.1 → 0.1.3

package/src/index.ts

@@ -28,11 +28,292 @@ import { codeToANSI } from "@shikijs/cli";
 import * as Diff from "diff";
 import type { BundledLanguage, BundledTheme } from "shiki";
 
+// ---------------------------------------------------------------------------
+// Diff Theme System — presets, auto-derive, and per-color overrides
+//
+// Resolution chain (per color, highest priority first):
+//   1. Environment variable override (e.g. DIFF_BG_ADD="#1a3320")
+//   2. diffColors.bgAdd from .pi/settings.json (explicit per-color hex)
+//   3. diffTheme preset value (named preset like "midnight")
+//   4. Auto-derived from pi theme fg colors (default behavior)
+//   5. Hardcoded fallback
+// ---------------------------------------------------------------------------
+
+/** Hex color palette for a diff theme preset. All values "#RRGGBB". */
+interface DiffPreset {
+	name: string;
+	description: string;
+	shikiTheme?: string;
+	bgAdd?: string;
+	bgDel?: string;
+	bgAddHighlight?: string;
+	bgDelHighlight?: string;
+	bgGutterAdd?: string;
+	bgGutterDel?: string;
+	bgEmpty?: string;
+	fgAdd?: string;
+	fgDel?: string;
+	fgDim?: string;
+	fgLnum?: string;
+	fgRule?: string;
+	fgStripe?: string;
+	fgSafeMuted?: string;
+}
+
+/** User diff config read from .pi/settings.json */
+interface DiffUserConfig {
+	diffTheme?: string;
+	diffColors?: Record<string, string>;
+}
+
+const DIFF_PRESETS: Record<string, DiffPreset> = {
+	default: {
+		name: "default",
+		description: "Original pi-diff colors — tuned for dark theme bases (~#1e1e2e)",
+		bgAdd: "#162620",
+		bgDel: "#2d1919",
+		bgAddHighlight: "#234b32",
+		bgDelHighlight: "#502323",
+		bgGutterAdd: "#12201a",
+		bgGutterDel: "#261616",
+		bgEmpty: "#121212",
+		fgDim: "#505050",
+		fgLnum: "#646464",
+		fgRule: "#323232",
+		fgStripe: "#282828",
+		fgSafeMuted: "#8b949e",
+	},
+	midnight: {
+		name: "midnight",
+		description: "Subtle tints for pure black (#000000) terminal backgrounds",
+		bgAdd: "#0d1a12",
+		bgDel: "#1a0d0d",
+		bgAddHighlight: "#1a3825",
+		bgDelHighlight: "#381a1a",
+		bgGutterAdd: "#091208",
+		bgGutterDel: "#120908",
+		bgEmpty: "#080808",
+		fgDim: "#404040",
+		fgLnum: "#505050",
+		fgRule: "#282828",
+		fgStripe: "#1e1e1e",
+		fgSafeMuted: "#8b949e",
+	},
+	subtle: {
+		name: "subtle",
+		description: "Minimal backgrounds — barely-there tints for a clean look",
+		bgAdd: "#081008",
+		bgDel: "#100808",
+		bgAddHighlight: "#122818",
+		bgDelHighlight: "#281212",
+		bgGutterAdd: "#060c06",
+		bgGutterDel: "#0c0606",
+		bgEmpty: "#060606",
+		fgDim: "#383838",
+		fgLnum: "#484848",
+		fgRule: "#242424",
+		fgStripe: "#181818",
+		fgSafeMuted: "#8b949e",
+	},
+	neon: {
+		name: "neon",
+		description: "Higher contrast backgrounds for better visibility",
+		bgAdd: "#1a3320",
+		bgDel: "#331a16",
+		bgAddHighlight: "#2d5c3a",
+		bgDelHighlight: "#5c2d2d",
+		bgGutterAdd: "#142818",
+		bgGutterDel: "#28120e",
+		bgEmpty: "#141414",
+		fgDim: "#606060",
+		fgLnum: "#787878",
+		fgRule: "#404040",
+		fgStripe: "#303030",
+		fgSafeMuted: "#9da5ae",
+	},
+};
+
+/** Parse 24-bit ANSI color code → RGB. Works for both fg and bg escapes. */
+function parseAnsiRgb(ansi: string): { r: number; g: number; b: number } | null {
+	const esc = "\u001b";
+	const m = ansi.match(new RegExp(`${esc}\\[(?:38|48);2;(\\d+);(\\d+);(\\d+)m`));
+	return m ? { r: +m[1], g: +m[2], b: +m[3] } : null;
+}
+
+/** Convert "#RRGGBB" hex → ANSI 24-bit background escape. */
+function hexToBgAnsi(hex: string): string {
+	if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex)) return "";
+	const r = Number.parseInt(hex.slice(1, 3), 16);
+	const g = Number.parseInt(hex.slice(3, 5), 16);
+	const b = Number.parseInt(hex.slice(5, 7), 16);
+	return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+/** Convert "#RRGGBB" hex → ANSI 24-bit foreground escape. */
+function hexToFgAnsi(hex: string): string {
+	if (!hex || !/^#[0-9a-fA-F]{6}$/.test(hex)) return "";
+	const r = Number.parseInt(hex.slice(1, 3), 16);
+	const g = Number.parseInt(hex.slice(3, 5), 16);
+	const b = Number.parseInt(hex.slice(5, 7), 16);
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+/** Derive a muted background ANSI code from a foreground ANSI code.
+ *  Scales the fg RGB by `intensity` (0.0–1.0) to produce a subtle tint. */
+function deriveBgFromFg(fgAnsi: string, intensity: number): string {
+	const rgb = parseAnsiRgb(fgAnsi);
+	if (!rgb) return "";
+	const r = Math.round(rgb.r * intensity);
+	const g = Math.round(rgb.g * intensity);
+	const b = Math.round(rgb.b * intensity);
+	return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+/** Mix an accent color into a base color at the given intensity (0.0–1.0).
+ *  Returns an ANSI 24-bit background escape. Used to derive diff backgrounds
+ *  that blend with the tool box background (toolSuccessBg). */
+function mixBg(base: { r: number; g: number; b: number }, accent: { r: number; g: number; b: number }, intensity: number): string {
+	const r = Math.round(base.r + (accent.r - base.r) * intensity);
+	const g = Math.round(base.g + (accent.g - base.g) * intensity);
+	const b = Math.round(base.b + (accent.b - base.b) * intensity);
+	return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+/** Whether auto-derive from theme is still pending (runs lazily on first render). */
+let _autoDerivePending = true;
+
+/** Whether user set explicit bg config (via preset or per-color overrides). */
+let _hasExplicitBgConfig = false;
+
+/** Auto-derive all diff background colors from the pi theme's fg diff colors.
+ *  Reads toolSuccessBg as the base and mixes accent colors into it.
+ *  Falls back to black (0,0,0) as base if toolSuccessBg is unavailable. */
+function autoDeriveBgFromTheme(theme: any): void {
+	if (!theme?.getFgAnsi) return;
+	try {
+		const fgAdd = theme.getFgAnsi("toolDiffAdded");
+		const fgDel = theme.getFgAnsi("toolDiffRemoved");
+		const addRgb = parseAnsiRgb(fgAdd);
+		const delRgb = parseAnsiRgb(fgDel);
+		if (!addRgb || !delRgb) return;
+
+		// Read toolSuccessBg as the base background color
+		let base = { r: 0, g: 0, b: 0 };
+		if (theme.getBgAnsi) {
+			try {
+				const bgAnsi = theme.getBgAnsi("toolSuccessBg");
+				const parsed = parseAnsiRgb(bgAnsi);
+				if (parsed) {
+					base = parsed;
+					BG_BASE = bgAnsi;
+				}
+			} catch { /* no toolSuccessBg — use black */ }
+		}
+
+		// Line backgrounds — subtle accent mixed into base (8–10%)
+		BG_ADD = mixBg(base, addRgb, 0.08);
+		BG_DEL = mixBg(base, delRgb, 0.10);
+
+		// Word-level highlights — more visible (20–22%)
+		BG_ADD_W = mixBg(base, addRgb, 0.20);
+		BG_DEL_W = mixBg(base, delRgb, 0.22);
+
+		// Gutters — subtler than lines (5–6%)
+		BG_GUTTER_ADD = mixBg(base, addRgb, 0.05);
+		BG_GUTTER_DEL = mixBg(base, delRgb, 0.06);
+
+		// Empty filler and context — match the base
+		BG_EMPTY = BG_BASE;
+
+		// Rebuild derived constants
+		DIVIDER = `${FG_RULE}│${RST}`;
+	} catch {
+		// Fall back to defaults silently
+	}
+}
+
+/** Load diff theme config from .pi/settings.json (project-level, then global). */
+function loadDiffConfig(): DiffUserConfig {
+	const paths = [
+		`${process.cwd()}/.pi/settings.json`,
+		`${process.env.HOME ?? ""}/.pi/settings.json`,
+	];
+	for (const p of paths) {
+		try {
+			if (existsSync(p)) {
+				const raw = JSON.parse(readFileSync(p, "utf-8"));
+				if (raw.diffTheme || raw.diffColors) {
+					return { diffTheme: raw.diffTheme, diffColors: raw.diffColors };
+				}
+			}
+		} catch {
+			// skip invalid files
+		}
+	}
+	return {};
+}
+
+/** Apply diff palette from settings → preset → (auto-derive deferred) → defaults.
+ *  Called once during extension initialization. */
+function applyDiffPalette(): void {
+	const config = loadDiffConfig();
+
+	// Load preset if specified
+	const preset = config.diffTheme ? DIFF_PRESETS[config.diffTheme] : null;
+	if (preset) _hasExplicitBgConfig = true;
+
+	// Per-color overrides from settings
+	const ov = config.diffColors ?? {};
+	if (Object.keys(ov).length > 0) _hasExplicitBgConfig = true;
+
+	// Helper: apply a hex bg color if not env-overridden
+	const applyBg = (envName: string | null, key: string, presetVal: string | undefined, set: (v: string) => void) => {
+		if (envName && process.env[envName]) return; // env override wins
+		const hex = ov[key] ?? presetVal;
+		if (hex) { const a = hexToBgAnsi(hex); if (a) set(a); }
+	};
+	// Helper: apply a hex fg color if not env-overridden
+	const applyFg = (envName: string | null, key: string, presetVal: string | undefined, set: (v: string) => void) => {
+		if (envName && process.env[envName]) return;
+		const hex = ov[key] ?? presetVal;
+		if (hex) { const a = hexToFgAnsi(hex); if (a) set(a); }
+	};
+
+	// --- Apply backgrounds ---
+	applyBg("DIFF_BG_ADD", "bgAdd", preset?.bgAdd, (v) => { BG_ADD = v; });
+	applyBg("DIFF_BG_DEL", "bgDel", preset?.bgDel, (v) => { BG_DEL = v; });
+	applyBg("DIFF_BG_ADD_HL", "bgAddHighlight", preset?.bgAddHighlight, (v) => { BG_ADD_W = v; });
+	applyBg("DIFF_BG_DEL_HL", "bgDelHighlight", preset?.bgDelHighlight, (v) => { BG_DEL_W = v; });
+	applyBg("DIFF_BG_GUTTER_ADD", "bgGutterAdd", preset?.bgGutterAdd, (v) => { BG_GUTTER_ADD = v; });
+	applyBg("DIFF_BG_GUTTER_DEL", "bgGutterDel", preset?.bgGutterDel, (v) => { BG_GUTTER_DEL = v; });
+	applyBg(null, "bgEmpty", preset?.bgEmpty, (v) => { BG_EMPTY = v; });
+
+	// --- Apply foregrounds ---
+	applyFg("DIFF_FG_ADD", "fgAdd", preset?.fgAdd, (v) => { FG_ADD = v; });
+	applyFg("DIFF_FG_DEL", "fgDel", preset?.fgDel, (v) => { FG_DEL = v; });
+	applyFg(null, "fgDim", preset?.fgDim, (v) => { FG_DIM = v; });
+	applyFg(null, "fgLnum", preset?.fgLnum, (v) => { FG_LNUM = v; });
+	applyFg(null, "fgRule", preset?.fgRule, (v) => { FG_RULE = v; });
+	applyFg(null, "fgStripe", preset?.fgStripe, (v) => { FG_STRIPE = v; });
+	applyFg(null, "fgSafeMuted", preset?.fgSafeMuted, (v) => { FG_SAFE_MUTED = v; });
+
+	// --- Shiki syntax theme ---
+	const shiki = ov.shikiTheme ?? preset?.shikiTheme;
+	if (shiki) THEME = shiki as BundledTheme;
+
+	// --- Rebuild derived constants ---
+	DIVIDER = `${FG_RULE}│${RST}`;
+	DEFAULT_DIFF_COLORS = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+
+	// If no explicit bg config, auto-derive will run on first render
+	_autoDerivePending = !_hasExplicitBgConfig;
+}
+
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 
-const THEME: BundledTheme = (process.env.DIFF_THEME as BundledTheme | undefined) ?? "github-dark";
+let THEME: BundledTheme = (process.env.DIFF_THEME as BundledTheme | undefined) ?? "github-dark";
 
 function envInt(name: string, fallback: number): number {
 	const v = Number.parseInt(process.env[name] ?? "", 10);
@@ -60,30 +341,30 @@ function envBg(name: string, fallback: string): string {
 // --- Split-view thresholds ---
 // Split is preferred when there's real room. At narrow widths, a clean stacked
 // (unified) view is better than a cramped split with wrapping.
-const SPLIT_MIN_WIDTH = envInt("DIFF_SPLIT_MIN_WIDTH", 150);          // need ≥150 cols for split to breathe
+const SPLIT_MIN_WIDTH = envInt("DIFF_SPLIT_MIN_WIDTH", 150); // need ≥150 cols for split to breathe
 const SPLIT_MIN_CODE_WIDTH = envInt("DIFF_SPLIT_MIN_CODE_WIDTH", 60); // ≥60 code cols per side
-const SPLIT_MAX_WRAP_RATIO = 0.20;      // if >20% lines wrap in split, fall back to stacked
-const SPLIT_MAX_WRAP_LINES = 8;         // absolute cap before unified fallback
+const SPLIT_MAX_WRAP_RATIO = 0.2; // if >20% lines wrap in split, fall back to stacked
+const SPLIT_MAX_WRAP_LINES = 8; // absolute cap before unified fallback
 
 // --- Terminal bounds ---
-const MAX_TERM_WIDTH = 210;             // max for 1728px wide display (~205 cols at typical font)
-const DEFAULT_TERM_WIDTH = 200;         // safe default for 1728x1117 resolution
+const MAX_TERM_WIDTH = 210; // max for 1728px wide display (~205 cols at typical font)
+const DEFAULT_TERM_WIDTH = 200; // safe default for 1728x1117 resolution
 
 // --- Rendering limits ---
-const MAX_PREVIEW_LINES = 60;           // was 50 — show slightly more context in edit preview
-const MAX_RENDER_LINES = 150;           // was 120 — show more of the diff in write tool
-const MAX_HL_CHARS = 80_000;            // was 50k — allow syntax hl for larger diffs
-const CACHE_LIMIT = 192;               // was 128 — bigger cache for multi-file sessions
+const MAX_PREVIEW_LINES = 60; // was 50 — show slightly more context in edit preview
+const MAX_RENDER_LINES = 150; // was 120 — show more of the diff in write tool
+const MAX_HL_CHARS = 80_000; // was 50k — allow syntax hl for larger diffs
+const CACHE_LIMIT = 192; // was 128 — bigger cache for multi-file sessions
 
 // --- Word diff ---
-const WORD_DIFF_MIN_SIM = 0.15;        // was 0.2 — show word diffs for slightly less similar lines
+const WORD_DIFF_MIN_SIM = 0.15; // was 0.2 — show word diffs for slightly less similar lines
 
 // --- Wrapping ---
 // Adaptive: narrow terminals truncate aggressively, wide terminals allow wrapping.
 // Actual wrap rows are computed per-render via adaptiveWrapRows().
-const MAX_WRAP_ROWS_WIDE = 3;          // ≥180 cols
-const MAX_WRAP_ROWS_MED  = 2;          // 120–179 cols
-const MAX_WRAP_ROWS_NARROW = 1;        // <120 cols (truncate, no wrap)
+const MAX_WRAP_ROWS_WIDE = 3; // ≥180 cols
+const MAX_WRAP_ROWS_MED = 2; // 120–179 cols
+const MAX_WRAP_ROWS_NARROW = 1; // <120 cols (truncate, no wrap)
 
 // ---------------------------------------------------------------------------
 // ANSI
@@ -95,24 +376,24 @@ const DIM = "\x1b[2m";
 
 // Subtle diff backgrounds — muted tones to let syntax fg shine through
 // Override via env: DIFF_BG_ADD="#1a3320" etc. (hex "#RRGGBB" format)
-const BG_ADD   = envBg("DIFF_BG_ADD",    "\x1b[48;2;22;38;32m");      // muted teal-green
-const BG_DEL   = envBg("DIFF_BG_DEL",    "\x1b[48;2;45;25;25m");      // muted brown-red
-const BG_ADD_W = envBg("DIFF_BG_ADD_HL", "\x1b[48;2;35;75;50m");      // word-level emphasis
-const BG_DEL_W = envBg("DIFF_BG_DEL_HL", "\x1b[48;2;80;35;35m");
-const BG_GUTTER_ADD = envBg("DIFF_BG_GUTTER_ADD", "\x1b[48;2;18;32;26m");
-const BG_GUTTER_DEL = envBg("DIFF_BG_GUTTER_DEL", "\x1b[48;2;38;22;22m");
-const BG_GUTTER_CTX = "";  // use terminal default bg for context gutters
-const BG_EMPTY = "\x1b[48;2;18;18;18m";     // filler rows when one side is shorter
+let BG_ADD = envBg("DIFF_BG_ADD", "\x1b[48;2;22;38;32m"); // muted teal-green
+let BG_DEL = envBg("DIFF_BG_DEL", "\x1b[48;2;45;25;25m"); // muted brown-red
+let BG_ADD_W = envBg("DIFF_BG_ADD_HL", "\x1b[48;2;35;75;50m"); // word-level emphasis
+let BG_DEL_W = envBg("DIFF_BG_DEL_HL", "\x1b[48;2;80;35;35m");
+let BG_GUTTER_ADD = envBg("DIFF_BG_GUTTER_ADD", "\x1b[48;2;18;32;26m");
+let BG_GUTTER_DEL = envBg("DIFF_BG_GUTTER_DEL", "\x1b[48;2;38;22;22m");
+const BG_GUTTER_CTX = ""; // use terminal default bg for context gutters
+let BG_EMPTY = "\x1b[48;2;18;18;18m"; // filler rows when one side is shorter
 
 // Diff foregrounds — override via env: DIFF_FG_ADD="#50d264" etc.
-const FG_ADD  = envFg("DIFF_FG_ADD",  "\x1b[38;2;100;180;120m");      // desaturated green
-const FG_DEL  = envFg("DIFF_FG_DEL",  "\x1b[38;2;200;100;100m");      // desaturated red
-const FG_DIM  = "\x1b[38;2;80;80;80m";
-const FG_LNUM = "\x1b[38;2;100;100;100m";
-const FG_RULE = "\x1b[38;2;50;50;50m";
-const FG_SAFE_MUTED = "\x1b[38;2;139;148;158m";
+let FG_ADD = envFg("DIFF_FG_ADD", "\x1b[38;2;100;180;120m"); // desaturated green
+let FG_DEL = envFg("DIFF_FG_DEL", "\x1b[38;2;200;100;100m"); // desaturated red
+let FG_DIM = "\x1b[38;2;80;80;80m";
+let FG_LNUM = "\x1b[38;2;100;100;100m";
+let FG_RULE = "\x1b[38;2;50;50;50m";
+let FG_SAFE_MUTED = "\x1b[38;2;139;148;158m";
 
-const FG_STRIPE = "\x1b[38;2;40;40;40m"; // gray diagonal stripes on terminal default bg
+let FG_STRIPE = "\x1b[38;2;40;40;40m"; // gray diagonal stripes on terminal default bg
 
 const BORDER_BAR = "▌";
 
@@ -122,9 +403,13 @@ function stripes(w: number, _rowOffset: number): string {
 	return FG_STRIPE + "╱".repeat(w) + RST;
 }
 
-const DIVIDER = `${FG_RULE}│${RST}`;
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
+let DIVIDER = `${FG_RULE}│${RST}`;
+const ESC_RE = "\u001b";
+const ANSI_RE = new RegExp(`${ESC_RE}\\[[0-9;]*m`, "g");
+const ANSI_CAPTURE_RE = new RegExp(`${ESC_RE}\\[([^m]*)m`, "g");
+const ANSI_PARAM_CAPTURE_RE = new RegExp(`${ESC_RE}\\[([0-9;]*)m`, "g");
 const BG_DEFAULT = "\x1b[49m"; // reset to terminal default background
+let BG_BASE = BG_DEFAULT; // tool box base bg — updated from theme's toolSuccessBg
 
 // ---------------------------------------------------------------------------
 // Theme-aware diff colors
@@ -137,10 +422,27 @@ interface DiffColors {
 	fgCtx: string;
 }
 
-const DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+let DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
 
-/** Resolve diff fg colors from theme (if available), falling back to hardcoded ANSI. */
+/** Resolve diff fg colors from theme (if available), falling back to hardcoded ANSI.
+ *  On first call with a valid theme, auto-derives bg colors if no explicit config was set.
+ *  Always reads toolSuccessBg for BG_BASE (used for context line backgrounds). */
 function resolveDiffColors(theme?: any): DiffColors {
+	// Always read toolSuccessBg for BG_BASE (even with explicit config)
+	if (theme?.getBgAnsi && BG_BASE === BG_DEFAULT) {
+		try {
+			const bgAnsi = theme.getBgAnsi("toolSuccessBg");
+			const parsed = parseAnsiRgb(bgAnsi);
+			if (parsed) BG_BASE = bgAnsi;
+		} catch { /* ignore */ }
+	}
+
+	// Auto-derive bg colors from theme on first render (if no explicit preset/overrides)
+	if (_autoDerivePending && theme?.getFgAnsi) {
+		autoDeriveBgFromTheme(theme);
+		_autoDerivePending = false;
+	}
+
 	if (!theme?.getFgAnsi) return DEFAULT_DIFF_COLORS;
 	try {
 		const fgAdd = theme.getFgAnsi("toolDiffAdded") || FG_ADD;
@@ -186,16 +488,21 @@ interface ParsedDiff {
 // Utilities
 // ---------------------------------------------------------------------------
 
-function strip(s: string): string { return s.replace(ANSI_RE, ""); }
+function strip(s: string): string {
+	return s.replace(ANSI_RE, "");
+}
 
-function tabs(s: string): string { return s.replace(/\t/g, "  "); }
+function tabs(s: string): string {
+	return s.replace(/\t/g, "  ");
+}
 
 function termW(): number {
 	// Try multiple sources — process.stdout.columns may be undefined in piped/subagent contexts
-	const raw = process.stdout.columns
-		|| (process.stderr as any).columns
-		|| Number.parseInt(process.env.COLUMNS ?? "", 10)
-		|| DEFAULT_TERM_WIDTH;
+	const raw =
+		process.stdout.columns ||
+		(process.stderr as any).columns ||
+		Number.parseInt(process.env.COLUMNS ?? "", 10) ||
+		DEFAULT_TERM_WIDTH;
 	return Math.max(80, Math.min(raw - 4, MAX_TERM_WIDTH)); // -4 safety margin for pi TUI padding
 }
 
@@ -206,27 +513,39 @@ function fit(s: string, w: number): string {
 	if (plain.length <= w) return s + " ".repeat(w - plain.length);
 	// Truncated — show content + dim › indicator
 	const showW = w > 2 ? w - 1 : w;
-	let vis = 0, i = 0;
+	let vis = 0,
+		i = 0;
 	while (i < s.length && vis < showW) {
-		if (s[i] === "\x1b") { const e = s.indexOf("m", i); if (e !== -1) { i = e + 1; continue; } }
-		vis++; i++;
+		if (s[i] === "\x1b") {
+			const e = s.indexOf("m", i);
+			if (e !== -1) {
+				i = e + 1;
+				continue;
+			}
+		}
+		vis++;
+		i++;
 	}
-	return w > 2
-		? s.slice(0, i) + RST + FG_DIM + "›" + RST
-		: s.slice(0, i) + RST;
+	return w > 2 ? `${s.slice(0, i)}${RST}${FG_DIM}›${RST}` : `${s.slice(0, i)}${RST}`;
 }
 
 /** Extract last active fg + bg ANSI codes from a string. Used for wrapping continuations. */
 function ansiState(s: string): string {
-	let fg = "", bg = "";
-	const re = /\x1b\[([^m]*)m/g;
-	let m: RegExpExecArray | null;
-	while ((m = re.exec(s)) !== null) {
-		const p = m[1];
-		if (p === "0") { fg = ""; bg = ""; }
-		else if (p === "39") { fg = ""; }
-		else if (p.startsWith("38;")) { fg = m[0]; }
-		else if (p.startsWith("48;")) { bg = m[0]; }
+	let fg = "",
+		bg = "";
+	for (const match of s.matchAll(ANSI_CAPTURE_RE)) {
+		const p = match[1] ?? "";
+		const seq = match[0] ?? "";
+		if (p === "0") {
+			fg = "";
+			bg = "";
+		} else if (p === "39") {
+			fg = "";
+		} else if (p.startsWith("38;")) {
+			fg = seq;
+		} else if (p.startsWith("48;")) {
+			bg = seq;
+		}
 	}
 	return bg + fg;
 }
@@ -238,14 +557,14 @@ function isLowContrastShikiFg(params: string): boolean {
 	const parts = params.split(";").map(Number);
 	if (parts.length !== 5 || parts.some((n) => !Number.isFinite(n))) return false;
 	const [, , r, g, b] = parts;
-	const luminance = (0.2126 * r) + (0.7152 * g) + (0.0722 * b);
+	const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
 	return luminance < 72;
 }
 
 function normalizeShikiContrast(ansi: string): string {
-	return ansi.replace(/\x1b\[([0-9;]*)m/g, (seq, params: string) => (
-		isLowContrastShikiFg(params) ? FG_SAFE_MUTED : seq
-	));
+	return ansi.replace(ANSI_PARAM_CAPTURE_RE, (seq, params: string) =>
+		isLowContrastShikiFg(params) ? FG_SAFE_MUTED : seq,
+	);
 }
 
 /** Wrap ANSI-encoded string into rows of `w` visible chars. Max `maxRows` rows; last row truncates with ›. */
@@ -258,7 +577,9 @@ function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(), fillBg = "
 	}
 
 	const rows: string[] = [];
-	let row = "", vis = 0, i = 0;
+	let row = "",
+		vis = 0,
+		i = 0;
 	let onLastRow = false;
 	let effW = w;
 
@@ -272,7 +593,11 @@ function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(), fillBg = "
 		// Pass through ANSI escapes
 		if (s[i] === "\x1b") {
 			const end = s.indexOf("m", i);
-			if (end !== -1) { row += s.slice(i, end + 1); i = end + 1; continue; }
+			if (end !== -1) {
+				row += s.slice(i, end + 1);
+				i = end + 1;
+				continue;
+			}
 		}
 
 		// Row full
@@ -281,10 +606,17 @@ function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(), fillBg = "
 				// Check if remaining string has visible chars
 				let hasMore = false;
 				for (let j = i; j < s.length; j++) {
-					if (s[j] === "\x1b") { const e2 = s.indexOf("m", j); if (e2 !== -1) { j = e2; continue; } }
-					hasMore = true; break;
+					if (s[j] === "\x1b") {
+						const e2 = s.indexOf("m", j);
+						if (e2 !== -1) {
+							j = e2;
+							continue;
+						}
+					}
+					hasMore = true;
+					break;
 				}
-				if (hasMore && w > 2) row += RST + FG_DIM + "›" + RST;
+				if (hasMore && w > 2) row += `${RST}${FG_DIM}›${RST}`;
 				else row += fillBg + " ".repeat(Math.max(0, w - vis)) + RST;
 				rows.push(row);
 				return rows;
@@ -294,10 +626,15 @@ function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(), fillBg = "
 			rows.push(row + RST);
 			row = state + fillBg;
 			vis = 0;
-			if (rows.length >= maxRows - 1) { onLastRow = true; effW = w > 2 ? w - 1 : w; }
+			if (rows.length >= maxRows - 1) {
+				onLastRow = true;
+				effW = w > 2 ? w - 1 : w;
+			}
 		}
 
-		row += s[i]; vis++; i++;
+		row += s[i];
+		vis++;
+		i++;
 	}
 
 	// Final row, padded
@@ -341,7 +678,7 @@ function shouldUseSplit(diff: ParsedDiff, tw: number, maxRows = MAX_PREVIEW_LINE
 	if (!diff.lines.length) return false;
 	if (tw < SPLIT_MIN_WIDTH) return false;
 
-	const nw = Math.max(2, String(Math.max(...diff.lines.map(l => l.oldNum ?? l.newNum ?? 0), 0)).length);
+	const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
 	const half = Math.floor((tw - 1) / 2); // -1 for center divider
 	const gw = nw + 5; // border + num + sign + sp + │ + sp
 	const cw = Math.max(12, half - gw);
@@ -369,16 +706,43 @@ function shouldUseSplit(diff: ParsedDiff, tw: number, maxRows = MAX_PREVIEW_LINE
 // ---------------------------------------------------------------------------
 
 const EXT_LANG: Record<string, BundledLanguage> = {
-	ts: "typescript", tsx: "tsx", js: "javascript", jsx: "jsx",
-	mjs: "javascript", cjs: "javascript",
-	py: "python", rb: "ruby", rs: "rust", go: "go", java: "java",
-	c: "c", cpp: "cpp", h: "c", hpp: "cpp", cs: "csharp",
-	swift: "swift", kt: "kotlin",
-	html: "html", css: "css", scss: "scss",
-	json: "json", yaml: "yaml", yml: "yaml", toml: "toml",
-	md: "markdown", sql: "sql", sh: "bash", bash: "bash", zsh: "bash",
-	lua: "lua", php: "php", dart: "dart", xml: "xml",
-	graphql: "graphql", svelte: "svelte", vue: "vue",
+	ts: "typescript",
+	tsx: "tsx",
+	js: "javascript",
+	jsx: "jsx",
+	mjs: "javascript",
+	cjs: "javascript",
+	py: "python",
+	rb: "ruby",
+	rs: "rust",
+	go: "go",
+	java: "java",
+	c: "c",
+	cpp: "cpp",
+	h: "c",
+	hpp: "cpp",
+	cs: "csharp",
+	swift: "swift",
+	kt: "kotlin",
+	html: "html",
+	css: "css",
+	scss: "scss",
+	json: "json",
+	yaml: "yaml",
+	yml: "yaml",
+	toml: "toml",
+	md: "markdown",
+	sql: "sql",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	lua: "lua",
+	php: "php",
+	dart: "dart",
+	xml: "xml",
+	graphql: "graphql",
+	svelte: "svelte",
+	vue: "vue",
 };
 
 function lang(fp: string): BundledLanguage | undefined {
@@ -396,7 +760,8 @@ codeToANSI("", "typescript", THEME).catch(() => {});
 const _cache = new Map<string, string[]>();
 
 function _touch(k: string, v: string[]): string[] {
-	_cache.delete(k); _cache.set(k, v);
+	_cache.delete(k);
+	_cache.set(k, v);
 	while (_cache.size > CACHE_LIMIT) {
 		const first = _cache.keys().next().value;
 		if (first === undefined) break;
@@ -429,7 +794,8 @@ async function hlBlock(code: string, language: BundledLanguage | undefined): Pro
 function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff {
 	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: ctx });
 	const lines: DiffLine[] = [];
-	let added = 0, removed = 0;
+	let added = 0,
+		removed = 0;
 
 	for (let hi = 0; hi < patch.hunks.length; hi++) {
 		if (hi > 0) {
@@ -438,13 +804,21 @@ function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff
 			lines.push({ type: "sep", oldNum: null, newNum: gap > 0 ? gap : null, content: "" });
 		}
 		const h = patch.hunks[hi];
-		let oL = h.oldStart, nL = h.newStart;
+		let oL = h.oldStart,
+			nL = h.newStart;
 		for (const raw of h.lines) {
 			if (raw === "\") continue;
-			const ch = raw[0], text = raw.slice(1);
-			if (ch === "+") { lines.push({ type: "add", oldNum: null, newNum: nL++, content: text }); added++; }
-			else if (ch === "-") { lines.push({ type: "del", oldNum: oL++, newNum: null, content: text }); removed++; }
-			else { lines.push({ type: "ctx", oldNum: oL++, newNum: nL++, content: text }); }
+			const ch = raw[0],
+				text = raw.slice(1);
+			if (ch === "+") {
+				lines.push({ type: "add", oldNum: null, newNum: nL++, content: text });
+				added++;
+			} else if (ch === "-") {
+				lines.push({ type: "del", oldNum: oL++, newNum: null, content: text });
+				removed++;
+			} else {
+				lines.push({ type: "ctx", oldNum: oL++, newNum: nL++, content: text });
+			}
 		}
 	}
 	return { lines, added, removed, chars: oldContent.length + newContent.length };
@@ -464,7 +838,10 @@ function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff
  * similarity score and character ranges for emphasis highlighting.
  * Replaces separate wordDiffRanges + wordDiffSimilarity (which called diffWords twice).
  */
-function wordDiffAnalysis(a: string, b: string): {
+function wordDiffAnalysis(
+	a: string,
+	b: string,
+): {
 	similarity: number;
 	oldRanges: Array<[number, number]>;
 	newRanges: Array<[number, number]>;
@@ -473,11 +850,22 @@ function wordDiffAnalysis(a: string, b: string): {
 	const parts = Diff.diffWords(a, b);
 	const oldRanges: Array<[number, number]> = [];
 	const newRanges: Array<[number, number]> = [];
-	let oPos = 0, nPos = 0, same = 0;
+	let oPos = 0,
+		nPos = 0,
+		same = 0;
 	for (const p of parts) {
-		if (p.removed) { oldRanges.push([oPos, oPos + p.value.length]); oPos += p.value.length; }
-		else if (p.added) { newRanges.push([nPos, nPos + p.value.length]); nPos += p.value.length; }
-		else { const len = p.value.length; same += len; oPos += len; nPos += len; }
+		if (p.removed) {
+			oldRanges.push([oPos, oPos + p.value.length]);
+			oPos += p.value.length;
+		} else if (p.added) {
+			newRanges.push([nPos, nPos + p.value.length]);
+			nPos += p.value.length;
+		} else {
+			const len = p.value.length;
+			same += len;
+			oPos += len;
+			nPos += len;
+		}
 	}
 	const maxLen = Math.max(a.length, b.length);
 	return { similarity: maxLen > 0 ? same / maxLen : 1, oldRanges, newRanges };
@@ -490,12 +878,7 @@ function wordDiffAnalysis(a: string, b: string): {
  *
  * Uses sorted-range pointer scan instead of Set (avoids O(totalChars) Set creation).
  */
-function injectBg(
-	ansiLine: string,
-	ranges: Array<[number, number]>,
-	baseBg: string,
-	hlBg: string,
-): string {
+function injectBg(ansiLine: string, ranges: Array<[number, number]>, baseBg: string, hlBg: string): string {
 	if (!ranges.length) return baseBg + ansiLine + RST;
 
 	let out = baseBg;
@@ -519,9 +902,13 @@ function injectBg(
 		// Advance past exhausted ranges
 		while (ri < ranges.length && vis >= ranges[ri][1]) ri++;
 		const want = ri < ranges.length && vis >= ranges[ri][0] && vis < ranges[ri][1];
-		if (want !== inHL) { inHL = want; out += inHL ? hlBg : baseBg; }
+		if (want !== inHL) {
+			inHL = want;
+			out += inHL ? hlBg : baseBg;
+		}
 		out += ansiLine[i];
-		vis++; i++;
+		vis++;
+		i++;
 	}
 	return out + RST;
 }
@@ -529,11 +916,15 @@ function injectBg(
 /** Simple word diff (no syntax hl) — fallback when Shiki isn't available. */
 function plainWordDiff(oldText: string, newText: string): { old: string; new: string } {
 	const parts = Diff.diffWords(oldText, newText);
-	let o = "", n = "";
+	let o = "",
+		n = "";
 	for (const p of parts) {
 		if (p.removed) o += `${BG_DEL_W}${p.value}${RST}${BG_DEL}`;
 		else if (p.added) n += `${BG_ADD_W}${p.value}${RST}${BG_ADD}`;
-		else { o += p.value; n += p.value; }
+		else {
+			o += p.value;
+			n += p.value;
+		}
 	}
 	return { old: o, new: n };
 }
@@ -549,18 +940,24 @@ function plainWordDiff(oldText: string, newText: string): { old: string; new: st
 //   • Paired del/add lines adjacent with word-level emphasis
 // ---------------------------------------------------------------------------
 
-async function renderUnified(diff: ParsedDiff, language: BundledLanguage | undefined, max = MAX_RENDER_LINES, dc: DiffColors = DEFAULT_DIFF_COLORS): Promise<string> {
+async function renderUnified(
+	diff: ParsedDiff,
+	language: BundledLanguage | undefined,
+	max = MAX_RENDER_LINES,
+	dc: DiffColors = DEFAULT_DIFF_COLORS,
+): Promise<string> {
 	if (!diff.lines.length) return "";
 
 	const vis = diff.lines.slice(0, max);
 	const tw = termW();
-	const nw = Math.max(2, String(Math.max(...vis.map(l => l.oldNum ?? l.newNum ?? 0), 0)).length);
+	const nw = Math.max(2, String(Math.max(...vis.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
 	const gw = nw + 5; // border + num + sign + sp + │ + sp
 	const cw = Math.max(20, tw - gw);
 	const canHL = diff.chars <= MAX_HL_CHARS && vis.length <= MAX_RENDER_LINES;
 
 	// Build separate old/new code blocks for highlighting
-	const oldSrc: string[] = [], newSrc: string[] = [];
+	const oldSrc: string[] = [],
+		newSrc: string[] = [];
 	for (const l of vis) {
 		if (l.type === "ctx" || l.type === "del") oldSrc.push(l.content);
 		if (l.type === "ctx" || l.type === "add") newSrc.push(l.content);
@@ -569,14 +966,23 @@ async function renderUnified(diff: ParsedDiff, language: BundledLanguage | undef
 		? await Promise.all([hlBlock(oldSrc.join("\n"), language), hlBlock(newSrc.join("\n"), language)])
 		: [oldSrc, newSrc];
 
-	let oI = 0, nI = 0, idx = 0;
+	let oI = 0,
+		nI = 0,
+		idx = 0;
 	const out: string[] = [];
 	out.push(rule(tw));
 
 	/** Emit a single stacked row with compact gutter + left border bar. */
-	function emitRow(num: number | null, sign: string, gutterBg: string, signFg: string, body: string, bodyBg = ""): void {
+	function emitRow(
+		num: number | null,
+		sign: string,
+		gutterBg: string,
+		signFg: string,
+		body: string,
+		bodyBg = "",
+	): void {
 		const borderFg = sign === "-" ? dc.fgDel : sign === "+" ? dc.fgAdd : "";
-		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : `${BG_DEFAULT} `;
+		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : `${BG_BASE} `;
 		const numFg = borderFg || FG_LNUM;
 		const gutter = `${border}${gutterBg}${lnum(num, nw, numFg)}${signFg}${sign}${RST} ${DIVIDER} `;
 		const contGutter = `${border}${gutterBg}${" ".repeat(nw + 1)}${RST} ${DIVIDER} `;
@@ -594,28 +1000,35 @@ async function renderUnified(diff: ParsedDiff, language: BundledLanguage | undef
 			const label = gap && gap > 0 ? ` ${gap} unmodified lines ` : "···";
 			const totalW = Math.min(tw, 72);
 			const pad = Math.max(0, totalW - label.length - 2);
-			const half1 = Math.floor(pad / 2), half2 = pad - half1;
+			const half1 = Math.floor(pad / 2),
+				half2 = pad - half1;
 			out.push(`${FG_DIM}${"─".repeat(half1)}${label}${"─".repeat(half2)}${RST}`);
-			idx++; continue;
+			idx++;
+			continue;
 		}
 
 		// Context line — dimmed, single line number
 		if (l.type === "ctx") {
 			const hl = oldHL[oI] ?? l.content;
-			emitRow(l.newNum, " ", BG_DEFAULT, dc.fgCtx, `${BG_DEFAULT}${DIM}${hl}`, BG_DEFAULT);
-			oI++; nI++; idx++; continue;
+			emitRow(l.newNum, " ", BG_BASE, dc.fgCtx, `${BG_BASE}${DIM}${hl}`, BG_BASE);
+			oI++;
+			nI++;
+			idx++;
+			continue;
 		}
 
 		// Collect del/add blocks
 		const dels: Array<{ l: DiffLine; hl: string }> = [];
 		while (idx < vis.length && vis[idx].type === "del") {
 			dels.push({ l: vis[idx], hl: oldHL[oI] ?? vis[idx].content });
-			oI++; idx++;
+			oI++;
+			idx++;
 		}
 		const adds: Array<{ l: DiffLine; hl: string }> = [];
 		while (idx < vis.length && vis[idx].type === "add") {
 			adds.push({ l: vis[idx], hl: newHL[nI] ?? vis[idx].content });
-			nI++; idx++;
+			nI++;
+			idx++;
 		}
 
 		// 1:1 paired → word diff emphasis
@@ -658,7 +1071,12 @@ async function renderUnified(diff: ParsedDiff, language: BundledLanguage | undef
 // Split view (auto-fallback to unified when narrow)
 // ---------------------------------------------------------------------------
 
-async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefined, max = MAX_PREVIEW_LINES, dc: DiffColors = DEFAULT_DIFF_COLORS): Promise<string> {
+async function renderSplit(
+	diff: ParsedDiff,
+	language: BundledLanguage | undefined,
+	max = MAX_PREVIEW_LINES,
+	dc: DiffColors = DEFAULT_DIFF_COLORS,
+): Promise<string> {
 	const tw = termW();
 	if (!shouldUseSplit(diff, tw, max)) return renderUnified(diff, language, max, dc);
 	if (!diff.lines.length) return "";
@@ -669,23 +1087,35 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 	let i = 0;
 	while (i < diff.lines.length) {
 		const l = diff.lines[i];
-		if (l.type === "sep" || l.type === "ctx") { rows.push({ left: l, right: l }); i++; continue; }
-		const dels: DiffLine[] = [], adds: DiffLine[] = [];
-		while (i < diff.lines.length && diff.lines[i].type === "del") { dels.push(diff.lines[i]); i++; }
-		while (i < diff.lines.length && diff.lines[i].type === "add") { adds.push(diff.lines[i]); i++; }
+		if (l.type === "sep" || l.type === "ctx") {
+			rows.push({ left: l, right: l });
+			i++;
+			continue;
+		}
+		const dels: DiffLine[] = [],
+			adds: DiffLine[] = [];
+		while (i < diff.lines.length && diff.lines[i].type === "del") {
+			dels.push(diff.lines[i]);
+			i++;
+		}
+		while (i < diff.lines.length && diff.lines[i].type === "add") {
+			adds.push(diff.lines[i]);
+			i++;
+		}
 		const n = Math.max(dels.length, adds.length);
 		for (let j = 0; j < n; j++) rows.push({ left: dels[j] ?? null, right: adds[j] ?? null });
 	}
 
 	const vis = rows.slice(0, max);
 	const half = Math.floor((tw - 1) / 2); // -1 for center divider
-	const nw = Math.max(2, String(Math.max(...diff.lines.map(l => l.oldNum ?? l.newNum ?? 0), 0)).length);
+	const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);
 	const gw = nw + 5; // border + num + sign + sp + │ + sp
 	const cw = Math.max(12, half - gw);
 	const canHL = diff.chars <= MAX_HL_CHARS && vis.length * 2 <= MAX_RENDER_LINES * 2;
 
 	// Build separate code blocks per side
-	const leftSrc: string[] = [], rightSrc: string[] = [];
+	const leftSrc: string[] = [],
+		rightSrc: string[] = [];
 	for (const r of vis) {
 		if (r.left && r.left.type !== "sep") leftSrc.push(r.left.content);
 		if (r.right && r.right.type !== "sep") rightSrc.push(r.right.content);
@@ -694,13 +1124,19 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 		? await Promise.all([hlBlock(leftSrc.join("\n"), language), hlBlock(rightSrc.join("\n"), language)])
 		: [leftSrc, rightSrc];
 
-	let lI = 0, rI = 0;
+	let lI = 0,
+		rI = 0;
 	let stripeRow = 0; // tracks row index for diagonal stripe offset
 
 	// Returns { gutter, contGutter, body } for wrapping composition
 	type HalfResult = { gutter: string; contGutter: string; bodyRows: string[] };
 
-	function half_build(line: DiffLine | null, hl: string, ranges: Array<[number, number]> | null, side: "left" | "right"): HalfResult {
+	function half_build(
+		line: DiffLine | null,
+		hl: string,
+		ranges: Array<[number, number]> | null,
+		side: "left" | "right",
+	): HalfResult {
 		// Empty filler — diagonal stripes
 		if (!line) {
 			const gw2 = nw + 2; // number + sign + space before │
@@ -716,16 +1152,17 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 			return { gutter: g, contGutter: g, bodyRows: [`${FG_DIM}${fit(label, cw)}${RST}`] };
 		}
 
-		const isDel = line.type === "del", isAdd = line.type === "add";
-		const gBg = isDel ? BG_GUTTER_DEL : isAdd ? BG_GUTTER_ADD : BG_DEFAULT;
-		const cBg = isDel ? BG_DEL : isAdd ? BG_ADD : BG_DEFAULT;
+		const isDel = line.type === "del",
+			isAdd = line.type === "add";
+		const gBg = isDel ? BG_GUTTER_DEL : isAdd ? BG_GUTTER_ADD : BG_BASE;
+		const cBg = isDel ? BG_DEL : isAdd ? BG_ADD : BG_BASE;
 		const sFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : dc.fgCtx;
 		const sign = isDel ? "-" : isAdd ? "+" : " ";
-		const num = isDel ? line.oldNum : isAdd ? line.newNum : (side === "left" ? line.oldNum : line.newNum);
+		const num = isDel ? line.oldNum : isAdd ? line.newNum : side === "left" ? line.oldNum : line.newNum;
 
 		// Border bar + colored line numbers for changed lines
 		const borderFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : "";
-		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : ` ${BG_DEFAULT}`;
+		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : ` ${BG_BASE}`;
 		const numFg = borderFg || FG_LNUM;
 
 		let body: string;
@@ -734,7 +1171,7 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 		} else if (isDel || isAdd) {
 			body = `${cBg}${hl}`;
 		} else {
-			body = `${BG_DEFAULT}${DIM}${hl}`;
+			body = `${BG_BASE}${DIM}${hl}`;
 		}
 
 		const gutter = `${border}${gBg}${lnum(num, nw, numFg)}${sFg}${BOLD}${sign}${RST} ${FG_RULE}│${RST} `;
@@ -751,7 +1188,8 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 	out.push(`${rule(half)}${FG_RULE}┊${RST}${rule(half)}`);
 
 	for (const r of vis) {
-		const leftLine = r.left, rightLine = r.right;
+		const leftLine = r.left,
+			rightLine = r.right;
 		const paired = leftLine && rightLine && leftLine.type === "del" && rightLine.type === "add";
 		const wd = paired ? wordDiffAnalysis(leftLine.content, rightLine.content) : null;
 
@@ -764,12 +1202,13 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 			rResult = half_build(rightLine, rhl, wd.newRanges, "right");
 		} else if (paired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
 			const pwd = plainWordDiff(leftLine.content, rightLine.content);
-			lI++; rI++;
+			lI++;
+			rI++;
 			lResult = half_build(leftLine, pwd.old, null, "left");
 			rResult = half_build(rightLine, pwd.new, null, "right");
 		} else {
-			const lhl = (leftLine && leftLine.type !== "sep") ? (leftHL[lI++] ?? leftLine?.content ?? "") : "";
-			const rhl = (rightLine && rightLine.type !== "sep") ? (rightHL[rI++] ?? rightLine?.content ?? "") : "";
+			const lhl = leftLine && leftLine.type !== "sep" ? (leftHL[lI++] ?? leftLine?.content ?? "") : "";
+			const rhl = rightLine && rightLine.type !== "sep" ? (rightHL[rI++] ?? rightLine?.content ?? "") : "";
 			lResult = half_build(leftLine, lhl, null, "left");
 			rResult = half_build(rightLine, rhl, null, "right");
 		}
@@ -782,7 +1221,8 @@ async function renderSplit(diff: ParsedDiff, language: BundledLanguage | undefin
 			const lg = row === 0 ? lResult.gutter : lResult.contGutter;
 			const rg = row === 0 ? rResult.gutter : rResult.contGutter;
 			const lb = lResult.bodyRows[row] ?? (leftIsEmpty ? stripes(cw, stripeRow) : `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
-			const rb = rResult.bodyRows[row] ?? (rightIsEmpty ? stripes(cw, stripeRow) : `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
+			const rb =
+				rResult.bodyRows[row] ?? (rightIsEmpty ? stripes(cw, stripeRow) : `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
 			out.push(`${lg}${lb}${DIVIDER}${rg}${rb}`);
 			stripeRow++;
 		}
@@ -807,13 +1247,18 @@ export const __testing = {
 };
 
 export default function diffRendererExtension(pi: any): void {
+	// Apply diff theme palette from settings/presets before rendering
+	applyDiffPalette();
+
 	let createWriteTool: any, createEditTool: any, TextComponent: any;
 	try {
 		const sdk = require("@mariozechner/pi-coding-agent");
 		createWriteTool = sdk.createWriteTool;
 		createEditTool = sdk.createEditTool;
 		TextComponent = require("@mariozechner/pi-tui").Text;
-	} catch { return; }
+	} catch {
+		return;
+	}
 	if (!createWriteTool || !createEditTool || !TextComponent) return;
 
 	const cwd = process.cwd();
@@ -833,7 +1278,11 @@ export default function diffRendererExtension(pi: any): void {
 		async execute(tid: string, params: any, sig: any, upd: any, ctx: any) {
 			const fp = params.path ?? params.file_path ?? "";
 			let old: string | null = null;
-			try { if (fp && existsSync(fp)) old = readFileSync(fp, "utf-8"); } catch { old = null; }
+			try {
+				if (fp && existsSync(fp)) old = readFileSync(fp, "utf-8");
+			} catch {
+				old = null;
+			}
 
 			const result = await origWrite.execute(tid, params, sig, upd, ctx);
 			const content = params.content ?? "";
@@ -873,16 +1322,18 @@ export default function diffRendererExtension(pi: any): void {
 					ctx.state._previewKey = previewKey;
 					ctx.state._previewText = hdr;
 					const lg = lang(fp);
-					hlBlock(args.content, lg).then((lines: string[]) => {
-						if (ctx.state._previewKey !== previewKey) return;
-						const maxShow = ctx.expanded ? lines.length : 16;
-						const preview = lines.slice(0, maxShow).join("\n");
-						const rem = lines.length - maxShow;
-						let out = `${hdr}\n\n${preview}`;
-						if (rem > 0) out += `\n${theme.fg("muted", `… (${rem} more lines, ${lines.length} total)`)}`;
-						ctx.state._previewText = out;
-						ctx.invalidate();
-					}).catch(() => {});
+					hlBlock(args.content, lg)
+						.then((lines: string[]) => {
+							if (ctx.state._previewKey !== previewKey) return;
+							const maxShow = ctx.expanded ? lines.length : 16;
+							const preview = lines.slice(0, maxShow).join("\n");
+							const rem = lines.length - maxShow;
+							let out = `${hdr}\n\n${preview}`;
+							if (rem > 0) out += `\n${theme.fg("muted", `… (${rem} more lines, ${lines.length} total)`)}`;
+							ctx.state._previewText = out;
+							ctx.invalidate();
+						})
+						.catch(() => {});
 				}
 				text.setText(ctx.state._previewText ?? hdr);
 				return text;
@@ -895,7 +1346,11 @@ export default function diffRendererExtension(pi: any): void {
 		renderResult(result: any, _opt: any, theme: any, ctx: any) {
 			const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
 			if (ctx.isError) {
-				const e = result.content?.filter((c: any) => c.type === "text").map((c: any) => c.text || "").join("\n") ?? "Error";
+				const e =
+					result.content
+						?.filter((c: any) => c.type === "text")
+						.map((c: any) => c.text || "")
+						.join("\n") ?? "Error";
 				text.setText(`\n${theme.fg("error", e)}`);
 				return text;
 			}
@@ -907,15 +1362,17 @@ export default function diffRendererExtension(pi: any): void {
 					ctx.state._wdk = key;
 					ctx.state._wdt = `  ${d.summary}\n${theme.fg("muted", "  rendering diff…")}`;
 					const dc = resolveDiffColors(theme);
-					renderSplit(d.diff, d.language, MAX_RENDER_LINES, dc).then((rendered: string) => {
-						if (ctx.state._wdk !== key) return;
-						ctx.state._wdt = `  ${d.summary}\n${rendered}`;
-						ctx.invalidate();
-					}).catch(() => {
-						if (ctx.state._wdk !== key) return;
-						ctx.state._wdt = `  ${d.summary}`;
-						ctx.invalidate();
-					});
+					renderSplit(d.diff, d.language, MAX_RENDER_LINES, dc)
+						.then((rendered: string) => {
+							if (ctx.state._wdk !== key) return;
+							ctx.state._wdt = `  ${d.summary}\n${rendered}`;
+							ctx.invalidate();
+						})
+						.catch(() => {
+							if (ctx.state._wdk !== key) return;
+							ctx.state._wdt = `  ${d.summary}`;
+							ctx.invalidate();
+						});
 				}
 				text.setText(ctx.state._wdt ?? `  ${d.summary}`);
 				return text;
@@ -932,16 +1389,18 @@ export default function diffRendererExtension(pi: any): void {
 					ctx.state._nft = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`;
 					const lg = lang(fp);
 					if (rawContent) {
-						hlBlock(rawContent, lg).then((hlLines: string[]) => {
-							if (ctx.state._nfk !== pk) return;
-							const maxShow = ctx.expanded ? hlLines.length : 12;
-							const preview = hlLines.slice(0, maxShow).join("\n");
-							const rem = hlLines.length - maxShow;
-							let out = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}\n${preview}`;
-							if (rem > 0) out += `\n${theme.fg("muted", `  … ${rem} more lines`)}`;
-							ctx.state._nft = out;
-							ctx.invalidate();
-						}).catch(() => {});
+						hlBlock(rawContent, lg)
+							.then((hlLines: string[]) => {
+								if (ctx.state._nfk !== pk) return;
+								const maxShow = ctx.expanded ? hlLines.length : 12;
+								const preview = hlLines.slice(0, maxShow).join("\n");
+								const rem = hlLines.length - maxShow;
+								let out = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}\n${preview}`;
+								if (rem > 0) out += `\n${theme.fg("muted", `  … ${rem} more lines`)}`;
+								ctx.state._nft = out;
+								ctx.invalidate();
+							})
+							.catch(() => {});
 					}
 				}
 				text.setText(ctx.state._nft ?? `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`);
@@ -977,7 +1436,9 @@ export default function diffRendererExtension(pi: any): void {
 						const idx = f.indexOf(newText);
 						if (idx >= 0) editLine = f.slice(0, idx).split("\n").length;
 					}
-				} catch { editLine = 0; }
+				} catch {
+					editLine = 0;
+				}
 				const diff = parseDiff(oldText, newText);
 				(result as any).details = { _type: "editInfo", summary: summarize(diff.added, diff.removed), editLine };
 			}
@@ -1003,17 +1464,19 @@ export default function diffRendererExtension(pi: any): void {
 				const lg = lang(fp);
 				const diff = parseDiff(oldText, newText);
 				const dc = resolveDiffColors(theme);
-				renderSplit(diff, lg, MAX_PREVIEW_LINES, dc).then((rendered) => {
-					if (ctx.state._pk !== pk) return;
-					ctx.state._pt = `${hdr}\n${summarize(diff.added, diff.removed)}\n${rendered}`;
-					ctx.invalidate();
-				}).catch(() => {
-					if (ctx.state._pk !== pk) return;
-					// Fallback: plain word diff
-					const diff2 = parseDiff(oldText, newText);
-					ctx.state._pt = `${hdr}  ${summarize(diff2.added, diff2.removed)}`;
-					ctx.invalidate();
-				});
+				renderSplit(diff, lg, MAX_PREVIEW_LINES, dc)
+					.then((rendered) => {
+						if (ctx.state._pk !== pk) return;
+						ctx.state._pt = `${hdr}\n${summarize(diff.added, diff.removed)}\n${rendered}`;
+						ctx.invalidate();
+					})
+					.catch(() => {
+						if (ctx.state._pk !== pk) return;
+						// Fallback: plain word diff
+						const diff2 = parseDiff(oldText, newText);
+						ctx.state._pt = `${hdr}  ${summarize(diff2.added, diff2.removed)}`;
+						ctx.invalidate();
+					});
 			}
 
 			text.setText(ctx.state._pt ?? hdr);
@@ -1023,7 +1486,11 @@ export default function diffRendererExtension(pi: any): void {
 		renderResult(result: any, _opt: any, theme: any, ctx: any) {
 			const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
 			if (ctx.isError) {
-				const e = result.content?.filter((c: any) => c.type === "text").map((c: any) => c.text || "").join("\n") ?? "Error";
+				const e =
+					result.content
+						?.filter((c: any) => c.type === "text")
+						.map((c: any) => c.text || "")
+						.join("\n") ?? "Error";
 				text.setText(`\n${theme.fg("error", e)}`);
 				return text;
 			}