gentle-pi 4.2.0 → 4.4.0

package/lib/shell-bar.ts

@@ -1,5 +1,5 @@
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { GAUGE_CELLS, gaugeTone, paintGauge, renderGauge, type GaugeTone } from "./shell-gauge.ts";
+import { GAUGE_CELLS, gaugeTone, paintGauge, renderGauge, type GaugePaint, type GaugeTone } from "./shell-gauge.ts";
 import { renderUsageBar, selectUsageLimit, type ProviderUsage, type UsageWindow } from "./shell-usage.ts";
 import { sanitizeTerminalText } from "./terminal-theme.ts";
 import { CARD_TONE, floatRows, panelInnerWidth, renderCard } from "./shell-card.ts";
@@ -22,7 +22,7 @@ export interface ShellBarModel {
 	review?: ReviewSidebarSnapshot;
 	jobs?: RunningJobDisplay[];
 	profile?: string;
-	changes?: { files: number; added: number; deleted: number; notice?: string };
+	changes?: { files: number; added: number; deleted: number };
 	cwd: string;
 	branch: string | null;
 	dirty: number | undefined;
@@ -159,21 +159,21 @@ function executionSegment(modelId: string, effort: string | undefined, theme: Sh
 		: theme.fg(ROLE.MODEL, modelId);
 }
 
-function contextSegment(contextPercent: number | null, theme: ShellBarTheme): string {
+function contextSegment(contextPercent: number | null, theme: ShellBarTheme, paint?: GaugePaint): string {
 	const percentText = contextPercent === null ? "?%" : `${Math.round(contextPercent)}%`;
-	return `${theme.fg(ROLE.LABEL, "ctx")} ${paintGauge(contextPercent, theme)} ${theme.fg(ROLE.VALUE, percentText)}`;
+	return `${theme.fg(ROLE.LABEL, "ctx")} ${paintGauge(contextPercent, theme, GAUGE_CELLS, paint)} ${theme.fg(ROLE.VALUE, percentText)}`;
 }
 
 function costSegment(costTotal: number, subscription: boolean, theme: ShellBarTheme): string {
 	return theme.fg(ROLE.VALUE, formatCost(costTotal, subscription));
 }
 
-function buildSegments(model: ShellBarModel, theme: ShellBarTheme, presentation?: Presentation): string[] {
+function buildSegments(model: ShellBarModel, theme: ShellBarTheme, presentation?: Presentation, paint?: GaugePaint): string[] {
 	const location = locationSegment(model, theme);
 	const modelSegment = executionSegment(model.modelId, model.effort, theme);
-	const context = contextSegment(model.contextPercent, theme);
+	const context = contextSegment(model.contextPercent, theme, paint);
 	const cost = costSegment(model.costTotal, model.subscription, theme);
-	const usage = model.usage ? renderUsageBar(model.usage, theme, model.modelId) : undefined;
+	const usage = model.usage ? renderUsageBar(model.usage, theme, model.modelId, paint) : undefined;
 	const statuses = model.statuses.map((status) => theme.fg(ROLE.STATUS, sanitizeStatus(status)));
 	return [
 		...(presentation?.density === "minimal" ? [] : [theme.fg(ROLE.BRAND, SHELL_BAR_BRAND)]),
@@ -240,7 +240,6 @@ export function renderShellSidebarBar(model: ShellBarModel, theme: ShellBarTheme
 				changes?.files
 					? `${changes.files} ${changes.files === 1 ? "file" : "files"} · ${theme.fg("success", `+${changes.added}`)} ${theme.fg("error", `−${changes.deleted}`)}`
 					: label("No captured changes"),
-				...(changes?.notice ? [theme.fg("warning", sanitizeStatus(changes.notice))] : []),
 				label("/gentle:changes"),
 			],
 		}]),
@@ -295,11 +294,11 @@ function headerLeftStages(model: ShellHeaderModel, theme: ShellBarTheme, showMod
 const USAGE_LABEL_ROLE = ROLE.LABEL;
 const USAGE_HINT_ROLE = "dim";
 
-function usageWindowText(window: UsageWindow, theme: ShellBarTheme, withGauge: boolean): string {
+function usageWindowText(window: UsageWindow, theme: ShellBarTheme, withGauge: boolean, paint?: GaugePaint): string {
 	const percent = `${Math.round(window.usedPercent)}%`;
 	const parts = [
 		...(window.label.length > 0 ? [theme.fg(ROLE.LABEL, window.label)] : []),
-		...(withGauge ? [paintGauge(window.usedPercent, theme)] : []),
+		...(withGauge ? [paintGauge(window.usedPercent, theme, GAUGE_CELLS, paint)] : []),
 		theme.fg(ROLE.VALUE, percent),
 	];
 	return parts.join(" ");
@@ -310,10 +309,10 @@ function usageWindowText(window: UsageWindow, theme: ShellBarTheme, withGauge: b
 // text only. A provider with no usage data at all has no windows to shape,
 // so all three collapse to the bare "usage" label plus the shortcut hint.
 type UsageStage = "full" | "text" | "primary";
-function usageSegmentText(windows: UsageWindow[], theme: ShellBarTheme, stage: UsageStage, hint: string | undefined): string {
+function usageSegmentText(windows: UsageWindow[], theme: ShellBarTheme, stage: UsageStage, hint: string | undefined, paint?: GaugePaint): string {
 	const label = theme.fg(USAGE_LABEL_ROLE, "usage");
 	const shown = stage === "primary" ? windows.slice(0, 1) : windows;
-	const body = shown.map((window) => usageWindowText(window, theme, stage === "full")).join(` ${theme.fg(ROLE.LABEL, "·")} `);
+	const body = shown.map((window) => usageWindowText(window, theme, stage === "full", paint)).join(` ${theme.fg(ROLE.LABEL, "·")} `);
 	const head = body.length > 0 ? `${label} ${body}` : label;
 	return hint ? `${head} ${theme.fg(ROLE.LABEL, "·")} ${theme.fg(USAGE_HINT_ROLE, hint)}` : head;
 }
@@ -338,16 +337,16 @@ function fitHeaderContent(text: string, width: number): string {
 	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
 }
 
-export function renderShellHeaderBar(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: Presentation): ShellHeaderResult {
+export function renderShellHeaderBar(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: Presentation, paint?: GaugePaint): ShellHeaderResult {
 	const targetWidth = Math.max(0, Math.floor(width));
 	let content: ShellHeaderResult | undefined;
 	let contentWidth = targetWidth;
 	const row = floatHeaderRow(theme, targetWidth, (inner) => {
 		contentWidth = inner;
-		content = headerContent(model, theme, inner, usageHint, presentation);
+		content = headerContent(model, theme, inner, usageHint, presentation, paint);
 		return content.text;
 	});
-	if (row === undefined || !content) return headerContent(model, theme, width, usageHint, presentation);
+	if (row === undefined || !content) return headerContent(model, theme, width, usageHint, presentation, paint);
 	const { usageSpan } = content;
 	// The inset splits evenly around the content, so its left share is where
 	// the content's columns start.
@@ -356,8 +355,8 @@ export function renderShellHeaderBar(model: ShellHeaderModel, theme: ShellBarThe
 }
 
 /** Shared geometry for the rail header and the below-editor header widget. */
-export function renderShellHeaderChrome(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation): ShellHeaderChrome {
-	const { text, usageSpan } = renderShellHeaderBar(model, theme, width, usageHint, presentation);
+export function renderShellHeaderChrome(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation, paint?: GaugePaint): ShellHeaderChrome {
+	const { text, usageSpan } = renderShellHeaderBar(model, theme, width, usageHint, presentation, paint);
 	const targetWidth = Math.max(0, Math.floor(width));
 	const painted = floatHeaderPaint(theme, targetWidth, () => "");
 	const rule = renderShellHeaderRule(theme, targetWidth);
@@ -377,12 +376,12 @@ export function shellHeaderUsageHit(chrome: ShellHeaderChrome, x: number, y: num
 	return y === chrome.headerRow && usageSpan !== undefined && x >= usageSpan.start && x < usageSpan.end;
 }
 
-function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: Presentation): ShellHeaderResult {
+function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: Presentation, paint?: GaugePaint): ShellHeaderResult {
 	const targetWidth = Math.max(0, Math.floor(width));
 	const jobs = model.jobs ? theme.fg(ROLE.STATUS, shellJobsCount(model.jobs)) : undefined;
 	const ctxCost = joinSegments([
 		...(jobs ? [jobs] : []),
-		...(presentation?.visibility.usageCost === false ? [] : [contextSegment(model.contextPercent, theme), costSegment(model.costTotal, model.subscription, theme)]),
+		...(presentation?.visibility.usageCost === false ? [] : [contextSegment(model.contextPercent, theme, paint), costSegment(model.costTotal, model.subscription, theme)]),
 	], theme);
 	const windows = model.usage ? (selectUsageLimit(model.usage, model.modelId)?.windows ?? []) : [];
 	const leftStages = headerLeftStages(model, theme, presentation?.visibility.modelDetails !== false)
@@ -403,7 +402,7 @@ function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: num
 		{ leftIndex: leftStages.length - 1, usageStage: undefined },
 	];
 	for (const { leftIndex, usageStage } of attempts) {
-		const usageText = usageStage ? usageSegmentText(windows, theme, usageStage, usageHint) : undefined;
+		const usageText = usageStage ? usageSegmentText(windows, theme, usageStage, usageHint, paint) : undefined;
 		const right = usageText ? joinSegments([ctxCost, usageText], theme) : ctxCost;
 		const left = joinSegments(leftStages[leftIndex]!, theme);
 		if (visibleWidth(left) + (right ? RIGHT_PADDING : 0) + visibleWidth(right) > targetWidth) continue;
@@ -422,12 +421,14 @@ function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: num
 
 // A single owner supplies real captured filenames, not ShellBarModel's totals.
 // Undefined keeps every legacy surface alive for style/width/theme transitions.
-export function renderShellBelowInputFloat(model: ShellBarModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation, changes?: ChangesModel): ShellHeaderChrome | undefined {
+export function renderShellBelowInputFloat(model: ShellBarModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation, changes?: ChangesModel, paint?: GaugePaint): ShellHeaderChrome | undefined {
 	if (presentation?.headerPlacement !== "below-input") return undefined;
 	const targetWidth = Math.max(0, Math.floor(width));
 	if (floatHeaderPaint(theme, targetWidth, () => "") === undefined) return undefined;
-	const chrome = renderShellHeaderChrome(buildShellHeaderModel(model, presentation.statusPlacement === "hidden"), theme, targetWidth, usageHint, presentation);
-	const changesRow = changes?.files.length && presentation.visibility.changes !== false
+	const chrome = renderShellHeaderChrome(buildShellHeaderModel(model, presentation.statusPlacement === "hidden"), theme, targetWidth, usageHint, presentation, paint);
+	// The row exists only while files are actually tracked; an unborn-only root
+	// is silence here (/gentle:changes explains the state on demand).
+	const changesRow = Boolean(changes && changes.files.length > 0) && presentation.visibility.changes !== false
 		? floatHeaderRow(theme, targetWidth, (inner) => renderChangesWidget(changes, theme, inner)[0] ?? "")
 		: undefined;
 	const statuses = presentation.statusPlacement === "hidden" ? [] : [
@@ -456,12 +457,12 @@ export function renderShellBelowInputFloat(model: ShellBarModel, theme: ShellBar
 // header row's own cascade, so context, cost and usage outlive the location
 // on small screens, and keeps extension statuses on a second line instead of
 // dropping them the way the header deliberately does.
-export function renderShellBottomOnlyBar(model: ShellBarModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation, changes?: ChangesModel): string[] {
-	const grouped = renderShellBelowInputFloat(model, theme, width, usageHint, presentation, changes);
+export function renderShellBottomOnlyBar(model: ShellBarModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: HeaderPresentation, changes?: ChangesModel, paint?: GaugePaint): string[] {
+	const grouped = renderShellBelowInputFloat(model, theme, width, usageHint, presentation, changes, paint);
 	if (grouped) return grouped.rows;
 	const headerModel = buildShellHeaderModel(model, true);
 	// Neon, missing backgrounds and sub-minimum widths keep the old row count.
-	const rows = [headerContent(headerModel, theme, width, usageHint, presentation).text];
+	const rows = [headerContent(headerModel, theme, width, usageHint, presentation, paint).text];
 	const statuses = model.statuses.map(sanitizeStatus).filter((status) => status.length > 0).map((status) => theme.fg(ROLE.STATUS, status));
 	return statuses.length ? [...rows, truncateToWidth(joinSegments(statuses, theme), Math.max(0, Math.floor(width)), "…")] : rows;
 }
@@ -503,8 +504,8 @@ export function renderShellHeaderRule(theme: ShellBarTheme, width: number): stri
 	return theme.fg(HEADER_RULE_ROLE, HEADER_RULE_CHAR.repeat(targetWidth));
 }
 
-export function renderShellBar(model: ShellBarModel, theme: ShellBarTheme, width: number, presentation?: Presentation): string[] {
-	let segments = buildSegments(model, theme, presentation);
+export function renderShellBar(model: ShellBarModel, theme: ShellBarTheme, width: number, presentation?: Presentation, paint?: GaugePaint): string[] {
+	let segments = buildSegments(model, theme, presentation, paint);
 	const right = model.sessionName ? theme.fg(ROLE.SESSION, model.sessionName) : undefined;
 
 	let left = joinSegments(segments, theme);

package/lib/shell-changes-view.ts

@@ -67,12 +67,15 @@ export function colorDiff(text: string, theme: ChangesViewTheme): string[] {
 	return lines;
 }
 
+// New files are two distinct states: `A` is tracked and staged, `U` is still
+// untracked. Git's own `??` reads as a broken value in a status column, so the
+// list names the state instead of echoing the plumbing code.
 const FILE_STATUS = {
 	[CHANGE_STATUS.MODIFIED]: "M",
 	[CHANGE_STATUS.ADDED]: "A",
 	[CHANGE_STATUS.DELETED]: "D",
 	[CHANGE_STATUS.RENAMED]: "R",
-	[CHANGE_STATUS.UNTRACKED]: "??",
+	[CHANGE_STATUS.UNTRACKED]: "U",
 } as const;
 
 function fileCounts(file: ChangedFile, theme: ChangesViewTheme): string {
@@ -113,18 +116,41 @@ function fit(text: string, width: number): string {
 	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
 }
 
-// Both standalone files and the worktree accordion use the original frame.
-function renderPanes(width: number, rows: number, theme: ChangesViewTheme, title: string, leftLine: (row: number) => string, diffLines: string[], keys: string, headerFile?: ChangedFile): string[] {
+// One geometry feeds both rendering and pointer hit-testing, so clicks stay
+// aligned with what is painted. Diff-only drops the list column and its
+// separator; its empty list zone receives no pointer events.
+interface PaneLayout {
+	inner: number;
+	listWidth: number;
+	diffWidth: number;
+	listStart: number;
+	listEnd: number;
+	diffStart: number;
+	diffEnd: number;
+}
+
+function paneLayout(width: number, diffOnly: boolean): PaneLayout {
 	const inner = Math.max(8, width - 2);
+	if (diffOnly) return { inner, listWidth: 0, diffWidth: inner - 2, listStart: 0, listEnd: 0, diffStart: 2, diffEnd: inner };
 	const listWidth = Math.min(LIST_MAX_WIDTH, Math.floor(inner * LIST_RATIO));
 	const diffWidth = inner - listWidth - 4;
+	return { inner, listWidth, diffWidth, listStart: 2, listEnd: 2 + listWidth, diffStart: 5 + listWidth, diffEnd: 5 + listWidth + diffWidth };
+}
+
+// Both standalone files and the worktree accordion use the original frame.
+function renderPanes(width: number, rows: number, theme: ChangesViewTheme, title: string, leftLine: (row: number) => string, diffLines: string[], keys: string, headerFile?: ChangedFile, diffOnly = false): string[] {
+	const { inner, listWidth, diffWidth } = paneLayout(width, diffOnly);
 	const rightLines = headerFile ? [pathHeader(headerFile, theme, diffWidth), ...diffLines] : diffLines;
 	const titleText = truncateToWidth(title, inner - 4, "…");
 	const top = theme.fg(ROLE.FRAME, "╭─ ") + theme.fg(ROLE.TITLE, titleText) + theme.fg(ROLE.FRAME, ` ${rule(inner - visibleWidth(titleText) - 3)}╮`);
 	const body: string[] = [];
 	for (let row = 0; row < rows; row += 1) {
-		const left = fit(leftLine(row), listWidth);
 		const right = fit(rightLines[row] ?? "", diffWidth);
+		if (diffOnly) {
+			body.push(`${theme.fg(ROLE.FRAME, "│")} ${right} ${theme.fg(ROLE.FRAME, "│")}`);
+			continue;
+		}
+		const left = fit(leftLine(row), listWidth);
 		body.push(`${theme.fg(ROLE.FRAME, "│")} ${left} ${theme.fg(ROLE.FRAME, "│")} ${right}${theme.fg(ROLE.FRAME, "│")}`);
 	}
 	const keysLine = `${theme.fg(ROLE.FRAME, "│")} ${fit(keys, inner - 2)} ${theme.fg(ROLE.FRAME, "│")}`;
@@ -142,11 +168,9 @@ interface PointerLayout {
 	diffEnd: number;
 }
 
-function pointerLayout(width: number, bodyRows: number): PointerLayout {
-	const inner = Math.max(8, width - 2);
-	const listWidth = Math.min(LIST_MAX_WIDTH, Math.floor(inner * LIST_RATIO));
-	const diffWidth = inner - listWidth - 4;
-	return { width, height: bodyRows + CHROME_ROWS, bodyRows, listStart: 2, listEnd: 2 + listWidth, diffStart: 5 + listWidth, diffEnd: 5 + listWidth + diffWidth };
+function pointerLayout(width: number, bodyRows: number, diffOnly = false): PointerLayout {
+	const { listStart, listEnd, diffStart, diffEnd } = paneLayout(width, diffOnly);
+	return { width, height: bodyRows + CHROME_ROWS, bodyRows, listStart, listEnd, diffStart, diffEnd };
 }
 
 function displayText(text: string): string {
@@ -186,6 +210,8 @@ export class WorktreeChangesView {
 	private disposed = false;
 	private leftPressActive = false;
 	private hoveredIndex: number | undefined;
+	// Not persisted: every opening starts with the file list visible.
+	private diffOnly = false;
 	private readonly expanded = new Set<string>();
 	private readonly previews = new Map<string, { fingerprint: string; view: ChangesView }>();
 
@@ -224,13 +250,27 @@ export class WorktreeChangesView {
 	handleInput(data: string): void {
 		if (this.disposed) return;
 		if (data === "r") return this.deps.onRefresh();
-		if (matchesKey(data, Key.escape) || data === "q") return this.deps.onClose();
+		if (data === "q") return this.deps.onClose();
+		if (matchesKey(data, Key.escape)) {
+			if (!this.diffOnly) return this.deps.onClose();
+			return this.setDiffOnly(false);
+		}
+		if (data === "F") return this.setDiffOnly(!this.diffOnly);
 		const rows = this.visibleRows();
 		const row = rows[this.selected];
 		if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("j")) || matchesKey(data, Key.ctrl("k"))) {
 			if (row?.file) this.previews.get(rowKey(row))?.view.handleInput(data);
 			return;
 		}
+		if (this.diffOnly) {
+			// Only files have a diff: j/k walk every file, crossing groups.
+			if (data === "j" || matchesKey(data, Key.down)) this.stepFile(1);
+			else if (data === "k" || matchesKey(data, Key.up)) this.stepFile(-1);
+			else if (row?.file && (data === "o" || matchesKey(data, Key.enter))) return this.deps.onOpen(row.tree.root, row.file);
+			else return;
+			this.deps.requestRender();
+			return;
+		}
 		if (data === "j" || matchesKey(data, Key.down)) this.selected = Math.max(0, Math.min(rows.length - 1, this.selected + 1));
 		else if (data === "k" || matchesKey(data, Key.up)) this.selected = Math.max(0, this.selected - 1);
 		else if (row && (matchesKey(data, Key.left) || matchesKey(data, Key.backspace))) {
@@ -315,9 +355,11 @@ export class WorktreeChangesView {
 				: paintHoverable(theme, `${this.expanded.has(row.tree.root) ? "▾" : "▸"} ${displayText(row.tree.branch ?? "detached")} · ${displayText(basename(row.tree.root))}`, hovered, idleRole);
 			return `${marker} ${text}`;
 		};
-		const keys = theme.fg(ROLE.KEY_TEXT, "j/k select   enter toggle/open   ← parent/fold   ctrl+j/k scroll   r refresh   esc close");
-		this.pointerLayout = pointerLayout(width, height);
-		return renderPanes(width, height, theme, `✎ Changes · ${this.trees.length} worktrees`, leftLine, preview, keys, selected?.file);
+		const keys = theme.fg(ROLE.KEY_TEXT, this.diffOnly
+			? "j/k file   ctrl+j/k scroll   o open   r refresh   F files   esc files"
+			: "j/k select   enter toggle/open   ← fold   ctrl+j/k scroll   r refresh   F diff only   esc close");
+		this.pointerLayout = pointerLayout(width, height, this.diffOnly);
+		return renderPanes(width, height, theme, `✎ Changes · ${this.trees.length} worktrees`, leftLine, preview, keys, selected?.file, this.diffOnly);
 	}
 
 	invalidate(): void {
@@ -341,6 +383,31 @@ export class WorktreeChangesView {
 		return Math.max(MIN_BODY_ROWS, rows - CHROME_ROWS);
 	}
 
+	private setDiffOnly(on: boolean): void {
+		this.diffOnly = on;
+		this.hoveredIndex = undefined;
+		this.pointerLayout = undefined;
+		// A group header has no diff; diff-only starts on the next file.
+		if (on && !this.visibleRows()[this.selected]?.file) this.stepFile(1);
+		this.deps.requestRender();
+	}
+
+	// Move to the next file in the fully expanded order, expanding its group
+	// so the file list shows the same selection after diff-only mode.
+	private stepFile(direction: 1 | -1): void {
+		const all: WorktreeRow[] = this.trees.flatMap((tree) => [{ tree }, ...tree.model.files.map((file) => ({ tree, file }))]);
+		const current = this.visibleRows()[this.selected];
+		let index = current ? all.findIndex((row) => rowKey(row) === rowKey(current)) : -1;
+		do index += direction;
+		while (index >= 0 && index < all.length && !all[index]!.file);
+		const target = all[index];
+		if (!target) return;
+		this.expanded.add(target.tree.root);
+		this.selected = this.visibleRows().findIndex((row) => rowKey(row) === rowKey(target));
+		this.ensureSelectedVisible();
+		this.ensurePreview();
+	}
+
 	private scrollList(delta: number, rows: number): boolean {
 		const next = Math.max(0, Math.min(Math.max(0, this.visibleRows().length - rows), this.listOffset + Math.trunc(delta)));
 		if (next === this.listOffset) return false;

package/lib/shell-changes.ts

@@ -27,6 +27,8 @@ export interface ChangesModel {
 	files: ChangedFile[];
 	added: number;
 	deleted: number;
+	/** Stored once per model build; the footer memo reads it every keystroke. */
+	digest?: string;
 }
 
 export interface ChangesSnapshot {
@@ -63,7 +65,7 @@ const HAS_RENAME_BRACES = /\{[^{}]* => [^{}]*\}/;
 const RENAME_ARROW = " => ";
 
 export function emptyChanges(): ChangesModel {
-	return { files: [], added: 0, deleted: 0 };
+	return { files: [], added: 0, deleted: 0, digest: EMPTY_CHANGES_DIGEST };
 }
 
 function renamedPath(path: string): string {
@@ -124,9 +126,42 @@ export function changesModel(changed: ChangedFile[]): ChangesModel {
 		files,
 		added: files.reduce((total, file) => total + file.added, 0),
 		deleted: files.reduce((total, file) => total + file.deleted, 0),
+		digest: changesDigest({ files, added: 0, deleted: 0 }),
 	};
 }
 
+// The footer Status memo asks "did any change move?" on every keystroke, so
+// the answer must be O(1) to read: the model stores this digest once per
+// build (changesModel/emptyChanges) and consumers read the stored field.
+// It is a 64-bit FNV-1a roll over every per-file tuple the renderer consumes
+// (path, status, counts, diffRevision, countsUnavailable), so counts alone
+// cannot miss a same-count edit. A hash collision could only skip one
+// refresh until the next change moves the digest again -- it never renders a
+// wrong picture -- but it is a probabilistic signal, not an exact one.
+function fnv1a(hash: number, text: string): number {
+	for (let index = 0; index < text.length; index += 1) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 0x01000193);
+	}
+	return hash >>> 0;
+}
+
+const FNV_OFFSET_BASIS = 0x811c9dc5;
+const SECOND_SEED = 0x811c9dc5 ^ 0x9e3779b9;
+
+export function changesDigest(model: ChangesModel): string {
+	let first = FNV_OFFSET_BASIS;
+	let second = SECOND_SEED;
+	for (const file of model.files) {
+		const tuple = `\u0000${file.path}\u0000${file.status}\u0000${file.added}\u0000${file.deleted}\u0000${file.diffRevision ?? ""}\u0000${file.countsUnavailable ?? ""}`;
+		first = fnv1a(first, tuple);
+		second = fnv1a(second, tuple);
+	}
+	return `${first.toString(16).padStart(8, "0")}${second.toString(16).padStart(8, "0")}`;
+}
+
+const EMPTY_CHANGES_DIGEST = changesDigest({ files: [], added: 0, deleted: 0 });
+
 export function changesSummary(model: ChangesModel): string {
 	const noun = model.files.length === 1 ? "file" : "files";
 	return `${model.files.length} ${noun} · +${model.added} −${model.deleted}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}`;
@@ -134,19 +169,39 @@ export function changesSummary(model: ChangesModel): string {
 
 // One line: summary, the files joined by dots, and the command pushed to
 // the right edge. The file list goes first when the terminal is narrow.
+// The idle widget exists only while files are tracked. An unborn root (no
+// commits yet) is silence here: /gentle:changes explains the state on demand,
+// where the message has room and context.
+//
+// Both surfaces that paint it (the sidebar part and the below-input header
+// row) re-render every frame, so the paint is memoized per digest, width and
+// theme identity -- one stored frame, like CodemodeCard's cachedFrame. The
+// digest already rolls up every per-file detail the paint consumes (path,
+// status, counts, diffRevision, countsUnavailable), so a digest hit skips the
+// per-file join entirely; a digest-less (hand-built) model never caches, and
+// a new theme object repaints.
+type WidgetFrame = { digest: string; width: number; theme: ChangesTheme; lines: string[] };
+let widgetFrame: WidgetFrame | undefined;
+
 export function renderChangesWidget(model: ChangesModel, theme: ChangesTheme, width: number): string[] {
 	if (model.files.length === 0) return [];
+	if (model.digest !== undefined && widgetFrame?.digest === model.digest && widgetFrame.width === width && widgetFrame.theme === theme) return widgetFrame.lines;
 	const noun = model.files.length === 1 ? "file" : "files";
 	const dot = theme.fg("muted", "·");
 	const head = `${theme.fg("accent", WIDGET_GLYPH)} ${theme.fg("text", `${model.files.length} ${noun}`)} ${dot} ${theme.fg("success", `+${model.added}`)} ${theme.fg("error", `−${model.deleted}`)}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}`;
 	const hint = theme.fg("dim", CHANGES_COMMAND);
 	const list = model.files.map((file) => theme.fg("muted", file.path)).join(` ${dot} `);
 	const left = `${head} ${dot} ${list}`;
+	let lines: string[];
 	const gap = width - visibleWidth(left) - visibleWidth(hint);
-	if (gap >= 2) return [`${left}${" ".repeat(gap)}${hint}`];
-	const headGap = width - visibleWidth(head) - visibleWidth(hint);
-	if (headGap >= 2) return [`${head}${" ".repeat(headGap)}${hint}`];
-	return [truncateToWidth(head, width, "…")];
+	if (gap >= 2) lines = [`${left}${" ".repeat(gap)}${hint}`];
+	else {
+		const headGap = width - visibleWidth(head) - visibleWidth(hint);
+		lines = headGap >= 2 ? [`${head}${" ".repeat(headGap)}${hint}`] : [truncateToWidth(head, width, "…")];
+	}
+	if (model.digest === undefined) return lines;
+	widgetFrame = { digest: model.digest, width, theme, lines };
+	return lines;
 }
 
 export interface GitResult {
@@ -199,12 +254,24 @@ export async function foreignRootBranch(git: GitRunner): Promise<string | undefi
 	return verified.code === 0 ? branch : "no commits yet";
 }
 
+// A root whose HEAD is unborn (no commits yet) has no baseline: `git diff
+// HEAD` is meaningless and `git status` reports every file as untracked.
+// Worktree-holder folders -- repositories that exist only to parent linked
+// worktrees -- look exactly like this, and scanning them floods Changes with
+// thousands of phantom untracked files (the whole holder's contents). One
+// cheap verify answers "is there anything to diff against" before a scan.
+const HEAD_EXISTS_ARGS = ["rev-parse", "--verify", "-q", "HEAD"];
+
 // /gentle:changes: one group per registered root holding its working tree
 // against HEAD. A root whose Git fails (timed out, rejected) has no group but
 // is listed in failedRoots: a failed scan is never reported as a clean root.
+// A root with no commits has no group either, listed in unbornRoots: there is
+// nothing to track yet, and the bar says so instead of scanning the holder.
 export class WorktreeChangesTracker {
 	worktrees: WorktreeChanges[] = [];
 	failedRoots: string[] = [];
+	/** Registered roots whose HEAD is unborn: skipped, never scanned. */
+	unbornRoots: string[] = [];
 	scannedRootCount = 0;
 	private inFlight: Promise<ChangesModel> | undefined;
 	private readonly discover: GitRunner;
@@ -266,9 +333,17 @@ export class WorktreeChangesTracker {
 		const metadata = new Map((result.code === 0 ? parseWorktrees(result.stdout) : []).map((tree) => [tree.root, tree]));
 		// Roots scan in parallel so one slow root does not delay the others.
 		const failed: string[] = [];
+		const unborn: string[] = [];
 		const scanned = await Promise.all([...roots].map(async (root): Promise<WorktreeChanges | undefined> => {
 			const known = metadata.get(root);
 			try {
+				// Only an answered "no" means unborn: a rejected verify cannot tell
+				// unborn from broken Git, so the scan below still decides.
+				const head = await this.gitForRoot(root)(HEAD_EXISTS_ARGS).catch(() => undefined);
+				if (head && head.code !== 0) {
+					unborn.push(root);
+					return undefined;
+				}
 				const tracker = new ChangesTracker(this.gitForRoot(root), this.linesForRoot(root), this.revisionForRoot(root));
 				await tracker.start();
 				if (!tracker.statusRead) {
@@ -301,6 +376,7 @@ export class WorktreeChangesTracker {
 		if (latest.size !== roots.size || [...latest].some((root) => !roots.has(root))) return this.capture();
 		this.worktrees = trees;
 		this.failedRoots = failed;
+		this.unbornRoots = unborn;
 		this.scannedRootCount = roots.size;
 		return this.model;
 	}

package/lib/shell-gauge.ts

@@ -20,10 +20,38 @@ const GAUGE_EMPTY_ROLE = "border";
 const WARNING_THRESHOLD = 80;
 const ERROR_THRESHOLD = 95;
 
-export function renderGauge(percent: number | null, cells: number = GAUGE_CELLS): string {
+// Gauge-specific theme roles (issue #2222). Every field is optional and falls
+// back to the shared role the gauge painted with before gauge roles existed,
+// so themes without a gauge block render byte-identically to today.
+export interface GaugePaint {
+	/** Filled cells below the warning threshold; falls back to `accent`. */
+	ok?: string;
+	/** Filled cells from 80%; falls back to `warning`. */
+	warning?: string;
+	/** Filled cells from 95%; falls back to `error`. */
+	error?: string;
+	/** Empty cells; falls back to `border`. */
+	empty?: string;
+	/** Filled-cell glyph; falls back to `▰`. */
+	filled?: string;
+	/** Empty-cell glyph; falls back to `▱`. */
+	emptyGlyph?: string;
+}
+
+export interface GaugeGlyphs {
+	filled: string;
+	empty: string;
+}
+
+export function gaugeGlyphs(glyphs?: Partial<GaugeGlyphs>): GaugeGlyphs {
+	return { filled: glyphs?.filled ?? GAUGE_FILLED, empty: glyphs?.empty ?? GAUGE_EMPTY };
+}
+
+export function renderGauge(percent: number | null, cells: number = GAUGE_CELLS, glyphs?: Partial<GaugeGlyphs>): string {
 	const clamped = Math.max(0, Math.min(100, percent ?? 0));
 	const filled = Math.round((clamped / 100) * cells);
-	return GAUGE_FILLED.repeat(filled) + GAUGE_EMPTY.repeat(cells - filled);
+	const [filledGlyph, emptyGlyph] = [glyphs?.filled ?? GAUGE_FILLED, glyphs?.empty ?? GAUGE_EMPTY];
+	return filledGlyph.repeat(filled) + emptyGlyph.repeat(cells - filled);
 }
 
 export function gaugeTone(percent: number | null): GaugeTone {
@@ -33,8 +61,23 @@ export function gaugeTone(percent: number | null): GaugeTone {
 	return GAUGE_TONE.ACCENT;
 }
 
-export function paintGauge(percent: number | null, theme: GaugeTheme, cells: number = GAUGE_CELLS): string {
-	const gauge = renderGauge(percent, cells);
-	const filled = gauge.replace(new RegExp(`${GAUGE_EMPTY}+$`), "");
-	return theme.fg(gaugeTone(percent), filled) + theme.fg(GAUGE_EMPTY_ROLE, gauge.slice(filled.length));
+export function paintGauge(percent: number | null, theme: GaugeTheme, cells: number = GAUGE_CELLS, paint?: GaugePaint): string {
+	const glyphs = gaugeGlyphs(paint && { filled: paint.filled, empty: paint.emptyGlyph });
+	const gauge = renderGauge(percent, cells, glyphs);
+	const filled = stripTrailing(gauge, glyphs.empty);
+	// Token names go through theme.fg; raw ANSI prefixes (resolved from direct
+	// colors by gauge-theme.ts) paint directly, so the gauges alone recolor.
+	const isAnsi = (role: string | undefined): role is string => typeof role === "string" && role.startsWith("\x1b[");
+	const paintFg = (role: string | undefined, fallback: string, text: string): string => (isAnsi(role) ? `${role}${text}\x1b[39m` : theme.fg(role ?? fallback, text));
+	const tone = gaugeTone(percent);
+	const filledRole = tone === GAUGE_TONE.ACCENT ? paint?.ok : tone === GAUGE_TONE.WARNING ? paint?.warning : tone === GAUGE_TONE.ERROR ? paint?.error : undefined;
+	return paintFg(filledRole, tone, filled) + paintFg(paint?.empty, GAUGE_EMPTY_ROLE, gauge.slice(filled.length));
+}
+
+// Strips the maximal run of trailing empty glyphs without building a RegExp
+// from theme-authored strings, which could contain regex metacharacters.
+function stripTrailing(gauge: string, empty: string): string {
+	let end = gauge.length;
+	while (end >= empty.length && end > 0 && gauge.endsWith(empty, end)) end -= empty.length;
+	return gauge.slice(0, end);
 }

package/lib/shell-prompt.ts

@@ -23,10 +23,10 @@ const PETAL_TONE = {
 
 export type PetalTone = (typeof PETAL_TONE)[keyof typeof PETAL_TONE];
 
-// Keep Pi's original loader cadence while carrying the banner's reflected-light
-// language into the compact working labels. The highlight enters before the
-// word, crosses it as a soft symmetric wave, then exits before wrapping.
-export const SHELL_PULSE_MS = 80;
+// Render-driven animation (gentle-shell#994): the petal advances inside the
+// prompt's own frames while streaming, so the only timer left is a watchdog
+// that repaints silent working phases (long tool runs with no output).
+export const SHELL_PULSE_WATCHDOG_MS = 1000;
 export const SHELL_SCANNER_STEPS = 15;
 const SCANNER_ENTRY_OFFSET = 3;