pi-claude-code-ui 1.0.90 → 1.0.92

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 > [!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.92 — 2026-10-24
+
+### Changed
+
+- **Terminal colors are on by default** - on pi 1.4 or newer, pi now follows the terminal's palette (Ghostty, Rex, ...) without `/cc-theme terminal on`. The first start switches to pi's `system` theme, saves the theme you had as `terminalThemePrevious`, and says so; `/cc-theme terminal off` (or `"terminalTheme": false`) restores that theme and keeps it. `pi --use-theme <name>` still wins for that run, and older pi versions are left alone.
+- **Branch connectors have one rule and no settings** - `├ └ │` are always a faint mark at a fixed 2:1 contrast against the terminal background, which keeps them visible on dark, light, and tinted themes. The `/cc-tools branch` command and the `toolBranchColorMode` / `toolBranchRgbGray` settings are removed; existing values are ignored. On pi before 1.4 the contrast is taken against black or white (rgb 72 on dark themes, as before).
+
+## 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

package/README.md

@@ -28,9 +28,10 @@ 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** (default, pi 1.4+) — pi's theme follows the terminal's own palette (Ghostty, Rex, kitty, WezTerm, …), including switches between two dark or two light themes; `/cc-theme terminal off` keeps a theme of your choice
+- **Theme-adaptive palette** — 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)
+- **Faint branch connectors** — `├ └ │` keep the same faint contrast on every terminal background, dark or light
+- **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 +60,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": true
 }
 ```
 
+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 |
 | "✻ 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 diffs use `github-dark` / `github-light`, and diff tints are mixed against `toolSuccessBg`.
+
+Branch connectors (`├`, `└`, `│`) and outlines (user box, tool rules, code fences, thinking rule) are neutral marks with nothing to configure. They blend the terminal's background toward its text color until they reach a fixed contrast: 2:1 for connectors (rgb 72 on a near-black terminal) and 5.1:1 for outlines (rgb ~136), so connectors stay faint but visible on dark, light, and tinted themes alike. On pi versions before 1.4, which don't report the terminal's colors, the same contrasts are taken against black or white.
+
 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, …)
+
+On by default: at startup the extension 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` (or `"terminalTheme": false`) restores it and keeps it. `pi --use-theme <name>` still picks the theme for that run, and on pi versions without the `system` theme (before 1.4) nothing changes.
+
+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 and keep it
+/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": true,
   "diffColors": {}
 }

package/extensions/index.ts

@@ -71,18 +71,35 @@ 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";
 const TRANSPARENT_RESET = `${RESET}${TRANSPARENT_BG}`;
 
-// User/code box borders and thinking/thought text: branch color + OUTLINE_CHROME_BRIGHTEN.
-// Branch ├└│ stay at `currentToolBranchAnsi` (see syncOutlineChromeFromBranch).
+// User/code box borders and thinking/thought text use the outline chrome color, branch
+// connectors ├└│ the fainter branch color (see chromeAnsi / syncOutlineChromeFromBranch).
 let BORDER_COLOR = "\x1b[38;5;238m";
 let CODE_BLOCK_LANG_FG = "\x1b[38;2;95;95;95m";
 const CHROME_ITALIC = "\x1b[3m";
