pi-claude-code-ui 1.0.89 → 1.0.91

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 > [!IMPORTANT]
 > **1.0.69 — package rename (permanent).** Canonical npm name is now [`pi-claude-code-ui`](https://www.npmjs.com/package/pi-claude-code-ui). `pi-claude-style-tools` is legacy and will not receive further releases. Install with `pi install npm:pi-claude-code-ui` or `npm i pi-claude-code-ui`.
 
+## 1.0.91 — 2026-10-24
+
+### Added
+
+- **Follow the terminal's colors** - `/cc-theme terminal on` (setting `terminalTheme`) switches pi to its built-in `system` theme, which takes every color from the palette Ghostty, Rex, or any other terminal reports, and keeps it on at every start. `/cc-theme terminal off` restores the previous theme. Terminals do not announce switches between two themes of the same kind (dark to dark), so the extension also asks the terminal for its color scheme when its window regains focus, and pi re-reads the palette.
+
+### Fixed
+
+- **Diffs use the theme's colors** - diff code was highlighted with GitHub's palette (`github-dark` / `github-light`) whatever the pi theme, so it never matched Markdown code blocks or the terminal. Diffs now use the theme's `syntax*` colors, and diff rows tint the terminal background toward the theme's own `toolDiffAdded` / `toolDiffRemoved` instead of mixing in fixed green and pink. Needs pi 1.4 or newer; older versions keep the GitHub palettes.
+- **Connectors and outlines follow the theme's tint** - branch connectors were a fixed neutral rgb(72) and box outlines rgb(136) on every theme, which looked heavy on light themes and gray on tinted ones. The default now blends the terminal background toward its text color to the same contrast (2:1 and 5.1:1), so dark terminals look as before. An explicit `/cc-tools branch <0-255>` still sets an exact gray.
+- **Light and dark agree with pi** - light/dark choices (diff palette, chrome) now come from pi's `theme.appearance` instead of a separate brightness guess, so they can no longer disagree with pi's own UI.
+- **Light themes no longer gray out syntax colors** - the contrast fix for bundled Shiki themes replaced every color above a fixed brightness with gray on light themes. It now only applies to the bundled themes.
+- **`diffColors.shikiTheme` is kept on theme switches** - a light/dark switch overwrote it with `github-dark` / `github-light`.
+- **Transparent tool backgrounds on pi 1.4** - pi 1.4 renamed the theme's background table, so `toolBackground` overrides were silently skipped.
+
+## 1.0.90 — 2026-10-19
+
+### Fixed
+
+- **Split diffs wrap long lines again** - with `"diffLayout": "split"` long lines were cut off with `›` after one row (two or three on wide terminals) instead of wrapping, because split columns kept the wrap limit meant for the auto layout. Forced split now wraps each line in full, up to 8 rows. Thanks @nabsiddiqui ([#34](https://github.com/FammasMaz/pi-cc-tools/issues/34)).
+
 ## 1.0.89 — 2026-10-19
 
 ### Fixed

package/README.md

@@ -28,9 +28,9 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 - **Subagent completion notifications** restyled to match the same Claude-style tool rows
 - **RTK rewrite integration** that folds rewrite notices into the bash tool row with a muted `(RTK)` badge and expanded-only rewrite details
 - **Transparent tool backgrounds** in `transparent` or `border` mode
-- **Theme-adaptive palette** — borders, branch connectors, dim text, spinner accent, and diff backgrounds automatically follow the active pi theme (set `themeAdaptive: false` to keep the fixed Claude-style palette)
-- **Light Ghostty-sync themes** — edit/write diffs use `github-light` highlighting and light-tinted diff rows; tool pending dots use softer chrome colors
-- **Transparent edit/write diffs** with universal red/green diff colors
+- **Terminal colors** — `/cc-theme terminal on` makes pi's theme follow the terminal's own palette (Ghostty, Rex, kitty, WezTerm, …), including switches between two dark or two light themes
+- **Theme-adaptive palette** — borders, branch connectors, dim text, spinner accent, diff highlighting, and diff backgrounds automatically follow the active pi theme (set `themeAdaptive: false` to keep the fixed Claude-style palette)
+- **Transparent edit/write diffs** tinted with the theme's own diff colors
 - **Grouped consecutive tool calls** with single-row summaries for repeated targets and per-tool glance rows for mixed work (set `groupToolCalls: false` to disable)
 - **Extra detail toggle** with `Ctrl+Shift+O`, increasing expanded preview caps without making the default view heavy
 - **Global border patch** for all tool rows, including unknown/custom tools
@@ -59,35 +59,53 @@ Set in `.pi/settings.json` or the active Pi agent settings file (`$PI_CODING_AGE
   "diffCollapsedLines": 24,
   "diffLayout": "auto",
   "themeAdaptive": true,
-  "diffTheme": "github-dark"
+  "terminalTheme": false
 }
 ```
 
+Leave `diffTheme` unset to highlight diffs with the theme's colors; set it (for example `"github-dark"`) to force a fixed diff palette.
+
 ### Theme integration
 
 When `themeAdaptive` is `true` (default), the following colors are derived from the active pi theme on every render and re-derived whenever the theme changes:
 
 | Element | Derived from |
 |---------|--------------|
-| User box, tool rules, code fences | `dim` → `muted` → `borderMuted` → `thinkingText` |
-| Branch connectors (`├`, `└`, `│`) | **fixed rgb(72)** by default (theme-independent); `/cc-tools branch theme` to follow pi theme |
+| Branch connectors (`├`, `└`, `│`) | terminal background blended toward its text color to a 2:1 contrast (rgb 72 on a near-black terminal); `/cc-tools branch theme` uses `dim` → `muted` → `borderMuted` instead, `/cc-tools branch <0-255>` an exact gray |
+| User box, tool rules, code fences, thinking rule | the same blend at a 5.1:1 contrast (rgb ~136 on a near-black terminal) |
 | "✻ Turn took Ns" line (final message only, with session total + turn count) | `muted` |
 | Expanded thinking-block text and `∴` marker | `muted` |
 | Diff add/remove accents | `toolDiffAdded` / `toolDiffRemoved` |
-| Diff background tints | mixed against `toolSuccessBg` base |
+| Diff code highlighting | the theme's `syntax*` colors, the same ones pi uses for Markdown code blocks |
+| Diff background tints | the terminal background tinted toward `toolDiffAdded` / `toolDiffRemoved` |
+| Light or dark variants | pi's own decision (`theme.appearance`) |
 | Spinner verb text (`Working…`) | `borderAccent` (fallback: `accent`) |
 | Spinner status text | `muted` |
 
+These need pi 1.4 or newer, which exposes the theme's concrete colors. On older pi versions branch connectors stay rgb 72, diffs use `github-dark` / `github-light`, and diff tints are mixed against `toolSuccessBg`.
+
 User-supplied `diffTheme` presets and `diffColors` overrides always win over theme-derived defaults. File-type icons (e.g. `ts`, `py`, `rs`) keep their language-identity colors and are not theme-derived.
 
 Set `themeAdaptive: false` to keep the original fixed Claude-style palette regardless of the active pi theme.
 
-On `/resume`, `/new`, or `/fork`, tool chrome is rebound from the **current** pi theme (no coupling to Ghostty or other theme extensions). If you use Ghostty sync, listing it **above** this extension in `settings.json` is recommended so `setTheme` runs before chrome rebind.
+On `/resume`, `/new`, or `/fork`, tool chrome is rebound from the **current** pi theme, so it also follows themes set by other extensions.
+
+### Terminal colors (Ghostty, Rex, …)
+
+`/cc-theme terminal on` switches pi to its built-in `system` theme, which builds every pi color from the palette the terminal reports, and keeps it there on every start. The theme you had before is saved as `terminalThemePrevious`; `/cc-theme terminal off` restores it.
+
+Pi already rebuilds the `system` theme when the terminal switches between light and dark. Terminals send no notification when you switch between two themes of the same kind, for example from one dark Rex theme to another, so this extension also asks the terminal for its color scheme whenever the terminal window regains focus (you went to the terminal's settings and came back). Pi then re-reads the palette and repaints only if the colors changed. The query is answered by Ghostty, Rex, and other terminals that support color scheme reports; in regular (non-fullscreen) mode the extension turns on focus reporting itself and keeps the focus events out of the editor.
+
+```text
+/cc-theme terminal on       # follow the terminal's colors
+/cc-theme terminal off      # go back to the previous theme
+/cc-theme terminal status   # show the current state
+```
 
 #### Toggle at runtime with `/cc-theme`
 
 ```text
-/cc-theme           # show current setting + theme name
+/cc-theme           # show current setting + theme name (and whether terminal colors are on)
 /cc-theme status    # show current setting + color preview (incl. spinner)
 /cc-theme on        # follow pi theme
 /cc-theme off       # keep fixed Claude palette

package/config/config.example.json

@@ -17,6 +17,6 @@
   "diffCollapsedLines": 24,
   "showTruncationHints": false,
   "themeAdaptive": true,
-  "diffTheme": "github-dark",
+  "terminalTheme": false,
   "diffColors": {}
 }

package/extensions/index.ts

@@ -71,6 +71,25 @@ import {
 	getLastBashOutputLine,
 } from "./bash-command";
 import { getUserSettingsPath } from "./settings-path";
+import {
+	blendForContrast,
+	mixRgb as mixThemeRgb,
+	rgbBgAnsi,
+	rgbFgAnsi,
+	rgbToHex,
+	shikiThemeFromPiTheme,
+	terminalDefaultColors,
+	themeAppearance,
+	themeTokenRgb,
+	type ShikiThemeRegistration,
+} from "./theme-colors";
+import {
+	activeThemeName,
+	requestTerminalColorScheme,
+	startFocusResync,
+	SYSTEM_THEME_NAME,
+	systemThemeAvailable,
+} from "./terminal-theme";
 
 const RESET = "\x1b[0m";
 const TRANSPARENT_BG = "\x1b[49m";
@@ -137,9 +156,18 @@ interface SettingsFile {
 	 * defaults so users keep full control.
 	 */
 	themeAdaptive?: boolean;
+	/**
+	 * When true, pi uses its built-in `system` theme, which takes every color
+	 * from the terminal's own palette (Ghostty, Rex, ...), and re-reads that
+	 * palette when the terminal regains focus so same-kind theme switches
+	 * (dark to dark) are picked up too. Toggle with `/cc-theme terminal`.
+	 */
+	terminalTheme?: boolean;
+	/** Pi theme that was active before `terminalTheme` was turned on; restored when it is turned off. */
+	terminalThemePrevious?: string;
 	/**
 	 * Theme color key used for the spinner verb (e.g. "Cooking…"). Defaults
-	 * to "accent". Useful when the active theme's accent is overloaded for
+	 * to "borderAccent". Useful when the active theme's accent is overloaded for
 	 * borders, headings, or bash mode and the verb should pop differently.
 	 * Valid keys are any of the pi theme `ThemeColor` names (e.g. accent,
 	 * borderAccent, success, warning, mdHeading, thinkingMedium, bashMode).
@@ -157,9 +185,13 @@ interface SettingsFile {
 	 * renders expanded, like stock pi.
 	 */
 	thinkingMode?: "live" | "full";
-	/** Gray level 0–255 for ├ └ │ when branch color mode is `fixed`. */
+	/** Exact gray level 0–255 for ├ └ │ in `fixed` mode. Unset: a fixed-contrast blend of the terminal background and text. */
 	toolBranchRgbGray?: number;
-	/** `fixed` (default): rgb gray 72, theme-independent. `theme`: dim → muted → borderMuted. */
+	/**
+	 * `fixed` (default): the terminal background blended toward its text color
+	 * to a fixed 2:1 contrast (rgb 72 on a #161616 terminal), or exactly
+	 * `toolBranchRgbGray` when set. `theme`: the theme's dim → muted → borderMuted color.
+	 */
 	toolBranchColorMode?: "theme" | "fixed";
 }
 
@@ -233,7 +265,10 @@ function syncToolBackgroundMode(): void {
 
 function setThemeBg(theme: unknown, key: string, value: string): void {
 	const themeAny = theme as any;
-	if (themeAny.bgColors instanceof Map) {
+	// pi >= 1.4 keeps background escapes in `bgAnsi`; older versions in `bgColors`.
+	if (themeAny.bgAnsi instanceof Map) {
+		themeAny.bgAnsi.set(key, value);
+	} else if (themeAny.bgColors instanceof Map) {
 		themeAny.bgColors.set(key, value);
 	} else if (themeAny.bgColors && typeof themeAny.bgColors === "object") {
 		themeAny.bgColors[key] = value;
@@ -4203,8 +4238,11 @@ function currentThemePaletteFingerprint(): string | undefined {
 
 /** Resolved-color fingerprint so palette re-derives when the active theme file changes under the same name/object. */
 function themePaletteFingerprint(theme: any): string {
-	const keys = ["success", "error", "borderMuted", "accent", "muted", "toolDiffAdded", "toolDiffRemoved"] as const;
-	return keys.map((k) => safeFgAnsi(theme, k) ?? "").join("\u001f");
+	const keys = ["success", "error", "borderMuted", "accent", "muted", "toolDiffAdded", "toolDiffRemoved", "syntaxKeyword", "syntaxString"] as const;
+	// Tokens set to "" follow the terminal's default colors, which can change under the same theme.
+	const defaults = terminalDefaultColors(theme);
+	const terminal = defaults ? `${rgbToHex(defaults.background)}${rgbToHex(defaults.foreground)}` : "";
+	return [...keys.map((k) => safeFgAnsi(theme, k) ?? ""), themeAppearance(theme) ?? "", terminal].join("\u001f");
 }
 
 function invalidateThemePaletteCache(): void {
@@ -4218,7 +4256,67 @@ function themeAdaptiveEnabled(): boolean {
 	return settings.themeAdaptive !== false;
 }
 
-let DIFF_THEME: BundledTheme = (process.env.DIFF_THEME as BundledTheme | undefined) ?? "github-dark";
+// ---------------------------------------------------------------------------
+// terminalTheme: pi follows the terminal's own palette (Ghostty, Rex, ...).
+// ---------------------------------------------------------------------------
+
+function terminalThemeEnabled(): boolean {
+	return readSettings().terminalTheme === true;
+}
+
+/** Pi's saved `theme` setting (may be a "light/dark" pair), from pi's own settings file. */
+function readPiThemeSetting(): string | undefined {
+	const agentDir = process.env.PI_CODING_AGENT_DIR || `${process.env.HOME ?? ""}/.pi/agent`;
+	try {
+		const raw = JSON.parse(readFileSync(`${agentDir}/settings.json`, "utf8"));
+		return typeof raw?.theme === "string" && raw.theme ? raw.theme : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Switch pi to its terminal-palette theme and keep it in sync. Returns false if unavailable. */
+function applyTerminalTheme(ctx: any, options: { announce: boolean }): boolean {
+	if (!ctx?.hasUI) return false;
+	if (!systemThemeAvailable(ctx.ui)) {
+		ctx.ui.notify("Terminal colors need pi's built-in `system` theme (pi 1.4 or newer).", "error");
+		return false;
+	}
+	const current = activeThemeName(ctx.ui);
+	if (current !== SYSTEM_THEME_NAME) {
+		// Remember what to go back to; a "light/dark" pair is kept as the pair.
+		const previous = readPiThemeSetting() ?? current;
+		if (previous && previous !== SYSTEM_THEME_NAME) writeSettingsKey("terminalThemePrevious", previous);
+		const result = ctx.ui.setTheme(SYSTEM_THEME_NAME);
+		if (!result?.success) {
+			ctx.ui.notify(`Could not switch to the terminal theme: ${result?.error ?? "unknown error"}`, "error");
+			return false;
+		}
+		if (options.announce) {
+			ctx.ui.notify(`Theme follows the terminal's colors (was "${previous ?? current}"). /cc-theme terminal off to switch back.`, "info");
+		}
+	}
+	startFocusResync(ctx.ui, terminalThemeEnabled);
+	return true;
+}
+
+/** Turn terminalTheme off and restore the theme that was active before it. */
+function restorePreviousTheme(ctx: any): string | undefined {
+	const previous = readSettings().terminalThemePrevious;
+	writeSettingsKey("terminalThemePrevious", undefined);
+	if (!ctx?.hasUI || !previous || activeThemeName(ctx.ui) !== SYSTEM_THEME_NAME) return undefined;
+	let name = previous;
+	if (previous.includes("/")) {
+		// ctx.ui.setTheme takes one theme name; pick the pair member for the current appearance.
+		const [light, dark] = previous.split("/");
+		name = themeAppearance(ctx.ui.theme) === "light" ? light : dark;
+	}
+	const result = ctx.ui.setTheme(name);
+	return result?.success ? name : undefined;
+}
+
+/** Shiki theme for diff previews: a bundled theme name, or one generated from the pi theme. */
+let DIFF_THEME: BundledTheme | ShikiThemeRegistration = (process.env.DIFF_THEME as BundledTheme | undefined) ?? "github-dark";
 /** True when the active pi theme has a light panel background (edit/write diff chrome). */
 let _diffOnLightBg = false;
 let codeToAnsiLoader: Promise<any> | null = null;
@@ -4238,6 +4336,7 @@ const WORD_DIFF_MIN_SIM = 0.15;
 const MAX_WRAP_ROWS_WIDE = 3;
 const MAX_WRAP_ROWS_MED = 2;
 const MAX_WRAP_ROWS_NARROW = 1;
+const FORCED_SPLIT_WRAP_ROWS = 8;
 
 let D_RST = "\x1b[0m";
 const D_BOLD = "\x1b[1m";
@@ -4259,8 +4358,40 @@ let FG_DEL = "\x1b[38;2;200;100;100m";
 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";
-// Tool branch connectors (├ └ │). Default fixed gray 72 — independent of pi theme.
+// Tool branch connectors (├ └ │). The default ("fixed" mode without an explicit gray) blends the
+// terminal's background toward its text color until it has the contrast rgb 72 has on a #161616
+// terminal (2.0:1), so connectors keep that weight on light and tinted themes and take on the
+// theme's tint. Outline chrome (user box, code fences, thinking rule) does the same at the
+// contrast of rgb 136 (5.1:1). Gray 72 / +64 is the fallback when pi does not expose concrete
+// theme colors (pi < 1.4) or themeAdaptive is off.
 const DEFAULT_TOOL_BRANCH_GRAY = 72;
+const BRANCH_CHROME_CONTRAST = 2.0;
+const OUTLINE_CHROME_CONTRAST = 5.1;
+
+// Branch connectors resolve their color on every rendered row, so keep the solved blends.
+const _chromeBlendCache = new Map<string, string>();
+
+/** Terminal background blended toward its text color to `contrast`, or null without concrete colors. */
+function themeChromeBlend(theme: any, contrast: number): string | null {
+	if (!theme || !themeAdaptiveEnabled()) return null;
+	const defaults = terminalDefaultColors(theme);
+	if (!defaults) return null;
+	const { background: bg, foreground: fg } = defaults;
+	const mode = typeof theme.getColorMode === "function" ? theme.getColorMode() : "";
+	const key = `${contrast}|${bg.r},${bg.g},${bg.b}|${fg.r},${fg.g},${fg.b}|${mode}`;
+	let ansi = _chromeBlendCache.get(key);
+	if (!ansi) {
+		if (_chromeBlendCache.size > 32) _chromeBlendCache.clear();
+		ansi = rgbFgAnsi(theme, blendForContrast(bg, fg, contrast));
+		_chromeBlendCache.set(key, ansi);
+	}
+	return ansi;
+}
+
+function hasExplicitToolBranchGray(): boolean {
+	const raw = readSettings().toolBranchRgbGray;
+	return typeof raw === "number" && Number.isFinite(raw);
+}
 
 function toolBranchRgbAnsi(gray: number): string {
 	const g = Math.max(0, Math.min(255, Math.round(gray)));
@@ -4274,11 +4405,17 @@ function ansiRgbBrightenedBy(ansi: string, delta: number): string | null {
 	return `\x1b[38;2;${bump(rgb.r)};${bump(rgb.g)};${bump(rgb.b)}m`;
 }
 
-/** Outline chrome always brighter than branch; never falls back to identical branch ANSI. */
+/** Outline chrome always stands out more than the branch; never falls back to identical branch ANSI. */
 function outlineChromeAnsiFromBranch(theme?: any): string {
 	const t = theme ?? _toolBranchThemeHint;
+	if (toolBranchColorModeFixed() && !hasExplicitToolBranchGray()) {
+		const blend = themeChromeBlend(t, OUTLINE_CHROME_CONTRAST);
+		if (blend) return blend;
+	}
 	const branch = currentToolBranchAnsi(t);
-	const fromBranch = ansiRgbBrightenedBy(branch, OUTLINE_CHROME_BRIGHTEN);
+	// Toward the text color: brighter on dark themes, darker on light ones.
+	const towardText = t && isLightThemeBackground(t) ? -OUTLINE_CHROME_BRIGHTEN : OUTLINE_CHROME_BRIGHTEN;
+	const fromBranch = ansiRgbBrightenedBy(branch, towardText);
 	if (fromBranch) return fromBranch;
 	let gray = DEFAULT_TOOL_BRANCH_GRAY;
 	if (toolBranchColorModeFixed()) {
@@ -4301,8 +4438,8 @@ function toolBranchColorModeFixed(): boolean {
 }
 
 function toolBranchRenderCacheKey(): string {
-	if (toolBranchColorModeFixed()) return `fixed:${getConfiguredToolBranchGray()}`;
-	return `theme:${stripAnsi(TOOL_RULE)}`;
+	// The escape itself, not stripAnsi(TOOL_RULE) (which is always ""), so a new color is a new key.
+	return `${toolBranchColorModeFixed() ? "fixed" : "theme"}:${TOOL_RULE}`;
 }
 
 let _toolBranchVisualEpoch = 0;
@@ -4342,6 +4479,10 @@ let _toolBranchThemeHint: any;
 function currentToolBranchAnsi(theme?: any): string {
 	const t = theme ?? _toolBranchThemeHint;
 	if (toolBranchColorModeFixed()) {
+		if (!hasExplicitToolBranchGray()) {
+			const blend = themeChromeBlend(t, BRANCH_CHROME_CONTRAST);
+			if (blend) return blend;
+		}
 		return toolBranchRgbAnsi(getConfiguredToolBranchGray());
 	}
 	const chrome = t ? resolveThemeChromeFg(t) : null;
@@ -4491,6 +4632,10 @@ const FALLBACK_BASE_BG_DARK = { r: 32, g: 35, b: 42 };
 const FALLBACK_BASE_BG_LIGHT = { r: 232, g: 233, b: 236 };
 
 function isLightThemeBackground(theme: any): boolean {
+	// pi >= 1.4 decides light/dark itself (from the terminal's colors for the system theme);
+	// use the same answer so diffs, chrome, and pi's own UI never disagree.
+	const appearance = themeAppearance(theme);
+	if (appearance) return appearance === "light";
 	const panel =
 		themeBgRgb(theme, "toolSuccessBg") ||
 		themeBgRgb(theme, "userMessageBg") ||
@@ -4510,10 +4655,18 @@ function isLightThemeBackground(theme: any): boolean {
 function syncDiffShikiTheme(theme: any): void {
 	if (process.env.DIFF_THEME) return;
 	const config = loadDiffConfig();
-	if (config.diffTheme) return;
+	if (config.diffTheme || config.diffColors?.shikiTheme) return;
 	_diffOnLightBg = isLightThemeBackground(theme);
-	DIFF_THEME = (_diffOnLightBg ? "github-light" : "github-dark") as BundledTheme;
-	clearHighlightCache();
+	// Highlight diffs with the theme's own syntax colors (the ones pi uses for Markdown code
+	// blocks). GitHub's palette is the fallback for pi versions without concrete theme colors.
+	const fromTheme = themeAdaptiveEnabled() ? shikiThemeFromPiTheme(theme) : null;
+	const next = fromTheme ?? ((_diffOnLightBg ? "github-light" : "github-dark") as BundledTheme);
+	if (diffThemeName(next) !== diffThemeName(DIFF_THEME)) clearHighlightCache();
+	DIFF_THEME = next;
+}
+
+function diffThemeName(theme: BundledTheme | ShikiThemeRegistration): string {
+	return typeof theme === "string" ? theme : theme.name;
 }
 const UNIVERSAL_DIFF_ADD_FG = { r: 110, g: 210, b: 130 };
 const UNIVERSAL_DIFF_DEL_FG = { r: 225, g: 110, b: 110 };
@@ -4534,17 +4687,65 @@ function rgbToBgAnsi(c: { r: number; g: number; b: number }): string {
 	return `\x1b[48;2;${Math.round(c.r)};${Math.round(c.g)};${Math.round(c.b)}m`;
 }
 
+// Diff row tints: how far each background moves from the surface toward the theme's diff color.
+// Light themes need less, because the same share of a mid-tone color reads stronger on white.
+const DIFF_TINT = {
+	dark: { line: { add: 0.2, del: 0.17 }, word: { add: 0.36, del: 0.32 }, gutter: { add: 0.12, del: 0.1 } },
+	light: { line: { add: 0.16, del: 0.13 }, word: { add: 0.3, del: 0.26 }, gutter: { add: 0.1, del: 0.08 } },
+} as const;
+
+/** The color a diff row is drawn on: the terminal background, or pi's tool panel in `default` tool style. */
+function diffSurfaceRgb(theme: any): Rgb | null {
+	if (toolBackgroundMode === "default") {
+		const panel = themeTokenRgb(theme, "toolSuccessBg");
+		if (panel) return panel;
+	}
+	return terminalDefaultColors(theme)?.background ?? null;
+}
+
+/**
+ * Diff colors straight from the theme: text in `toolDiffAdded` / `toolDiffRemoved`, and
+ * backgrounds that tint the row's real surface toward those same colors. Returns false on pi
+ * versions without concrete theme colors.
+ */
+function deriveDiffPaletteFromThemeColors(theme: any): boolean {
+	const add = themeTokenRgb(theme, "toolDiffAdded");
+	const del = themeTokenRgb(theme, "toolDiffRemoved");
+	const surface = diffSurfaceRgb(theme);
+	if (!add || !del || !surface) return false;
+	const tint = DIFF_TINT[isLightThemeBackground(theme) ? "light" : "dark"];
+	const bg = (color: Rgb, amount: number) => rgbBgAnsi(theme, mixThemeRgb(surface, color, amount));
+	FG_ADD = rgbFgAnsi(theme, add);
+	FG_DEL = rgbFgAnsi(theme, del);
+	BG_ADD = bg(add, tint.line.add);
+	BG_DEL = bg(del, tint.line.del);
+	BG_ADD_W = bg(add, tint.word.add);
+	BG_DEL_W = bg(del, tint.word.del);
+	BG_GUTTER_ADD = bg(add, tint.gutter.add);
+	BG_GUTTER_DEL = bg(del, tint.gutter.del);
+	return true;
+}
+
 function autoDeriveBgFromTheme(theme: any): void {
 	// Diff palette derivation.
 	//
 	// `toolDiffAdded` / `toolDiffRemoved` from the active pi theme give us the
-	// fg accents. The base background is taken from `toolSuccessBg` (close to
-	// the panel color the row will sit on) so the tinted backgrounds blend in
-	// instead of forcing a hardcoded dark hue. Falls back to the universal
-	// dark palette when the theme is unavailable or themeAdaptive=false.
+	// fg accents. On pi >= 1.4 the backgrounds tint the row's real surface toward
+	// those colors (deriveDiffPaletteFromThemeColors). Older pi versions only
+	// expose ANSI escapes, so the base is taken from `toolSuccessBg` and mixed
+	// with fixed tint targets. Falls back to the universal dark palette when the
+	// theme is unavailable or themeAdaptive=false.
 	const useTheme = themeAdaptiveEnabled() && theme;
 	const onLight = useTheme && isLightThemeBackground(theme);
 	_diffOnLightBg = !!onLight;
+	if (useTheme && deriveDiffPaletteFromThemeColors(theme)) {
+		BG_EMPTY = TRANSPARENT_BG;
+		BG_BASE = TRANSPARENT_BG;
+		D_RST = TRANSPARENT_RESET;
+		DIVIDER = `${FG_RULE}│${D_RST}`;
+		DEFAULT_DIFF_COLORS = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
+		return;
+	}
 	const addFgRgb = (useTheme && themeFgRgb(theme, "toolDiffAdded")) || UNIVERSAL_DIFF_ADD_FG;
 	const delFgRgb = (useTheme && themeFgRgb(theme, "toolDiffRemoved")) || UNIVERSAL_DIFF_DEL_FG;
 	const base =
@@ -4633,7 +4834,12 @@ function applyThemePaletteIfNeeded(theme: any): void {
 	}
 	const paletteChanged =
 		_themePaletteCacheName !== themeName || _themePaletteCacheFingerprint !== fingerprint;
-	if (paletteChanged) bumpToolBranchVisualEpoch();
+	if (paletteChanged) {
+		bumpToolBranchVisualEpoch();
+		// A new theme object (e.g. the system theme rebuilt after a terminal theme change)
+		// comes with pi's own tool backgrounds; re-apply the configured tool style to it.
+		applyToolBackgroundMode(theme);
+	}
 	_themePaletteCacheTheme = theme;
 	_themePaletteCacheName = themeName;
 	_themePaletteCacheFingerprint = fingerprint;
@@ -5102,7 +5308,7 @@ function lang(filePath: string): BundledLanguage | undefined {
 	return EXT_LANG[extname(filePath).slice(1).toLowerCase()];
 }
 
-async function codeToAnsiLazy(code: string, language: BundledLanguage, theme: BundledTheme): Promise<string> {
+async function codeToAnsiLazy(code: string, language: BundledLanguage, theme: BundledTheme | ShikiThemeRegistration): Promise<string> {
 	if (!codeToAnsiLoader) {
 		// Self-healing: a failed import (missing dep, transient error) must not leave a
 		// permanently-rejected promise that later becomes an unhandled rejection. Reset
@@ -5139,11 +5345,15 @@ function touchCache(key: string, value: string[]): string[] {
 async function hlBlock(code: string, language: BundledLanguage | undefined): Promise<string[]> {
 	if (!code) return [""];
 	if (!language || code.length > MAX_HL_CHARS) return code.split("\n");
-	const key = `${DIFF_THEME}\0${language}\0${code}`;
+	const diffTheme = DIFF_THEME;
+	const key = `${diffThemeName(diffTheme)}\0${language}\0${code}`;
 	const hit = hlCache.get(key);
 	if (hit) return touchCache(key, hit);
 	try {
-		const ansi = normalizeShikiContrast(await codeToAnsiLazy(code, language, DIFF_THEME));
+		const raw = await codeToAnsiLazy(code, language, diffTheme as any);
+		// Themes generated from pi already meet pi's contrast rules for this background;
+		// only bundled themes need their too-dark / too-light colors muted.
+		const ansi = typeof diffTheme === "string" ? normalizeShikiContrast(raw) : raw;
 		const out = (ansi.endsWith("\n") ? ansi.slice(0, -1) : ansi).split("\n");
 		return touchCache(key, out);
 	} catch {
@@ -5416,6 +5626,13 @@ async function renderSplit(
 	const nw = Math.max(2, String(maxLineNumber(diff.lines)).length);
 	const gw = nw + 5;
 	const cw = Math.max(12, half - gw);
+	// Auto only picks split when lines fit, so the usual wrap cap rarely bites. A forced
+	// split ("diffLayout": "split") halves the code width for every diff, and that cap
+	// (one row below 120 columns) cut long lines off instead of wrapping them. Wrap
+	// forced-split lines in full, with a cap only against minified one-liners.
+	const splitWrapRows = diffLayout() === "split"
+		? Math.max(adaptiveWrapRows(), FORCED_SPLIT_WRAP_ROWS)
+		: adaptiveWrapRows();
 	const canHL = diff.chars <= MAX_HL_CHARS && vis.length * 2 <= MAX_RENDER_LINES * 2;
 
 	const leftSrc: string[] = [];
@@ -5465,7 +5682,7 @@ async function renderSplit(
 		else body = `${BG_BASE}${D_DIM}${hl}`;
 		const gutter = `${border}${gBg}${lnum(num, nw, numFg)}${sFg}${D_BOLD}${sign} ${D_RST}${FG_RULE}│${D_RST} `;
 		const contGutter = `${border}${gBg}${" ".repeat(nw + 2)}${D_RST}${FG_RULE}│${D_RST} `;
-		return { gutter, contGutter, bodyRows: wrapAnsi(tabs(body), cw, adaptiveWrapRows(), cBg) };
+		return { gutter, contGutter, bodyRows: wrapAnsi(tabs(body), cw, splitWrapRows, cBg) };
 	}
 
 	const out: string[] = [];
@@ -7078,9 +7295,11 @@ export default function (pi: ExtensionAPI) {
 		const chromeHint = branchMode === "theme" && theme
 			? (resolveThemeChromeFg(theme) ? " (attenuated on light themes)" : " (fallback gray if theme keys missing)")
 			: "";
-		const branchLine = branchMode === "fixed"
-			? `Branch color: fixed rgb(${branchGray})`
-			: `Branch color: theme${chromeHint}`;
+		const branchLine = branchMode === "theme"
+			? `Branch color: theme${chromeHint}`
+			: hasExplicitToolBranchGray() || !themeChromeBlend(theme, BRANCH_CHROME_CONTRAST)
+				? `Branch color: fixed rgb(${branchGray})`
+				: "Branch color: fixed 2:1 contrast on the terminal background (rgb 72 on near-black)";
 		ctx.ui.notify([
 			`Tool style: ${toolBackgroundMode}`,
 			`Tool grouping: ${toolGroupingEnabled() ? "on" : "off"}`,
@@ -7170,7 +7389,7 @@ export default function (pi: ExtensionAPI) {
 					writeSettingsKey("toolBranchRgbGray", undefined);
 					writeSettingsKey("toolBranchColorMode", undefined);
 					if (ctx.hasUI) refreshAllToolBranchVisuals(ctx);
-					if (ctx.hasUI) ctx.ui.notify(`Branch color → fixed rgb(${DEFAULT_TOOL_BRANCH_GRAY}) (default)`, "info");
+					if (ctx.hasUI) ctx.ui.notify("Branch color → default (fixed contrast on the terminal background)", "info");
 					return;
 				}
 				if (arg === "theme") {
@@ -7182,7 +7401,9 @@ export default function (pi: ExtensionAPI) {
 				if (arg === "fixed") {
 					writeSettingsKey("toolBranchColorMode", "fixed");
 					if (ctx.hasUI) refreshAllToolBranchVisuals(ctx);
-					if (ctx.hasUI) ctx.ui.notify(`Branch color → fixed rgb(${getConfiguredToolBranchGray()})`, "info");
+					if (ctx.hasUI) ctx.ui.notify(hasExplicitToolBranchGray()
+						? `Branch color → fixed rgb(${getConfiguredToolBranchGray()})`
+						: "Branch color → fixed contrast on the terminal background", "info");
 					return;
 				}
 				const gray = Number.parseInt(arg, 10);
@@ -7247,11 +7468,66 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	// /cc-theme command — toggle pi-theme-adaptive coloring at runtime.
-	const THEME_MODES = ["on", "off", "toggle", "status"] as const;
+	// /cc-theme command — toggle pi-theme-adaptive coloring at runtime, and
+	// /cc-theme terminal — make pi's theme follow the terminal's palette.
+	const THEME_MODES = ["on", "off", "toggle", "status", "terminal"] as const;
+	const TERMINAL_MODES = ["on", "off", "toggle", "status"] as const;
+	const handleTerminalTheme = (arg: string, ctx: any): void => {
+		const current = terminalThemeEnabled();
+		if (!arg || arg === "status") {
+			if (!ctx.hasUI) return;
+			const name = activeThemeName(ctx.ui) ?? "unknown";
+			const previous = readSettings().terminalThemePrevious;
+			ctx.ui.notify([
+				`Terminal colors: ${current ? "on" : "off"} (pi theme "${name}")`,
+				current && previous ? `  /cc-theme terminal off restores "${previous}"` : "",
+				current && name !== SYSTEM_THEME_NAME ? "  pi is not using the system theme right now; /cc-theme terminal on switches it back" : "",
+			].filter(Boolean).join("\n"), "info");
+			return;
+		}
+		let next: boolean;
+		if (arg === "on") next = true;
+		else if (arg === "off") next = false;
+		else if (arg === "toggle") next = !current;
+		else {
+			if (ctx.hasUI) ctx.ui.notify(`Usage: /cc-theme terminal ${TERMINAL_MODES.join("|")}`, "error");
+			return;
+		}
+		if (next) {
+			writeSettingsKey("terminalTheme", true);
+			if (!applyTerminalTheme(ctx, { announce: false })) {
+				writeSettingsKey("terminalTheme", undefined);
+				return;
+			}
+			requestTerminalColorScheme();
+			if (ctx.hasUI) ctx.ui.notify("Terminal colors: on — pi's theme now follows the terminal (Ghostty, Rex, ...)", "info");
+		} else {
+			writeSettingsKey("terminalTheme", undefined);
+			const restored = restorePreviousTheme(ctx);
+			if (ctx.hasUI) {
+				ctx.ui.notify(restored
+					? `Terminal colors: off — restored theme "${restored}"`
+					: "Terminal colors: off — pick a theme with /settings", "info");
+			}
+		}
+	};
 	pi.registerCommand("cc-theme", {
-		description: "Toggle whether tool borders / branch rules / diff colors follow the active pi theme",
+		description: "Follow the terminal's colors (terminal on|off), or toggle whether tool chrome / diff colors follow the pi theme",
 		getArgumentCompletions(prefix) {
+			if (prefix.startsWith("terminal ")) {
+				const second = prefix.slice("terminal ".length);
+				return TERMINAL_MODES
+					.filter((m) => m.startsWith(second))
+					.map((m) => ({
+						value: `terminal ${m}`,
+						label: m,
+						description:
+							m === "on" ? "Use pi's system theme, built from the terminal's palette, and re-read it on focus"
+							: m === "off" ? "Go back to the theme you had before"
+							: m === "toggle" ? "Flip between on and off"
+							: "Show whether pi follows the terminal's colors",
+					}));
+			}
 			return THEME_MODES
 				.filter((m) => m.startsWith(prefix))
 				.map((m) => ({
@@ -7261,11 +7537,16 @@ export default function (pi: ExtensionAPI) {
 						m === "on" ? "Derive borders, branch rules, dim text and diff tints from the active pi theme (default)"
 						: m === "off" ? "Keep the fixed Claude-style palette regardless of theme"
 						: m === "toggle" ? "Flip between on and off"
+						: m === "terminal" ? "Make pi's theme follow the terminal's colors (Ghostty, Rex, ...)"
 						: "Show the current setting and a preview of the derived colors",
 				}));
 		},
 		async handler(args, ctx) {
 			const raw = args.trim().toLowerCase();
+			if (raw === "terminal" || raw.startsWith("terminal ")) {
+				handleTerminalTheme(raw.slice("terminal".length).trim(), ctx);
+				return;
+			}
 			const current = themeAdaptiveEnabled();
 
 			if (!raw || raw === "status") {
@@ -7273,6 +7554,7 @@ export default function (pi: ExtensionAPI) {
 				const theme = ctx.ui.theme as any;
 				const themeName = theme?.name ?? "unknown";
 				const state = current ? "on" : "off";
+				const terminalLine = `terminal colors: ${terminalThemeEnabled() ? "on" : "off"} (/cc-theme terminal on|off)`;
 				if (raw === "status" && current) {
 					const settings = readSettings();
 					const verbKey = settings.spinnerVerbColor || "borderAccent";
@@ -7290,9 +7572,9 @@ export default function (pi: ExtensionAPI) {
 						`spinner verb: ${verbAnsi ? `${verbAnsi}Cooking…\x1b[39m` : "(unchanged)"} (key: ${verbKey})`,
 						`spinner stat: ${statusAnsi ? `${statusAnsi}(thinking · ↓ 10 tokens · 2s)\x1b[39m` : "(unchanged)"} (key: ${statusKey})`,
 					].join("\n  ");
-					ctx.ui.notify(`Theme adaptive: ${state} (theme "${themeName}")\n  ${preview}`, "info");
+					ctx.ui.notify(`Theme adaptive: ${state} (theme "${themeName}")\n  ${terminalLine}\n  ${preview}`, "info");
 				} else {
-					ctx.ui.notify(`Theme adaptive: ${state} (theme "${themeName}")`, "info");
+					ctx.ui.notify(`Theme adaptive: ${state} (theme "${themeName}")\n  ${terminalLine}`, "info");
 				}
 				return;
 			}
@@ -7426,6 +7708,8 @@ export default function (pi: ExtensionAPI) {
 		clearRtkRewriteState();
 		if (!ctx.hasUI) return;
 		patchUiNotifications(ctx.ui);
+		// terminalTheme: switch to (and stay on) the theme built from the terminal's palette.
+		if (terminalThemeEnabled()) applyTerminalTheme(ctx, { announce: true });
 		// Session switch (/resume, /new) can leave tool chrome from the previous
 		// theme; rebind from ctx.ui.theme (other extensions may setTheme in the
 		// same tick — deferred passes pick up the final theme without coupling).

package/extensions/terminal-theme.ts

@@ -0,0 +1,132 @@
+// Follow the terminal's own colors (Ghostty, Rex, kitty, WezTerm, ...).
+//
+// Pi's built-in `system` theme already builds every color from the palette the
+// terminal reports (OSC 4/10/11) and rebuilds it when the terminal announces a
+// light/dark switch (DEC mode 2031). Terminals announce nothing when you switch
+// between two themes of the same kind, for example from one dark Rex theme to
+// another. So whenever the terminal regains focus (you went to its settings and
+// came back) we ask it for its color scheme (DSR 996). Pi's own handler treats
+// the reply like a light/dark report and re-reads the palette, and it only
+// re-renders when the colors actually changed.
+
+const FOCUS_IN = "\x1b[I";
+const FOCUS_OUT = "\x1b[O";
+const ENABLE_FOCUS_REPORTING = "\x1b[?1004h";
+const DISABLE_FOCUS_REPORTING = "\x1b[?1004l";
+const REQUEST_COLOR_SCHEME = "\x1b[?996n";
+const MIN_REQUEST_INTERVAL_MS = 250;
+
+export const SYSTEM_THEME_NAME = "system";
+
+export interface TerminalIo {
+	/** Raw terminal input. Defaults to process.stdin. */
+	input: { on(event: "data", listener: (chunk: unknown) => void): unknown };
+	/** Writes escape sequences to the terminal. Defaults to process.stdout when it is a TTY. */
+	write(data: string): void;
+}
+
+interface FocusResyncState {
+	io?: TerminalIo;
+	stdinListener?: (chunk: unknown) => void;
+	unsubscribeInput?: () => void;
+	exitHook?: () => void;
+	lastRequestAt: number;
+	isEnabled: () => boolean;
+}
+
+// Kept on globalThis so /reload (which re-evaluates this module) replaces the
+// previous listeners instead of stacking them.
+const STATE_KEY = Symbol.for("pi-claude-style-tools:terminal-theme-focus");
+
+function state(): FocusResyncState {
+	const g = globalThis as any;
+	if (!g[STATE_KEY]) g[STATE_KEY] = { lastRequestAt: 0, isEnabled: () => false } satisfies FocusResyncState;
+	return g[STATE_KEY] as FocusResyncState;
+}
+
+const processIo: TerminalIo = {
+	input: process.stdin,
+	write(data: string): void {
+		try {
+			if (process.stdout.isTTY) process.stdout.write(data);
+		} catch { /* terminal gone */ }
+	},
+};
+
+function write(data: string): void {
+	(state().io ?? processIo).write(data);
+}
+
+/** Ask the terminal to report its light/dark scheme; pi re-reads the palette on the reply. */
+export function requestTerminalColorScheme(): void {
+	const s = state();
+	const now = Date.now();
+	if (now - s.lastRequestAt < MIN_REQUEST_INTERVAL_MS) return;
+	s.lastRequestAt = now;
+	write(REQUEST_COLOR_SCHEME);
+}
+
+/**
+ * Re-read the terminal palette whenever the terminal regains focus.
+ *
+ * Fullscreen pi already turns on focus reporting and consumes the focus events
+ * before extensions see them, so focus-in is detected by watching stdin
+ * directly (without consuming anything). In regular mode we turn focus
+ * reporting on ourselves and consume the events so they never reach the editor.
+ */
+export function startFocusResync(ui: any, isEnabled: () => boolean, io: TerminalIo = processIo): void {
+	const s = state();
+	s.isEnabled = isEnabled;
+	if (s.io && s.io !== io) {
+		// A different terminal (tests): start over instead of mixing listeners.
+		s.stdinListener = undefined;
+		s.exitHook = undefined;
+	}
+	s.io = io;
+
+	if (!s.stdinListener) {
+		s.stdinListener = (chunk: unknown) => {
+			const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("latin1") : "";
+			if (text.includes(FOCUS_IN) && state().isEnabled()) requestTerminalColorScheme();
+		};
+		io.input.on("data", s.stdinListener);
+	}
+
+	// Pi drops extension input listeners on /reload and session replacement; re-register each time.
+	s.unsubscribeInput?.();
+	s.unsubscribeInput = undefined;
+	if (typeof ui?.onTerminalInput === "function") {
+		try {
+			s.unsubscribeInput = ui.onTerminalInput((data: string) =>
+				data === FOCUS_IN || data === FOCUS_OUT ? { consume: true } : undefined,
+			);
+		} catch { /* not interactive */ }
+	}
+
+	write(ENABLE_FOCUS_REPORTING);
+	if (!s.exitHook && io === processIo) {
+		s.exitHook = () => write(DISABLE_FOCUS_REPORTING);
+		process.once("exit", s.exitHook);
+	}
+}
+
+/** Theme name pi currently uses ("system" when it follows the terminal). */
+export function activeThemeName(ui: any): string | undefined {
+	try {
+		const name = ui?.theme?.name;
+		return typeof name === "string" ? name : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** True when this pi version has the built-in terminal-palette theme. */
+export function systemThemeAvailable(ui: any): boolean {
+	try {
+		if (activeThemeName(ui) === SYSTEM_THEME_NAME) return true;
+		const themes = ui?.getAllThemes?.();
+		return Array.isArray(themes) && themes.some((t: any) => t?.name === SYSTEM_THEME_NAME);
+	} catch {
+		return false;
+	}
+}

package/extensions/theme-colors.ts

@@ -0,0 +1,242 @@
+// Concrete colors from the active pi theme, and a Shiki theme built from them.
+//
+// Pi >= 1.4 exposes `theme.appearance` ("dark" | "light") and `theme.colors`
+// (concrete colors for every token, with tokens set to "" filled from the
+// terminal's reported default colors). Older pi versions only expose ANSI
+// escapes, so every helper here returns null when that API is missing and the
+// callers fall back to parsing `getFgAnsi()` / `getBgAnsi()`.
+
+import * as PiTui from "@earendil-works/pi-tui";
+
+export type Rgb = { r: number; g: number; b: number };
+
+export function rgbToHex({ r, g, b }: Rgb): string {
+	const h = (n: number) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+	return `#${h(r)}${h(g)}${h(b)}`;
+}
+
+/** Linear sRGB mix: `amount` 0 returns `a`, 1 returns `b`. */
+export function mixRgb(a: Rgb, b: Rgb, amount: number): Rgb {
+	return {
+		r: a.r + (b.r - a.r) * amount,
+		g: a.g + (b.g - a.g) * amount,
+		b: a.b + (b.b - a.b) * amount,
+	};
+}
+
+function relativeLuminance({ r, g, b }: Rgb): number {
+	const lin = (c: number) => {
+		const v = c / 255;
+		return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+	};
+	return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+
+/** WCAG contrast ratio, 1-21. */
+export function contrastRatio(a: Rgb, b: Rgb): number {
+	const la = relativeLuminance(a);
+	const lb = relativeLuminance(b);
+	return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+
+/**
+ * The color between `background` and `foreground` that has `ratio` contrast
+ * against the background, so chrome keeps the same visual weight on dark,
+ * light, and low-contrast themes. Returns the foreground if it cannot reach it.
+ */
+export function blendForContrast(background: Rgb, foreground: Rgb, ratio: number): Rgb {
+	if (contrastRatio(background, foreground) <= ratio) return foreground;
+	let lo = 0;
+	let hi = 1;
+	for (let i = 0; i < 18; i++) {
+		const mid = (lo + hi) / 2;
+		if (contrastRatio(background, mixRgb(background, foreground, mid)) < ratio) lo = mid;
+		else hi = mid;
+	}
+	return mixRgb(background, foreground, hi);
+}
+
+/** Pi Color value ({ kind: "rgb" | "oklch" | "indexed", ... }) to RGB. */
+function colorValueToRgb(color: any): Rgb | null {
+	if (!color || typeof color !== "object") return null;
+	const toRgb = (PiTui as any).colorToRgb;
+	if (typeof toRgb === "function") {
+		try {
+			const rgb = toRgb(color);
+			if (rgb && Number.isFinite(rgb.r)) return { r: rgb.r, g: rgb.g, b: rgb.b };
+		} catch { /* fall through */ }
+	}
+	if (color.kind === "rgb" && Number.isFinite(color.r)) return { r: color.r, g: color.g, b: color.b };
+	return null;
+}
+
+/** Concrete RGB for a theme token, or null on pi versions without `theme.colors`. */
+export function themeTokenRgb(theme: any, token: string): Rgb | null {
+	try {
+		return colorValueToRgb(theme?.colors?.[token]);
+	} catch {
+		return null;
+	}
+}
+
+/** "light" / "dark" as pi decides it, or undefined on pi versions without `theme.appearance`. */
+export function themeAppearance(theme: any): "light" | "dark" | undefined {
+	try {
+		const appearance = theme?.appearance;
+		return appearance === "light" || appearance === "dark" ? appearance : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+// A copy of the active theme with every token set to "" (terminal default).
+// Pi fills those from the terminal's reported default colors, which is the
+// only public way to read the terminal background. Built from the active
+// theme's own class so it reads the same module state as pi.
+const probeCache = new WeakMap<object, any>();
+
+function terminalDefaultsProbe(theme: any): any | null {
+	try {
+		const fg = theme?.fgAnsi;
+		const bg = theme?.bgAnsi;
+		const Ctor = theme?.constructor;
+		if (!(fg instanceof Map) || !(bg instanceof Map) || typeof Ctor !== "function") return null;
+		const key = fg as object;
+		let probe = probeCache.get(key);
+		if (!probe) {
+			const blank = (map: Map<string, unknown>) => Object.fromEntries([...map.keys()].map((k) => [k, ""]));
+			const mode = typeof theme.getColorMode === "function" ? theme.getColorMode() : "truecolor";
+			probe = new Ctor(blank(fg), blank(bg), mode, { appearance: themeAppearance(theme) });
+			probeCache.set(key, probe);
+		}
+		return probe;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The terminal's default background and foreground as pi knows them (reported
+ * by the terminal, or pi's guess for the theme's appearance). Null on pi
+ * versions without `theme.colors`.
+ */
+export function terminalDefaultColors(theme: any): { background: Rgb; foreground: Rgb } | null {
+	const probe = terminalDefaultsProbe(theme);
+	if (!probe) return null;
+	const background = themeTokenRgb(probe, "userMessageBg");
+	const foreground = themeTokenRgb(probe, "text");
+	return background && foreground ? { background, foreground } : null;
+}
+
+/** ANSI foreground escape for an RGB color in the theme's color mode (truecolor or 256). */
+export function rgbFgAnsi(theme: any, c: Rgb): string {
+	const mode = typeof theme?.getColorMode === "function" ? theme.getColorMode() : "truecolor";
+	const fgAnsi = (PiTui as any).foregroundAnsi;
+	const rgbColor = (PiTui as any).rgbColor;
+	if (mode !== "truecolor" && typeof fgAnsi === "function" && typeof rgbColor === "function") {
+		try {
+			return fgAnsi(rgbColor(Math.round(c.r), Math.round(c.g), Math.round(c.b)), mode);
+		} catch { /* fall through */ }
+	}
+	return `\x1b[38;2;${Math.round(c.r)};${Math.round(c.g)};${Math.round(c.b)}m`;
+}
+
+/** ANSI background escape for an RGB color in the theme's color mode (truecolor or 256). */
+export function rgbBgAnsi(theme: any, c: Rgb): string {
+	const mode = typeof theme?.getColorMode === "function" ? theme.getColorMode() : "truecolor";
+	const bgAnsi = (PiTui as any).backgroundAnsi;
+	const rgbColor = (PiTui as any).rgbColor;
+	if (mode !== "truecolor" && typeof bgAnsi === "function" && typeof rgbColor === "function") {
+		try {
+			return bgAnsi(rgbColor(Math.round(c.r), Math.round(c.g), Math.round(c.b)), mode);
+		} catch { /* fall through */ }
+	}
+	return `\x1b[48;2;${Math.round(c.r)};${Math.round(c.g)};${Math.round(c.b)}m`;
+}
+
+// ---------------------------------------------------------------------------
+// Shiki theme from the pi theme's syntax colors, so diff previews highlight
+// code the same way pi highlights Markdown code blocks. The scope mapping
+// mirrors pi's own highlight.js mapping (keyword, type, number, string,
+// comment, function, variable, operator, punctuation).
+// ---------------------------------------------------------------------------
+
+export interface ShikiThemeRegistration {
+	name: string;
+	type: "dark" | "light";
+	fg: string;
+	bg: string;
+	settings: Array<{ scope?: string[]; settings: { foreground?: string; background?: string; fontStyle?: string } }>;
+}
+
+const SHIKI_SCOPES: Array<[token: string, scopes: string[], fontStyle?: string]> = [
+	["syntaxComment", ["comment", "punctuation.definition.comment", "string.comment"]],
+	["syntaxKeyword", [
+		"keyword", "storage", "storage.type", "storage.modifier", "keyword.control",
+		"variable.language", "entity.name.tag", "support.type.property-name.json",
+	]],
+	["syntaxOperator", ["keyword.operator", "keyword.operator.assignment", "keyword.operator.arithmetic", "keyword.operator.logical", "keyword.operator.comparison"]],
+	["syntaxPunctuation", ["punctuation", "meta.brace", "meta.delimiter", "punctuation.definition.tag", "punctuation.separator", "punctuation.terminator"]],
+	["syntaxString", ["string", "string.quoted", "string.template", "string.regexp"]],
+	["syntaxNumber", ["constant.numeric", "constant.language", "constant.character", "constant.other", "support.constant"]],
+	["syntaxFunction", ["entity.name.function", "support.function", "meta.function-call.generic", "variable.function"]],
+	["syntaxType", [
+		"entity.name.type", "entity.name.class", "entity.name.namespace", "entity.other.inherited-class",
+		"support.type", "support.class", "storage.type.primitive", "storage.type.built-in",
+	]],
+	["syntaxVariable", ["variable.parameter", "entity.other.attribute-name", "meta.object-literal.key"]],
+	["mdHeading", ["markup.heading", "entity.name.section"], "bold"],
+	["mdLink", ["markup.underline.link", "string.other.link"]],
+	["mdCode", ["markup.inline.raw", "markup.inline.raw.string", "markup.fenced_code", "markup.raw"]],
+	["mdListBullet", ["punctuation.definition.list"]],
+	["toolDiffAdded", ["markup.inserted"]],
+	["toolDiffRemoved", ["markup.deleted"]],
+];
+
+let shikiCache: { key: string; theme: ShikiThemeRegistration } | null = null;
+
+/** Shiki theme from the active pi theme, or null when concrete colors are unavailable. */
+export function shikiThemeFromPiTheme(theme: any): ShikiThemeRegistration | null {
+	const defaults = terminalDefaultColors(theme);
+	const text = themeTokenRgb(theme, "text") ?? defaults?.foreground ?? null;
+	const appearance = themeAppearance(theme);
+	if (!text || !appearance) return null;
+	const background = defaults?.background ?? (appearance === "light" ? { r: 255, g: 255, b: 255 } : { r: 0, g: 0, b: 0 });
+
+	const entries: Array<[string, string]> = [];
+	for (const [token] of SHIKI_SCOPES) {
+		const rgb = themeTokenRgb(theme, token);
+		if (rgb) entries.push([token, rgbToHex(rgb)]);
+	}
+	if (entries.length === 0) return null;
+	const colors = Object.fromEntries(entries) as Record<string, string>;
+	const fg = rgbToHex(text);
+	const bg = rgbToHex(background);
+	const key = `${appearance}|${fg}|${bg}|${entries.map(([k, v]) => `${k}=${v}`).join(",")}`;
+	if (shikiCache?.key === key) return shikiCache.theme;
+
+	let hash = 2166136261;
+	for (let i = 0; i < key.length; i++) {
+		hash ^= key.charCodeAt(i);
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	const settings: ShikiThemeRegistration["settings"] = [{ settings: { foreground: fg, background: bg } }];
+	for (const [token, scopes, fontStyle] of SHIKI_SCOPES) {
+		const color = colors[token];
+		if (!color) continue;
+		settings.push({ scope: scopes, settings: fontStyle ? { foreground: color, fontStyle } : { foreground: color } });
+	}
+	settings.push({ scope: ["markup.bold"], settings: { fontStyle: "bold" } });
+	settings.push({ scope: ["markup.italic"], settings: { fontStyle: "italic" } });
+
+	const registration: ShikiThemeRegistration = {
+		// Shiki caches themes by name, so the name changes with the colors.
+		name: `pi-theme-${hash.toString(16).padStart(8, "0")}`,
+		type: appearance,
+		fg,
+		bg,
+		settings,
+	};
+	shikiCache = { key, theme: registration };
+	return registration;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-code-ui",
-  "version": "1.0.89",
+  "version": "1.0.91",
   "description": "Claude Code-style grouped tool rows for pi with Ctrl+O/Ctrl+Shift+O previews, math rendering, and consistent built-in, MCP, and custom tool rendering",
   "keywords": [
     "pi-package",
@@ -32,6 +32,8 @@
     "extensions/spinner.ts",
     "extensions/settings-path.ts",
     "extensions/bash-command.ts",
+    "extensions/theme-colors.ts",
+    "extensions/terminal-theme.ts",
     "config/config.example.json",
     "README.md",
     "CHANGELOG.md"