pi-compact-tools 0.12.0 → 0.13.1

package/extensions/compact-tools-activity.ts

@@ -1,9 +1,9 @@
 import { UserMessageComponent, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import type { TUI } from "@earendil-works/pi-tui";
 import { onTick } from "./compact-tools-clock.ts";
-import { colorizeRgb, interpolateRgb, type Rgb } from "./compact-tools-color.ts";
+import { colorizeRgb, interpolateRgb } from "./compact-tools-color.ts";
 import { hookMethod } from "./compact-tools-hook.ts";
-import { activityGlow, thinkingLevelColor, type ColorRamp, type ThinkingLevel } from "./compact-tools-palette.ts";
+import { activityGlow, perPalette, type ThinkingLevel } from "./compact-tools-palette.ts";
 
 const WIDGET_KEY = "compact-tools-silent-activity-render";
 const ACTIVITY_STATE = Symbol.for("pi-compact-tools.silent.activity.state");
@@ -109,26 +109,25 @@ export function frameChanges(frame: number): boolean {
 	return FRAME_CHANGED[frameIndex(frame)]!;
 }
 
+type PaintedBreath = readonly (readonly string[])[];
+
 /**
- * Resolving a ramp walks the theme's colors, so each level keeps its last one.
- * It is kept against the colors it is made from, the level's and the text's, not
- * against the theme: Pi's theme is one object whose palette /theme swaps.
+ * Every dot of every frame of a breath at a level, painted once per palette. A breath
+ * has a fixed number of frames, so each frame the line draws after that is a lookup.
  */
-const glowCache = new Map<ThinkingLevel, { colors: string; glow: ColorRamp | undefined }>();
-
-function cachedGlow(theme: Theme, level: ThinkingLevel): ColorRamp | undefined {
-	const colors = typeof theme.getFgAnsi === "function"
-		? theme.getFgAnsi(thinkingLevelColor(level)) + theme.getFgAnsi("text")
-		: "";
-	const cached = glowCache.get(level);
-	if (cached && cached.colors === colors) return cached.glow;
-	const glow = activityGlow(theme, level);
-	glowCache.set(level, { colors, glow });
-	return glow;
-}
-
-function toneColor(glow: ColorRamp, intensity: number): Rgb {
-	return interpolateRgb(glow.from, glow.to, intensity ** TONE_GAMMA);
+function paintedBreath(theme: Theme, level: ThinkingLevel): PaintedBreath {
+	const byLevel = perPalette(theme, "activity-breath", () => new Map<ThinkingLevel, PaintedBreath>());
+	let breath = byLevel.get(level);
+	if (!breath) {
+		const glow = activityGlow(theme, level);
+		const paint = (intensity: number) => glow
+			? colorizeRgb(theme, interpolateRgb(glow.from, glow.to, intensity ** TONE_GAMMA), DOT)
+			// Reached only when the theme's colors did not resolve.
+			: theme.fg(intensity > 0.5 ? "text" : "dim", DOT);
+		breath = FRAMES.map((cells) => cells.map(paint));
+		byLevel.set(level, breath);
+	}
+	return breath;
 }
 
 /** A line the light runs along with a fading afterimage, in the thinking level's color, fitted to the width. */
@@ -142,12 +141,7 @@ export function renderActivityDots(
 	if (width <= 0) return [];
 	const indent = Math.max(0, Math.min(column, width - 1));
 	const fitting = Math.min(DOT_COUNT, width - indent);
-	const glow = cachedGlow(theme, level);
-	const dots = FRAMES[frameIndex(frame)]!.slice(0, fitting).map((intensity) => glow
-		? colorizeRgb(theme, toneColor(glow, intensity), DOT)
-		// Reached only when the theme's colors did not resolve.
-		: theme.fg(intensity > 0.5 ? "text" : "dim", DOT));
-	return [" ".repeat(indent) + dots.join("")];
+	return [" ".repeat(indent) + paintedBreath(theme, level)[frameIndex(frame)]!.slice(0, fitting).join("")];
 }
 
 /** Add the activity row directly beneath the prompt, keeping Pi's padding inside its box. */

package/extensions/compact-tools-color.ts

@@ -1,72 +1,152 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+// A namespace import: Pi before 0.99 has no color functions, and a named import of one would fail to load.
+import * as tui from "@earendil-works/pi-tui";
 
+/** Plain channels, 0-255, so the math below stays arithmetic on three numbers. */
 export type Rgb = { r: number; g: number; b: number };
-type ThemeForeground = Parameters<Theme["getFgAnsi"]>[0];
 
-const ANSI_BASIC_RGB: readonly Rgb[] = [
+/**
+ * What Pi 0.99 added to its Theme for extensions, and what Pi 0.85 to 0.87 keep on
+ * theirs. Each piece is read as optional, and typed here rather than taken from Pi,
+ * so the extension builds and runs against every Pi it supports.
+ */
+type HostColor = object;
+type HostTheme = {
+	colors?: Readonly<Record<string, HostColor | undefined>>;
+	appearance?: "dark" | "light";
+	fgColors?: unknown;
+};
+const host = (theme: Theme) => theme as unknown as HostTheme;
+const colorToRgb = (tui as unknown as { colorToRgb?: (color: HostColor) => Rgb }).colorToRgb;
+
+/**
+ * A theme token's concrete color. Pi 0.99 resolves every token, including one set
+ * to the terminal's own color and one it renders faint; older Pi only writes an
+ * escape sequence, which is read back. A token Pi does not know resolves to
+ * nothing rather than throwing, since callers compute names from host state.
+ */
+export function themeColorRgb(theme: Theme, color: ThemeColor): Rgb | undefined {
+	const { colors } = host(theme);
+	if (colors && colorToRgb) {
+		const concrete = colors[color];
+		if (!concrete) return undefined;
+		const { r, g, b } = colorToRgb(concrete);
+		// Rounded as Pi rounds a color it writes out, so derived shades start from what the terminal shows.
+		return { r: Math.round(r), g: Math.round(g), b: Math.round(b) };
+	}
+	return escapeColorRgb(theme, color);
+}
+
+/** Pi before 0.99: the color inside the token's escape sequence. */
+function escapeColorRgb(theme: Theme, color: ThemeColor): Rgb | undefined {
+	let ansi: string;
+	try {
+		ansi = theme.getFgAnsi(color);
+	} catch {
+		return undefined;
+	}
+	const trueColor = ansi.match(/\[38;2;(\d+);(\d+);(\d+)m/u);
+	if (trueColor) return { r: Number(trueColor[1]), g: Number(trueColor[2]), b: Number(trueColor[3]) };
+	const indexed = ansi.match(/\[38;5;(\d+)m/u);
+	return indexed ? indexedRgb(Number(indexed[1])) : undefined;
+}
+
+const BASIC_RGB: readonly Rgb[] = [
 	{ r: 0, g: 0, b: 0 }, { r: 128, g: 0, b: 0 }, { r: 0, g: 128, b: 0 }, { r: 128, g: 128, b: 0 },
 	{ r: 0, g: 0, b: 128 }, { r: 128, g: 0, b: 128 }, { r: 0, g: 128, b: 128 }, { r: 192, g: 192, b: 192 },
 	{ r: 128, g: 128, b: 128 }, { r: 255, g: 0, b: 0 }, { r: 0, g: 255, b: 0 }, { r: 255, g: 255, b: 0 },
 	{ r: 0, g: 0, b: 255 }, { r: 255, g: 0, b: 255 }, { r: 0, g: 255, b: 255 }, { r: 255, g: 255, b: 255 },
 ];
+/** The 256-color cube's channel values and its gray ramp, as xterm and Pi define them. */
+const CUBE = [0, 95, 135, 175, 215, 255];
+const GRAYS = Array.from({ length: 24 }, (_, index) => 8 + index * 10);
 
-function ansi256ToRgb(index: number): Rgb {
-	if (index < 16) return ANSI_BASIC_RGB[index] ?? { r: 192, g: 192, b: 192 };
+function indexedRgb(index: number): Rgb {
+	if (index < 16) return BASIC_RGB[index] ?? BASIC_RGB[7]!;
 	if (index < 232) {
-		const value = index - 16;
-		const channel = (part: number) => part === 0 ? 0 : 55 + part * 40;
-		return {
-			r: channel(Math.floor(value / 36)),
-			g: channel(Math.floor((value % 36) / 6)),
-			b: channel(value % 6),
-		};
+		const cube = index - 16;
+		return { r: CUBE[Math.floor(cube / 36)]!, g: CUBE[Math.floor((cube % 36) / 6)]!, b: CUBE[cube % 6]! };
 	}
-	const gray = 8 + Math.min(23, index - 232) * 10;
+	const gray = GRAYS[Math.min(23, index - 232)]!;
 	return { r: gray, g: gray, b: gray };
 }
 
-const ANSI_256_RGB: readonly Rgb[] = Array.from({ length: 256 }, (_, index) => ansi256ToRgb(index));
+function nearest(values: readonly number[], target: number): number {
+	let best = 0;
+	for (let index = 1; index < values.length; index++) {
+		if (Math.abs(target - values[index]!) < Math.abs(target - values[best]!)) best = index;
+	}
+	return best;
+}
 
 /**
- * The nearest-color search runs per character on 256-color terminals, so both the
- * palette and the answers are kept. Callers interpolate between a handful of theme
- * colors, so the memo holds tens of entries rather than growing with output size.
+ * The 256-color entry Pi 0.99 picks for a color: the nearest cube or gray step, never
+ * the first sixteen, which are whatever the terminal makes of them. Written here so
+ * every Pi this extension runs on draws a derived color the same way.
  */
-const ansi256ByRgb = new Map<number, number>();
-
-function rgbToAnsi256(rgb: Rgb): number {
-	const key = (rgb.r << 16) | (rgb.g << 8) | rgb.b;
-	const memoized = ansi256ByRgb.get(key);
-	if (memoized !== undefined) return memoized;
-	let bestIndex = 0;
-	let bestDistance = Number.POSITIVE_INFINITY;
-	for (let index = 0; index < 256; index++) {
-		const candidate = ANSI_256_RGB[index]!;
-		const distance = (rgb.r - candidate.r) ** 2 + (rgb.g - candidate.g) ** 2 + (rgb.b - candidate.b) ** 2;
-		if (distance >= bestDistance) continue;
-		bestIndex = index;
-		bestDistance = distance;
-	}
-	ansi256ByRgb.set(key, bestIndex);
-	return bestIndex;
+function ansi256(rgb: Rgb): number {
+	const [r, g, b] = [nearest(CUBE, rgb.r), nearest(CUBE, rgb.g), nearest(CUBE, rgb.b)];
+	const cube = { r: CUBE[r]!, g: CUBE[g]!, b: CUBE[b]! };
+	const grayIndex = nearest(GRAYS, Math.round(luminanceRgb(rgb)));
+	const gray = GRAYS[grayIndex]!;
+	const distance = (to: Rgb) => (rgb.r - to.r) ** 2 * 0.299 + (rgb.g - to.g) ** 2 * 0.587 + (rgb.b - to.b) ** 2 * 0.114;
+	const spread = Math.max(rgb.r, rgb.g, rgb.b) - Math.min(rgb.r, rgb.g, rgb.b);
+	return spread < 10 && distance({ r: gray, g: gray, b: gray }) < distance(cube) ? 232 + grayIndex : 16 + 36 * r + 6 * g + b;
 }
 
-export function themeColorRgb(theme: Theme, color: ThemeForeground): Rgb | undefined {
-	if (typeof theme.getFgAnsi !== "function") return undefined;
-	// Pi throws on a color it does not know, and callers reach this with names computed from
-	// host state — a thinking level Pi adds later would otherwise take down a render.
-	let ansi: string;
-	try {
-		ansi = theme.getFgAnsi(color);
-	} catch {
-		return undefined;
+/** The opening escape sequence for a color, foreground (38) or background (48), in the terminal's color mode. */
+function openColor(theme: Theme, color: Rgb, set: 38 | 48): string {
+	return theme.getColorMode?.() === "256color"
+		? `\x1b[${set};5;${ansi256(color)}m`
+		: `\x1b[${set};2;${Math.round(color.r)};${Math.round(color.g)};${Math.round(color.b)}m`;
+}
+
+export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+	return `${openColor(theme, color, 38)}${text}\x1b[39m`;
+}
+
+export function fillRgb(theme: Theme, color: Rgb, text: string): string {
+	return `${openColor(theme, color, 48)}${text}\x1b[49m`;
+}
+
+/** A painter for one color, its escape sequence written once for every text it paints. */
+export function rgbPainter(theme: Theme, color: Rgb): (text: string) => string {
+	const open = openColor(theme, color, 38);
+	return (text) => `${open}${text}\x1b[39m`;
+}
+
+/**
+ * The palette a theme draws with right now, as an object to key derived colors by.
+ * Pi 0.99 hands out a new `theme.colors` whenever the theme or the terminal's colors
+ * change. Pi 0.85 to 0.87 give every theme its own map of escape sequences, reached
+ * through the same Theme object, which `/theme` points at another theme. A host with
+ * neither is told apart by the escape sequences of the colors derived from.
+ */
+export function paletteOf(theme: Theme): object {
+	const { colors, fgColors } = host(theme);
+	if (colors) return colors;
+	if (fgColors instanceof Map) return fgColors;
+	let key = theme.getColorMode?.() ?? "";
+	for (const token of PALETTE_TOKENS) {
+		try {
+			key += theme.getFgAnsi(token);
+		} catch {
+			key += "?";
+		}
 	}
-	const trueColor = ansi.match(/\[38;2;(\d+);(\d+);(\d+)m/u);
-	if (trueColor) return { r: Number(trueColor[1]), g: Number(trueColor[2]), b: Number(trueColor[3]) };
-	const indexed = ansi.match(/\[38;5;(\d+)m/u);
-	return indexed ? ansi256ToRgb(Number(indexed[1])) : undefined;
+	let palette = escapePalettes.get(key);
+	if (!palette) escapePalettes.set(key, palette = {});
+	return palette;
 }
 
+/** Every token the derived colors are made from. */
+const PALETTE_TOKENS: readonly ThemeColor[] = [
+	"text", "dim", "muted", "toolDiffAdded", "toolDiffRemoved",
+	"thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh",
+];
+/** One object per palette seen; a session switches among a handful of themes at most. */
+const escapePalettes = new Map<string, object>();
+
 export function interpolateRgb(from: Rgb, to: Rgb, amount: number): Rgb {
 	const bounded = Math.max(0, Math.min(1, amount));
 	const channel = (start: number, end: number) => Math.round(start + (end - start) * bounded);
@@ -77,34 +157,23 @@ export function interpolateRgb(from: Rgb, to: Rgb, amount: number): Rgb {
 	};
 }
 
-/** Shared by the foreground (38/39) and background (48/49) SGR pairs. */
-function paintRgb(theme: Theme, color: Rgb, text: string, set: 38 | 48): string {
-	const reset = set === 38 ? 39 : 49;
-	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
-		return `\x1b[${set};5;${rgbToAnsi256(color)}m${text}\x1b[${reset}m`;
-	}
-	return `\x1b[${set};2;${color.r};${color.g};${color.b}m${text}\x1b[${reset}m`;
-}
-
-export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
-	return paintRgb(theme, color, text, 38);
-}
-
 /** Perceived brightness on the same 0-255 scale as the channels, and linear under interpolation. */
 function luminanceRgb(rgb: Rgb): number {
 	return rgb.r * 0.299 + rgb.g * 0.587 + rgb.b * 0.114;
 }
 
-function isDarkTheme(theme: Theme): boolean {
-	const text = themeColorRgb(theme, "text");
-	if (!text) return true;
-	return luminanceRgb(text) > 128;
-}
-
-/** Themes never expose their terminal background, so the poles stand in for it. */
+/** The poles stand in for the terminal background: standing out means moving away from the theme's own. */
 const BLACK: Rgb = { r: 0, g: 0, b: 0 };
 const WHITE: Rgb = { r: 255, g: 255, b: 255 };
 
+/** The theme's declared appearance; before Pi 0.99, a theme with light text is a dark one. */
+function isDark(theme: Theme): boolean {
+	const { appearance } = host(theme);
+	if (appearance) return appearance === "dark";
+	const text = themeColorRgb(theme, "text");
+	return !text || luminanceRgb(text) > 128;
+}
+
 /** Mix a color toward its own gray so a vivid theme hue cannot turn chrome into a highlight. */
 export function neutralizeRgb(rgb: Rgb, keepHue: number): Rgb {
 	const gray = Math.round(luminanceRgb(rgb));
@@ -128,40 +197,40 @@ function atBrightness(rgb: Rgb, target: number): Rgb {
 	return reached >= target - 0.5 ? rounded : interpolateRgb(rounded, WHITE, (target - reached) / (255 - reached));
 }
 
+/** How far a color stands off the background: 0 for invisible, 1 for the opposite pole. */
+function contrastLevel(dark: boolean, rgb: Rgb): number {
+	const brightness = luminanceRgb(rgb) / 255;
+	return dark ? brightness : 1 - brightness;
+}
+
+function atContrast(dark: boolean, rgb: Rgb, level: number): Rgb {
+	return atBrightness(rgb, (dark ? level : 1 - level) * 255);
+}
+
 /** Lift a color part of the way to maximum contrast, keeping its hue for as long as it can. */
 export function liftContrast(theme: Theme, rgb: Rgb, amount: number): Rgb {
-	const dark = isDarkTheme(theme);
-	const brightness = luminanceRgb(rgb) / 255;
-	const level = dark ? brightness : 1 - brightness;
-	const target = level + (1 - level) * amount;
-	return atBrightness(rgb, (dark ? target : 1 - target) * 255);
+	const dark = isDark(theme);
+	const level = contrastLevel(dark, rgb);
+	return atContrast(dark, rgb, level + (1 - level) * amount);
 }
 
 /**
- * Move a color until how far it stands off the theme background — 0 for invisible, 1 for
- * the opposite pole — lands inside the band. A color already inside is returned untouched,
- * so a theme's own choice survives wherever it is legible to begin with.
+ * Move a color until its contrast against the background lands inside the band. A color
+ * already inside is returned untouched, so a theme's own choice survives wherever it is
+ * legible to begin with.
  */
 export function withContrast(theme: Theme, rgb: Rgb, minimum: number, maximum: number): Rgb {
-	const dark = isDarkTheme(theme);
-	const brightness = luminanceRgb(rgb) / 255;
-	const level = dark ? brightness : 1 - brightness;
-	const target = level > maximum ? maximum : level < minimum ? minimum : level;
-	if (target === level) return rgb;
-	return atBrightness(rgb, (dark ? target : 1 - target) * 255);
+	const dark = isDark(theme);
+	const level = contrastLevel(dark, rgb);
+	const target = Math.min(maximum, Math.max(minimum, level));
+	return target === level ? rgb : atContrast(dark, rgb, target);
 }
 
 /**
  * Diff rows need a tint that reads on the terminal background without hijacking `toolSuccessBg`
  * and `toolErrorBg`, which Pi paints across the whole tool row.
  */
-export function diffTintRgb(theme: Theme, color: ThemeForeground, amount = 0.17): Rgb | undefined {
+export function diffTintRgb(theme: Theme, color: ThemeColor, amount = 0.17): Rgb | undefined {
 	const rgb = themeColorRgb(theme, color);
-	if (!rgb) return undefined;
-	const base = isDarkTheme(theme) ? BLACK : WHITE;
-	return interpolateRgb(base, rgb, amount);
-}
-
-export function fillRgb(theme: Theme, color: Rgb, text: string): string {
-	return paintRgb(theme, color, text, 48);
+	return rgb && interpolateRgb(isDark(theme) ? BLACK : WHITE, rgb, amount);
 }

package/extensions/compact-tools-palette.ts

@@ -1,10 +1,18 @@
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { indicatorGlyph, indicatorStrength, indicatorTone, type RowStatus } from "./compact-tools-core.ts";
+import type { ExtensionAPI, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import {
+	indicatorGlyph,
+	indicatorStrength,
+	indicatorTone,
+	RUNNING_INDICATOR_FRAME_COUNT,
+	type RowStatus,
+} from "./compact-tools-core.ts";
 import {
 	colorizeRgb,
 	interpolateRgb,
 	liftContrast,
 	neutralizeRgb,
+	paletteOf,
+	rgbPainter,
 	themeColorRgb,
 	withContrast,
 	type Rgb,
@@ -24,9 +32,7 @@ import {
  * background the moves invert, and standing out means going darker.
  */
 
-type ThemeForeground = Parameters<Theme["getFgAnsi"]>[0];
-
-type ContrastBand = { color: ThemeForeground; keepHue: number; minimum: number; maximum: number };
+type ContrastBand = { color: ThemeColor; keepHue: number; minimum: number; maximum: number };
 
 /** A band with no color attached, for a derivation that supplies its own source. */
 type ContrastRange = { minimum: number; maximum: number };
@@ -63,32 +69,40 @@ const THINKING_LEVEL_COLOR = {
 	high: "thinkingHigh",
 	xhigh: "thinkingXhigh",
 	max: "thinkingMax",
-} as const satisfies Record<ThinkingLevel, ThemeForeground>;
+} as const satisfies Record<ThinkingLevel, ThemeColor>;
 
 /** The theme color a thinking level is painted with. */
-export function thinkingLevelColor(level: ThinkingLevel): ThemeForeground {
+export function thinkingLevelColor(level: ThinkingLevel): ThemeColor {
 	return THINKING_LEVEL_COLOR[level] ?? "thinkingMedium";
 }
 
 /**
- * Derivation is deliberately not cached against the Theme: `/theme` can swap a palette behind
- * the same instance, and a stale entry would outlive the switch. Callers that redraw per line
- * hold the derived value themselves instead.
+ * Derived colors, kept for as long as the palette they came from. `/theme` swaps the
+ * palette behind the same Theme, so the palette rather than the Theme is the key: a
+ * switch misses the cache by itself, and every frame in between is a lookup.
  */
+const derivedByPalette = new WeakMap<object, Map<string, unknown>>();
+
+export function perPalette<T>(theme: Theme, key: string, derive: () => T): T {
+	const palette = paletteOf(theme);
+	let cache = derivedByPalette.get(palette);
+	if (!cache) derivedByPalette.set(palette, cache = new Map());
+	if (!cache.has(key)) cache.set(key, derive());
+	return cache.get(key) as T;
+}
+
 function bandedRgb(theme: Theme, band: ContrastBand): Rgb | undefined {
 	const rgb = themeColorRgb(theme, band.color);
 	if (!rgb) return undefined;
 	return withContrast(theme, neutralizeRgb(rgb, band.keepHue), band.minimum, band.maximum);
 }
 
-/**
- * A chrome painter bound to one theme. Deriving the tone costs a parse and a dozen floating
- * point operations, and the frame is drawn once per line of tool output or thinking detail,
- * so callers in a loop take a painter once and callers with a single rail use `paintChrome`.
- */
+/** A painter for the chrome tone, derived once per palette however many rails a frame draws. */
 export function chromePainter(theme: Theme): (text: string) => string {
-	const chrome = bandedRgb(theme, CHROME);
-	return chrome ? (text) => colorizeRgb(theme, chrome, text) : (text) => theme.fg("dim", text);
+	return perPalette(theme, "chrome", () => {
+		const chrome = bandedRgb(theme, CHROME);
+		return chrome ? rgbPainter(theme, chrome) : (text: string) => theme.fg("dim", text);
+	});
 }
 
 /** Paint one rail, connector, or status line in the chrome tone. */
@@ -104,18 +118,27 @@ function ramp(theme: Theme, low: ContrastBand, high: ContrastBand): ColorRamp |
 	return from && to ? { from, to } : undefined;
 }
 
-/** Fade endpoints for the running tool indicator, or undefined when the theme resolves no RGB. */
-export function indicatorPulse(theme: Theme): ColorRamp | undefined {
-	return ramp(theme, PULSE_LOW, PULSE_HIGH);
+/**
+ * A row's status dot; a running one pulses between the theme's endpoints as frames advance.
+ * Every running row repaints its dot on every frame, so the pulse is painted once per palette.
+ */
+export function paintIndicator(theme: Theme, status: RowStatus, frame: number): string {
+	if (status !== "running") return theme.fg(indicatorTone(status), indicatorGlyph(status));
+	const pulse = runningPulse(theme);
+	return pulse[((frame % pulse.length) + pulse.length) % pulse.length]!;
 }
 
-/** A row's status dot; a running one pulses between the theme's endpoints as frames advance. */
-export function paintIndicator(theme: Theme, status: RowStatus, frame: number): string {
-	const glyph = indicatorGlyph(status, frame);
-	const pulse = status === "running" ? indicatorPulse(theme) : undefined;
-	return pulse
-		? colorizeRgb(theme, interpolateRgb(pulse.from, pulse.to, indicatorStrength(status, frame)), glyph)
-		: theme.fg(indicatorTone(status, frame), glyph);
+/** Every step of the running dot's pulse, painted once per palette. */
+function runningPulse(theme: Theme): readonly string[] {
+	return perPalette(theme, "running-pulse", () => {
+		const pulse = ramp(theme, PULSE_LOW, PULSE_HIGH);
+		return Array.from({ length: RUNNING_INDICATOR_FRAME_COUNT }, (_, step) => {
+			const glyph = indicatorGlyph("running", step);
+			return pulse
+				? colorizeRgb(theme, interpolateRgb(pulse.from, pulse.to, indicatorStrength("running", step)), glyph)
+				: theme.fg(indicatorTone("running", step), glyph);
+		});
+	});
 }
 
 /** How far the brightest activity dot moves from the level's color toward the label's crest. */
@@ -129,17 +152,21 @@ const ACTIVITY_UNLIT = 0.05;
  * label's full crest washes every level toward the same near-white.
  */
 export function activityGlow(theme: Theme, level: ThinkingLevel): ColorRamp | undefined {
-	const glow = progressGlow(theme, level);
-	if (!glow) return undefined;
-	const lit = interpolateRgb(glow.from, glow.to, ACTIVITY_CREST_MIX);
-	return { from: withContrast(theme, lit, ACTIVITY_UNLIT, ACTIVITY_UNLIT), to: lit };
+	return perPalette(theme, `activity:${level}`, () => {
+		const glow = progressGlow(theme, level);
+		if (!glow) return undefined;
+		const lit = interpolateRgb(glow.from, glow.to, ACTIVITY_CREST_MIX);
+		return { from: withContrast(theme, lit, ACTIVITY_UNLIT, ACTIVITY_UNLIT), to: lit };
+	});
 }
 
 /** Sweep endpoints for the working label at a thinking level, resting color to crest. */
 export function progressGlow(theme: Theme, level: ThinkingLevel): ColorRamp | undefined {
-	const raw = themeColorRgb(theme, thinkingLevelColor(level));
-	if (!raw) return undefined;
-	const lifted = liftContrast(theme, raw, GLOW_REST_LIFT);
-	const from = withContrast(theme, lifted, GLOW_FLOOR.minimum, GLOW_FLOOR.maximum);
-	return { from, to: liftContrast(theme, from, GLOW_CREST_LIFT) };
+	return perPalette(theme, `progress:${level}`, () => {
+		const raw = themeColorRgb(theme, thinkingLevelColor(level));
+		if (!raw) return undefined;
+		const lifted = liftContrast(theme, raw, GLOW_REST_LIFT);
+		const from = withContrast(theme, lifted, GLOW_FLOOR.minimum, GLOW_FLOOR.maximum);
+		return { from, to: liftContrast(theme, from, GLOW_CREST_LIFT) };
+	});
 }

package/extensions/compact-tools-progress.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { stripTerminalSequences, truncateToWidth } from "@earendil-works/pi-tui";
 import { onTick } from "./compact-tools-clock.ts";
-import { colorizeRgb, interpolateRgb } from "./compact-tools-color.ts";
+import { colorizeRgb, interpolateRgb, paletteOf } from "./compact-tools-color.ts";
 import { progressGlow, type ColorRamp, type ThinkingLevel } from "./compact-tools-palette.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
@@ -88,6 +88,8 @@ export class ProgressController {
 	private readonly activeTools = new Map<string, string>();
 	private message: string | undefined;
 	private frames: string[] = [];
+	/** The palette `frames` were painted with. */
+	private paintedFor: object | undefined;
 	private frame = 0;
 	/** Stops this label's share of the animation clock. */
 	private stopTicking: (() => void) | undefined;
@@ -134,7 +136,7 @@ export class ProgressController {
 			if (!this.context || event.level === this.level) return;
 			this.level = event.level;
 			// Recolor in place: the label and its animation phase are unchanged.
-			this.frames = createGlowFrames(this.message ?? "", this.context.ui.theme, this.level);
+			this.frames = [];
 			this.renderMessage();
 		});
 	}
@@ -169,7 +171,7 @@ export class ProgressController {
 	private setMessage(message: string): void {
 		if (!this.context || (this.message === message && this.stopTicking)) return;
 		this.message = message;
-		this.frames = createGlowFrames(message, this.context.ui.theme, this.level);
+		this.frames = [];
 		this.frame = 0;
 		this.renderMessage();
 		if (this.stopTicking) return;
@@ -180,7 +182,15 @@ export class ProgressController {
 	}
 
 	private renderMessage(): void {
-		if (!this.message || !this.context || this.frames.length === 0) return;
+		if (!this.message || !this.context) return;
+		// Painted once per label, level, and palette: a theme switch, or the system theme
+		// following the terminal from dark to light, repaints on the next frame.
+		const theme = this.context.ui.theme;
+		const palette = paletteOf(theme);
+		if (this.frames.length === 0 || this.paintedFor !== palette) {
+			this.frames = createGlowFrames(this.message, theme, this.level);
+			this.paintedFor = palette;
+		}
 		this.context.ui.setWorkingMessage(this.frames[this.frame % this.frames.length]);
 	}
 

package/extensions/compact-tools-runtime.ts

@@ -44,6 +44,11 @@ export class ToolRuntime {
 	 * more than one run's calls.
 	 */
 	private readonly currentCalls = new Set<string>();
+	/**
+	 * Calls a tool is making through `ctx.executeTool()`, as codemode scripts do. They
+	 * never get a row of their own, so nothing is timed or remembered for them.
+	 */
+	private readonly nestedCalls = new Set<string>();
 
 	constructor(private readonly clock: () => number = () => performance.now()) {
 		const shared = globalThis as SharedState;
@@ -93,7 +98,10 @@ export class ToolRuntime {
 	 * running, so a row that never got its result stops pulsing and waits instead.
 	 */
 	setBusy(busy: boolean): void {
-		if (busy && this.busy !== true) this.currentCalls.clear();
+		if (busy && this.busy !== true) {
+			this.currentCalls.clear();
+			this.nestedCalls.clear();
+		}
 		this.busy = busy;
 		if (busy) return;
 		const animating = this.indicators.size > 0;
@@ -110,6 +118,12 @@ export class ToolRuntime {
 		this.currentCalls.add(toolCallId);
 	}
 
+	/** A call another tool made began (`running`) or finished; Pi says so with `parentToolCallId`. */
+	noteNestedCall(toolCallId: string, running: boolean): void {
+		if (running) this.nestedCalls.add(toolCallId);
+		else this.nestedCalls.delete(toolCallId);
+	}
+
 	/**
 	 * Whether a call can be running: only one Pi announced in the run going on. A
 	 * row restored from the session, one left without a result when its run ended,
@@ -204,7 +218,7 @@ export class ToolRuntime {
 	createTimedExecute(definition: BuiltInDefinition): TimedExecute {
 		const execute = definition.execute as TimedExecute;
 		return async (...args: any[]) => {
-			const toolCallId = typeof args[0] === "string" ? args[0] : undefined;
+			const toolCallId = typeof args[0] === "string" && !this.nestedCalls.has(args[0]) ? args[0] : undefined;
 			const startedAt = (toolCallId ? this.executionTimings.get(toolCallId)?.startedAt : undefined) ?? Date.now();
 			if (toolCallId && !this.executionTimings.has(toolCallId)) {
 				this.executionTimings.set(toolCallId, { startedAt });

package/extensions/compact-tools-silent.ts

@@ -1,5 +1,7 @@
 import {
 	AssistantMessageComponent,
+	BranchSummaryMessageComponent,
+	CompactionSummaryMessageComponent,
 	CustomMessageComponent,
 	DynamicBorder,
 	ToolExecutionComponent,
@@ -118,12 +120,25 @@ export function renderAnswerOnly(component: AssistantLike, width: number, render
 	}
 }
 
+/**
+ * A summary Pi writes into the chat of its own accord: the context it compacted
+ * away, or the /tree branch it left behind. Both are bookkeeping rather than a
+ * prompt or an answer, and compaction arrives mid-turn, where a visible row
+ * would come between the animating activity line and the editor below it.
+ * Read through `typeof` so an older Pi without the export keeps its own rows.
+ */
+function isSummary(child: unknown): boolean {
+	return (typeof CompactionSummaryMessageComponent === "function" && isKind(child, CompactionSummaryMessageComponent))
+		|| (typeof BranchSummaryMessageComponent === "function" && isKind(child, BranchSummaryMessageComponent));
+}
+
 /**
  * A row Pi (or this extension) adds to the chat directly rather than as a message:
- * status lines are Text, and "What's New" blocks add borders and Markdown too.
+ * status lines are Text, "What's New" blocks add borders and Markdown too, and
+ * compaction and branch summaries come as components of their own.
  */
 function isNotice(child: unknown): boolean {
-	return isKind(child, Text) || isKind(child, DynamicBorder) || isKind(child, Markdown);
+	return isKind(child, Text) || isKind(child, DynamicBorder) || isKind(child, Markdown) || isSummary(child);
 }
 
 /**

package/extensions/compact-tools.ts

@@ -503,6 +503,14 @@ function noteCalls(message: unknown): void {
 	}
 }
 
+/**
+ * Whether another tool made the call through `ctx.executeTool()`, as codemode scripts
+ * do. Pi 0.99 marks such calls with `parentToolCallId`; older Pi never makes them.
+ */
+function madeByTool(event: object): boolean {
+	return typeof (event as { parentToolCallId?: unknown }).parentToolCallId === "string";
+}
+
 /** Hand the animation Pi's frame request, reached through an invisible widget as the extension API allows. */
 function bindRenderer(ctx: ExtensionContext): void {
 	ctx.ui.setWidget(RENDER_WIDGET_KEY, (tui) => {
@@ -572,10 +580,14 @@ export default function compactTools(pi: ExtensionAPI): void {
 	// their rows, and told to extensions before Pi makes them.
 	pi.on("message_update", (event) => noteCalls(event.message));
 	pi.on("tool_execution_start", (event) => {
+		if (madeByTool(event)) return runtime.noteNestedCall(event.toolCallId, true);
 		runtime.noteCall(event.toolCallId);
 		runtime.noteExecutionStart(event.toolCallId);
 	});
-	pi.on("tool_execution_end", (event) => runtime.noteExecutionEnd(event.toolCallId));
+	pi.on("tool_execution_end", (event) => {
+		if (madeByTool(event)) return runtime.noteNestedCall(event.toolCallId, false);
+		runtime.noteExecutionEnd(event.toolCallId);
+	});
 	pi.on("session_shutdown", (event) => {
 		thinkingCycle.dispose();
 		progress.dispose();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "Compact, expandable tool rows for Pi in its own compact style or Claude Code's, with a silent mode and a GitHub Dark theme.",
   "type": "module",
   "license": "MIT",
@@ -50,8 +50,8 @@
     "@earendil-works/pi-tui": ">=0.85.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "@types/node": "^24.0.0",
     "tsx": "^4.23.13",
     "typescript": "^5.9.0"

package/release-notes.json

@@ -1,4 +1,12 @@
 {
+  "0.13.1": [],
+  "0.13.0": [
+    "Follows Pi 0.99's system theme and light terminals: rails, dots, and the working label take their colors from the theme itself",
+    "Running dots, rails, and silent mode's activity line are painted once per theme instead of every frame",
+    "The working label repaints when the theme changes, including when the terminal switches between dark and light",
+    "Tools a codemode script calls leave nothing behind in the rows' timings",
+    "Silent mode hides compaction and branch summaries that Pi writes mid-turn"
+  ],
   "0.12.0": [
     "Running rows animate without being rebuilt: one repaint per frame, however many tools run",
     "A tool's time counts from when it runs, not from when the model began writing its call",