-/** Lift outline chrome above branch connectors so boxes and thought read brighter. */
-const OUTLINE_CHROME_BRIGHTEN = 64;
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
 const ANSI_PRESENT_RE = /\x1b\[[0-9;]*m/;
 const PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-container-render");
@@ -137,9 +154,19 @@ interface SettingsFile {
 	 * defaults so users keep full control.
 	 */
 	themeAdaptive?: boolean;
+	/**
+	 * On by default (pi >= 1.4): 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. Set to false, or run
+	 * `/cc-theme terminal off`, to keep the theme chosen in pi's /settings.
+	 */
+	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,10 +184,6 @@ interface SettingsFile {
 	 * renders expanded, like stock pi.
 	 */
 	thinkingMode?: "live" | "full";
-	/** Gray level 0–255 for ├ └ │ when branch color mode is `fixed`. */
-	toolBranchRgbGray?: number;
-	/** `fixed` (default): rgb gray 72, theme-independent. `theme`: dim → muted → borderMuted. */
-	toolBranchColorMode?: "theme" | "fixed";
 }
 
 let _settingsCache: { value: SettingsFile; timestamp: number } | null = null;
@@ -233,7 +256,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;
@@ -1580,7 +1606,7 @@ const TOOL_EXECUTION_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-tool
 
 // Rendered-output cache for assistant/user/custom message components.
 // Keyed by (width, branch visual epoch, tool background mode). The epoch changes on
-// theme / /cc-tools branch / /cc-theme rebinds; the mode is included because subagent
+// theme and /cc-theme rebinds; the mode is included because subagent
 // (custom-message) framing follows `toolBackgroundMode` via frameToolLikeLines. This avoids
 // re-running the per-line ANSI stripping (applyTerminalCopyZones, normalizeLeadingCheckGlyph,
 // border boxing) on every scroll/expand re-render — the dominant CPU cost on long chats,
@@ -4203,8 +4229,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 +4247,85 @@ 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, ...).
+// ---------------------------------------------------------------------------
+
+/** On by default; `terminalTheme: false` (or `/cc-theme terminal off`) turns it off. */
+function terminalThemeEnabled(): boolean {
+	return readSettings().terminalTheme !== false;
+}
+
+/** `pi --use-theme <name>` picks the theme for this run. */
+function themeChosenOnCommandLine(): boolean {
+	return process.argv.some((arg) => arg === "--use-theme" || arg.startsWith("--use-theme="));
+}
+
+/** 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.
+ * `reportUnavailable` is off for the default-on startup path, so older pi versions stay quiet.
+ */
+function applyTerminalTheme(ctx: any, options: { announce: boolean; reportUnavailable: boolean }): boolean {
+	if (!ctx?.hasUI) return false;
+	if (!systemThemeAvailable(ctx.ui)) {
+		if (options.reportUnavailable) {
+			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) {
+			// Pi renders a resumed session's transcript right after session_start; post the
+			// notice on the next tick so it lands below that history instead of above it.
+			const message = `Theme follows the terminal's colors (was "${previous ?? current}"). /cc-theme terminal off switches back and keeps it.`;
+			unrefTimer(setTimeout(() => {
+				try {
+					ctx.ui.notify(message, "info");
+				} catch { /* session replaced in the meantime */ }
+			}, 0));
+		}
+	}
+	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;
@@ -4260,50 +4367,53 @@ 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.
-const DEFAULT_TOOL_BRANCH_GRAY = 72;
+// Branch connectors (├ └ │) and outline chrome (user box, code fences, thinking rule) are neutral
+// marks drawn at a fixed contrast against the terminal background: the background blended toward
+// the terminal's text color until it reaches 2:1 for connectors (rgb 72 on a #161616 terminal) and
+// 5.1:1 for outlines (rgb ~136). That keeps connectors faint but visible on dark, light, and tinted
+// themes alike, with nothing to configure. When pi does not report the terminal's colors (pi < 1.4),
+// the same contrasts are taken against plain black or white, per the theme's appearance.
+type ChromeKind = "branch" | "outline";
+const CHROME_CONTRAST: Record<ChromeKind, number> = { branch: 2.0, outline: 5.1 };
+const DARK_FALLBACK_GRAY: Record<ChromeKind, number> = { branch: 72, outline: 136 };
+const WHITE_RGB = { r: 255, g: 255, b: 255 };
+const BLACK_RGB = { r: 0, g: 0, b: 0 };
 
 function toolBranchRgbAnsi(gray: number): string {
 	const g = Math.max(0, Math.min(255, Math.round(gray)));
 	return `\x1b[38;2;${g};${g};${g}m`;
 }
 
-function ansiRgbBrightenedBy(ansi: string, delta: number): string | null {
-	const rgb = parseAnsiRgb(ansi);
-	if (!rgb) return null;
-	const bump = (c: number) => Math.max(0, Math.min(255, Math.round(c + delta)));
-	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. */
-function outlineChromeAnsiFromBranch(theme?: any): string {
-	const t = theme ?? _toolBranchThemeHint;
-	const branch = currentToolBranchAnsi(t);
-	const fromBranch = ansiRgbBrightenedBy(branch, OUTLINE_CHROME_BRIGHTEN);
-	if (fromBranch) return fromBranch;
-	let gray = DEFAULT_TOOL_BRANCH_GRAY;
-	if (toolBranchColorModeFixed()) {
-		gray = getConfiguredToolBranchGray();
-	} else if (t) {
-		const hint = safeFgAnsi(t, "dim") ?? safeFgAnsi(t, "muted") ?? safeFgAnsi(t, "borderMuted");
-		const rgb = hint ? parseAnsiRgb(hint) : null;
-		if (rgb) gray = Math.round((rgb.r + rgb.g + rgb.b) / 3);
-	}
-	return toolBranchRgbAnsi(Math.min(255, gray + OUTLINE_CHROME_BRIGHTEN));
-}
-
-function getConfiguredToolBranchGray(): number {
-	const raw = readSettings().toolBranchRgbGray;
-	return typeof raw === "number" && Number.isFinite(raw) ? Math.max(0, Math.min(255, Math.round(raw))) : DEFAULT_TOOL_BRANCH_GRAY;
-}
-
-function toolBranchColorModeFixed(): boolean {
-	return readSettings().toolBranchColorMode !== "theme";
+// Connectors resolve their color on every rendered row, so keep the solved blends.
+const _chromeAnsiCache = new Map<string, string>();
+
+/** Chrome color for `kind` on the current terminal background. */
+function chromeAnsi(theme: any, kind: ChromeKind): string {
+	const defaults = theme ? terminalDefaultColors(theme) : null;
+	const light = !defaults && !!theme && isLightThemeBackground(theme);
+	const mode = typeof theme?.getColorMode === "function" ? theme.getColorMode() : "truecolor";
+	const key = defaults
+		? `${kind}|${rgbToHex(defaults.background)}|${rgbToHex(defaults.foreground)}|${mode}`
+		: `${kind}|${light ? "light" : "dark"}|${mode}`;
+	let ansi = _chromeAnsiCache.get(key);
+	if (!ansi) {
+		const contrast = CHROME_CONTRAST[kind];
+		const gray = DARK_FALLBACK_GRAY[kind];
+		const rgb = defaults
+			? blendForContrast(defaults.background, defaults.foreground, contrast)
+			: light
+				? blendForContrast(WHITE_RGB, BLACK_RGB, contrast)
+				: { r: gray, g: gray, b: gray };
+		if (_chromeAnsiCache.size > 32) _chromeAnsiCache.clear();
+		ansi = rgbFgAnsi(theme, rgb);
+		_chromeAnsiCache.set(key, ansi);
+	}
+	return ansi;
 }
 
 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 TOOL_RULE;
 }
 
 let _toolBranchVisualEpoch = 0;
@@ -4312,47 +4422,17 @@ function bumpToolBranchVisualEpoch(): void {
 	_toolBranchVisualEpoch++;
 }
 
-/** On light panels, theme dim/muted can be nearly white — pull chrome toward mid-gray. */
-function attenuateChromeAnsi(ansi: string, theme: any): string {
-	const rgb = parseAnsiRgb(ansi);
-	if (!rgb) return ansi;
-	if (!isLightThemeBackground(theme)) return ansi;
-	const lum = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
-	// Already quiet enough on light backgrounds.
-	if (lum <= 145) return ansi;
-	const target = 118;
-	const t = Math.min(1, (lum - 130) / 110);
-	const mix = (c: number) => Math.round(c + (target - c) * t);
-	return `\x1b[38;2;${mix(rgb.r)};${mix(rgb.g)};${mix(rgb.b)}m`;
-}
-
-/** Shared outline chrome: user box, tool rules, code fences, branch connectors. */
-function resolveThemeChromeFg(theme: any): string | null {
-	if (!theme || !themeAdaptiveEnabled()) return null;
-	const dim = safeFgAnsi(theme, "dim");
-	const muted = safeFgAnsi(theme, "muted");
-	const borderMuted = safeFgAnsi(theme, "borderMuted");
-	const thinking = safeFgAnsi(theme, "thinkingText");
-	const raw = dim ?? muted ?? borderMuted ?? thinking;
-	return raw ? attenuateChromeAnsi(raw, theme) : null;
-}
-
-/** Resolve ├ └ │ color from settings + theme on every use (not a stale global). */
+/** Last theme seen, for call sites that draw connectors without a theme at hand. */
 let _toolBranchThemeHint: any;
 
+/** ├ └ │ color for the current terminal background (resolved on every use, not a stale global). */
 function currentToolBranchAnsi(theme?: any): string {
-	const t = theme ?? _toolBranchThemeHint;
-	if (toolBranchColorModeFixed()) {
-		return toolBranchRgbAnsi(getConfiguredToolBranchGray());
-	}
-	const chrome = t ? resolveThemeChromeFg(t) : null;
-	if (chrome) return chrome;
-	return toolBranchRgbAnsi(getConfiguredToolBranchGray());
+	return chromeAnsi(theme ?? _toolBranchThemeHint, "branch");
 }
 
-/** User box, code fences, thinking/thought: branch + OUTLINE_CHROME_BRIGHTEN (never same as branch). */
+/** User box, code fences, thinking/thought: the outline chrome color (stronger than connectors). */
 function syncOutlineChromeFromBranch(theme?: any): void {
-	const outline = outlineChromeAnsiFromBranch(theme);
+	const outline = chromeAnsi(theme ?? _toolBranchThemeHint, "outline");
 	const prevBorder = BORDER_COLOR;
 	BORDER_COLOR = outline;
 	WORKED_LINE_FG = outline;
@@ -4416,7 +4496,7 @@ function refreshAllToolBranchVisuals(ctx: any): void {
 	invalidateThemePaletteCache();
 	applyToolBackgroundMode(ctx?.ui?.theme);
 	applyToolBranchColor(ctx?.ui?.theme);
-	bumpToolBranchVisualEpoch(); // always bust ToolText + container caches after /cc-tools branch
+	bumpToolBranchVisualEpoch(); // always bust ToolText + container caches
 	// Tool rows recompute branch markup on next render (liveBranchDisplay + cache bust).
 	if (ctx?.hasUI) {
 		try {
@@ -4457,7 +4537,7 @@ function scheduleDeferredChromeRebind(ctx: any, delayMs = 0): void {
 	unrefTimer(timer);
 }
 
-let TOOL_RULE = toolBranchRgbAnsi(DEFAULT_TOOL_BRANCH_GRAY);
+let TOOL_RULE = toolBranchRgbAnsi(DARK_FALLBACK_GRAY.branch);
 let FG_SAFE_MUTED = "\x1b[38;2;139;148;158m";
 let FG_STRIPE = "\x1b[38;2;40;40;40m";
 
@@ -4492,6 +4572,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") ||
@@ -4511,10 +4595,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 };
@@ -4535,17 +4627,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 =
@@ -4581,7 +4721,7 @@ const _claudeStyleDefaults = {
 	BORDER_COLOR: "\x1b[38;5;238m",
 	WORKED_LINE_FG: "\x1b[38;2;140;140;140m",
 	CODE_BLOCK_LANG_FG: "\x1b[38;2;95;95;95m",
-	TOOL_RULE: toolBranchRgbAnsi(DEFAULT_TOOL_BRANCH_GRAY),
+	TOOL_RULE: toolBranchRgbAnsi(DARK_FALLBACK_GRAY.branch),
 	FG_DIM: "\x1b[38;2;80;80;80m",
 	FG_LNUM: "\x1b[38;2;100;100;100m",
 	FG_RULE: "\x1b[38;2;50;50;50m",
@@ -4634,7 +4774,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;
@@ -5103,7 +5248,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
@@ -5140,11 +5285,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 {
@@ -7069,7 +7218,7 @@ export default function (pi: ExtensionAPI) {
 	// /cc-tools command — control tool chrome, grouping, and detail level.
 	const TOOL_MODES = ["outlines", "transparent", "default"] as const;
 	const TOOL_BOOL_MODES = ["on", "off", "toggle", "status"] as const;
-	const TOOL_SUBCOMMANDS = [...TOOL_MODES, "group", "detail", "thinking", "branch", "status"] as const;
+	const TOOL_SUBCOMMANDS = [...TOOL_MODES, "group", "detail", "thinking", "status"] as const;
 	const booleanMode = (raw: string | undefined, current: boolean): boolean | "status" | undefined => {
 		const mode = raw || "toggle";
 		if (mode === "on") return true;
@@ -7080,22 +7229,11 @@ export default function (pi: ExtensionAPI) {
 	};
 	const notifyToolStatus = (ctx: any): void => {
 		if (!ctx.hasUI) return;
-		const branchMode = toolBranchColorModeFixed() ? "fixed" : "theme";
-		const branchGray = getConfiguredToolBranchGray();
-		const theme = ctx.ui?.theme;
-		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}`;
 		ctx.ui.notify([
 			`Tool style: ${toolBackgroundMode}`,
 			`Tool grouping: ${toolGroupingEnabled() ? "on" : "off"}`,
 			`Thinking: ${getThinkingMode()}`,
 			`Extra detail: ${extraToolOutputExpanded ? "on" : "off"} (${rawKeyHint("ctrl+shift+o", "toggle")})`,
-			branchLine,
-			`  /cc-tools branch <0-255> | theme | fixed | reset`,
 		].join("\n"), "info");
 	};
 	pi.registerCommand("cc-tools", {
@@ -7113,20 +7251,12 @@ export default function (pi: ExtensionAPI) {
 							m === "group" ? "Toggle grouped adjacent/concurrent tool rows"
 							: m === "thinking" ? "Thinking display: live (default) or full"
 							: m === "detail" ? "Toggle Ctrl+Shift+O extra-detail mode"
-							: m === "branch" ? "├ └ │ gray (0-255), theme, fixed, or reset"
 							: m === "status" ? "Show tool UI settings"
 							: m === "outlines" ? "Horizontal rules around each tool (default)"
 							: m === "transparent" ? "No borders or backgrounds"
 							: "Pi built-in tool backgrounds",
 					}));
 			}
-			if (first === "branch") {
-				const second = parts[1] ?? "";
-				const opts = ["theme", "fixed", "reset", "status"];
-				return opts
-					.filter((o) => o.startsWith(second))
-					.map((o) => ({ value: `branch ${o}`, label: o, description: "Branch connector color" }));
-			}
 			if (first === "thinking") {
 				const second = parts[1] ?? "";
 				return ["live", "full", "status"]
@@ -7168,42 +7298,6 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			if (sub === "branch") {
-				const arg = parts[1] ?? "status";
-				if (arg === "status" || !arg) {
-					notifyToolStatus(ctx);
-					return;
-				}
-				if (arg === "reset") {
-					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");
-					return;
-				}
-				if (arg === "theme") {
-					writeSettingsKey("toolBranchColorMode", "theme");
-					if (ctx.hasUI) refreshAllToolBranchVisuals(ctx);
-					if (ctx.hasUI) ctx.ui.notify("Branch color → follow pi theme (dim/muted)", "info");
-					return;
-				}
-				if (arg === "fixed") {
-					writeSettingsKey("toolBranchColorMode", "fixed");
-					if (ctx.hasUI) refreshAllToolBranchVisuals(ctx);
-					if (ctx.hasUI) ctx.ui.notify(`Branch color → fixed rgb(${getConfiguredToolBranchGray()})`, "info");
-					return;
-				}
-				const gray = Number.parseInt(arg, 10);
-				if (!Number.isFinite(gray) || gray < 0 || gray > 255) {
-					if (ctx.hasUI) ctx.ui.notify("Usage: /cc-tools branch <0-255> | theme | fixed | reset", "error");
-					return;
-				}
-				writeSettingsKey("toolBranchRgbGray", gray);
-				writeSettingsKey("toolBranchColorMode", "fixed");
-				if (ctx.hasUI) refreshAllToolBranchVisuals(ctx);
-				if (ctx.hasUI) ctx.ui.notify(`Branch color → fixed rgb(${gray})`, "info");
-				return;
-			}
 
 			if (sub === "thinking") {
 				const arg = (parts[1] ?? "status").toLowerCase();
@@ -7255,11 +7349,69 @@ 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;
+			const isDefault = readSettings().terminalTheme === undefined;
+			ctx.ui.notify([
+				`Terminal colors: ${current ? "on" : "off"}${isDefault ? " (default)" : ""} (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) {
+			const prior = readSettings().terminalTheme;
+			writeSettingsKey("terminalTheme", true);
+			if (!applyTerminalTheme(ctx, { announce: false, reportUnavailable: true })) {
+				writeSettingsKey("terminalTheme", prior);
+				return;
+			}
+			requestTerminalColorScheme();
+			if (ctx.hasUI) ctx.ui.notify("Terminal colors: on — pi's theme now follows the terminal (Ghostty, Rex, ...)", "info");
+		} else {
+			// Explicit false: unset means on (the default).
+			writeSettingsKey("terminalTheme", false);
+			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) => ({
@@ -7269,11 +7421,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") {
@@ -7281,26 +7438,26 @@ 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";
 					const statusKey = settings.spinnerStatusColor || "muted";
 					const verbAnsi = safeFgAnsi(theme, verbKey) ?? safeFgAnsi(theme, "accent");
 					const statusAnsi = safeFgAnsi(theme, statusKey) ?? safeFgAnsi(theme, "muted");
-					const chromePreview = resolveThemeChromeFg(theme);
 					// Print a short preview of what we derived.
 					const preview = [
-						`chrome      : ${chromePreview ? `${chromePreview}─┌ User ├─\x1b[39m` : "(unchanged)"}`,
-						`  (user box, tool rules, branches)`, 
+						`outlines    : ${chromeAnsi(theme, "outline")}╭─ User ──\x1b[39m (user box, code fences)`,
+						`connectors  : ${chromeAnsi(theme, "branch")}├ └ │\x1b[39m (faint, fixed contrast on the terminal background)`,
 						`muted text  : ${safeFgAnsi(theme, "muted") ? `${safeFgAnsi(theme, "muted")}example dim text\x1b[39m` : "(unchanged)"}`,
 						`diff add    : ${safeFgAnsi(theme, "toolDiffAdded") ? `${safeFgAnsi(theme, "toolDiffAdded")}+ added line\x1b[39m` : "(unchanged)"}`,
 						`diff del    : ${safeFgAnsi(theme, "toolDiffRemoved") ? `${safeFgAnsi(theme, "toolDiffRemoved")}- removed line\x1b[39m` : "(unchanged)"}`,
 						`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;
 			}
@@ -7434,6 +7591,11 @@ export default function (pi: ExtensionAPI) {
 		clearRtkRewriteState();
 		if (!ctx.hasUI) return;
 		patchUiNotifications(ctx.ui);
+		// terminalTheme (on by default): switch to, and stay on, the theme built from the
+		// terminal's palette. `pi --use-theme <name>` still wins for that run.
+		if (terminalThemeEnabled() && !(themeChosenOnCommandLine() && activeThemeName(ctx.ui) !== SYSTEM_THEME_NAME)) {
+			applyTerminalTheme(ctx, { announce: true, reportUnavailable: readSettings().terminalTheme === 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.90",
+  "version": "1.0.92",
   "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"