gentle-pi 4.0.0 → 4.1.0

package/lib/shell-bar.ts

@@ -6,6 +6,8 @@ import { CARD_TONE, floatRows, panelInnerWidth, renderCard } from "./shell-card.
 import { REVIEW_SCOPE_UNAVAILABLE, REVIEW_SIDEBAR_LABELS, type ReviewSidebarSnapshot } from "./review-sidebar-state.ts";
 import type { VisualSettings } from "./visual-customization-policy.ts";
 import { renderChangesWidget, type ChangesModel } from "./shell-changes.ts";
+import type { RunningJobDisplay } from "./jobs-sidebar-state.ts";
+import { JOB_GLYPH } from "./background-jobs-tools.ts";
 
 type Presentation = Pick<VisualSettings, "density" | "visibility">;
 type HeaderPresentation = Presentation & Partial<Pick<VisualSettings, "headerPlacement" | "statusPlacement">>;
@@ -18,6 +20,7 @@ export { gaugeTone, renderGauge, type GaugeTone };
 
 export interface ShellBarModel {
 	review?: ReviewSidebarSnapshot;
+	jobs?: RunningJobDisplay[];
 	profile?: string;
 	changes?: { files: number; added: number; deleted: number; notice?: string };
 	cwd: string;
@@ -35,11 +38,10 @@ export interface ShellBarModel {
 }
 
 // The live header row above the fullscreen rail: session identity plus the
-// two counters that tick every frame (context, cost). Deliberately narrower
-// than ShellBarModel — extension statuses and the working/thinking state
-// never reach the header, so there is nothing on this type for them to leak
-// through.
+// live counters. Only the structured jobs count may join context/cost when
+// Status is absent; opaque extension statuses and working state stay excluded.
 export interface ShellHeaderModel {
+	jobs?: number;
 	cwd: string;
 	branch: string | null;
 	dirty: number | undefined;
@@ -55,9 +57,14 @@ export interface ShellHeaderModel {
 	usage: ProviderUsage | undefined;
 }
 
-export function buildShellHeaderModel(model: ShellBarModel): ShellHeaderModel {
+export function buildShellHeaderModel(model: ShellBarModel, showJobs = false): ShellHeaderModel {
 	const { cwd, branch, dirty, modelId, effort, profile, contextPercent, costTotal, subscription, usage } = model;
-	return { cwd, branch, dirty, modelId, effort, profile, contextPercent, costTotal, subscription, usage };
+	return { cwd, branch, dirty, modelId, effort, profile, contextPercent, costTotal, subscription, usage,
+		...(showJobs && model.jobs?.length ? { jobs: model.jobs.length } : {}) };
+}
+
+export function shellJobsCount(count: number): string {
+	return `${JOB_GLYPH} ${count} job${count === 1 ? "" : "s"}`;
 }
 
 /** A column span (`[start, end)`, in the rendered line's visible columns) a click must land in to hit the usage segment. */
@@ -110,6 +117,13 @@ export function shellEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
 	return !(value === "0" || value === "false" || value === "off");
 }
 
+// Herdr's native Pi detection matches Pi's standard loader row ("⠋ Working...").
+// Inside a Herdr pane keep that row, which Pi shows only during real activity,
+// so detection works without a local manifest override.
+export function keepNativeWorkingRow(env: NodeJS.ProcessEnv = process.env): boolean {
+	return env.HERDR_ENV === "1" && env.GENTLE_PI_AGENTS_CHILD !== "1";
+}
+
 export function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
 	if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
@@ -166,6 +180,7 @@ function buildSegments(model: ShellBarModel, theme: ShellBarTheme, presentation?
 		location,
 		...(presentation?.visibility.modelDetails === false ? [] : [modelSegment]),
 		...(presentation?.visibility.usageCost === false ? [] : [context, cost, ...(usage ? [usage] : [])]),
+		...(model.jobs?.length ? [theme.fg(ROLE.STATUS, shellJobsCount(model.jobs.length))] : []),
 		...statuses,
 	];
 }
@@ -237,6 +252,10 @@ export function renderShellSidebarBar(model: ShellBarModel, theme: ShellBarTheme
 				...(model.review.scope !== REVIEW_SCOPE_UNAVAILABLE ? [label(sanitizeStatus(model.review.scope))] : []),
 			],
 		}] : []),
+		...(model.jobs?.length ? [{
+			title: "Jobs",
+			lines: [...model.jobs].sort((a, b) => b.startedAt - a.startedAt).map((job) => value(sanitizeStatus(job.label))),
+		}] : []),
 		{ title: "Integrations", lines: model.statuses.length
 			? model.statuses.map((status) => theme.fg(ROLE.STATUS, sanitizeStatus(status)))
 			: [label("No status reported")] },
@@ -360,7 +379,11 @@ export function shellHeaderUsageHit(chrome: ShellHeaderChrome, x: number, y: num
 
 function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: number, usageHint?: string, presentation?: Presentation): ShellHeaderResult {
 	const targetWidth = Math.max(0, Math.floor(width));
-	const ctxCost = joinSegments([contextSegment(model.contextPercent, theme), costSegment(model.costTotal, model.subscription, theme)], theme);
+	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)]),
+	], theme);
 	const windows = model.usage ? (selectUsageLimit(model.usage, model.modelId)?.windows ?? []) : [];
 	const leftStages = headerLeftStages(model, theme, presentation?.visibility.modelDetails !== false)
 		.map((stage) => presentation?.density === "minimal" ? stage.slice(1) : stage);
@@ -381,7 +404,7 @@ function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: num
 	];
 	for (const { leftIndex, usageStage } of attempts) {
 		const usageText = usageStage ? usageSegmentText(windows, theme, usageStage, usageHint) : undefined;
-		const right = presentation?.visibility.usageCost === false ? "" : usageText ? joinSegments([ctxCost, usageText], theme) : ctxCost;
+		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;
 		const text = left + " ".repeat(targetWidth - visibleWidth(left) - visibleWidth(right)) + right;
@@ -390,6 +413,10 @@ function headerContent(model: ShellHeaderModel, theme: ShellBarTheme, width: num
 		return { text, usageSpan: { start: usageStart, end: usageStart + visibleWidth(usageText) } };
 	}
 	const brand = presentation?.density === "minimal" ? "" : theme.fg(ROLE.BRAND, theme.bold(HEADER_BRAND));
+	if (jobs && visibleWidth(jobs) <= targetWidth) {
+		const left = visibleWidth(brand) + RIGHT_PADDING + visibleWidth(jobs) <= targetWidth ? brand : "";
+		return { text: left + " ".repeat(targetWidth - visibleWidth(left) - visibleWidth(jobs)) + jobs };
+	}
 	return { text: visibleWidth(brand) <= targetWidth ? brand : "" };
 }
 
@@ -399,11 +426,14 @@ export function renderShellBelowInputFloat(model: ShellBarModel, theme: ShellBar
 	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), theme, targetWidth, usageHint, presentation);
+	const chrome = renderShellHeaderChrome(buildShellHeaderModel(model, presentation.statusPlacement === "hidden"), theme, targetWidth, usageHint, presentation);
 	const changesRow = changes?.files.length && presentation.visibility.changes !== false
 		? floatHeaderRow(theme, targetWidth, (inner) => renderChangesWidget(changes, theme, inner)[0] ?? "")
 		: undefined;
-	const statuses = presentation.statusPlacement === "hidden" ? [] : model.statuses.map(sanitizeStatus).filter(Boolean);
+	const statuses = presentation.statusPlacement === "hidden" ? [] : [
+		...(model.jobs?.length ? [shellJobsCount(model.jobs.length)] : []),
+		...model.statuses.map(sanitizeStatus).filter(Boolean),
+	];
 	const statusRow = statuses.length
 		? floatHeaderRow(theme, targetWidth, () => joinSegments(statuses.map((status) => theme.fg(ROLE.STATUS, status)), theme))
 		: undefined;
@@ -429,7 +459,7 @@ export function renderShellBelowInputFloat(model: ShellBarModel, theme: ShellBar
 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);
 	if (grouped) return grouped.rows;
-	const headerModel = buildShellHeaderModel(model);
+	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 statuses = model.statuses.map(sanitizeStatus).filter((status) => status.length > 0).map((status) => theme.fg(ROLE.STATUS, status));

package/lib/shell-changes-view.ts

@@ -1,7 +1,7 @@
 import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { sanitizeTerminalText } from "./terminal-theme.ts";
-import { basename } from "node:path";
-import { CHANGE_STATUS, changesSummary, type ChangedFile, type ChangesModel, type WorktreeChanges } from "./shell-changes.ts";
+import { basename, posix } from "node:path";
+import { CHANGE_STATUS, DIFF_TOO_LARGE, changesSummary, type ChangedFile, type ChangesModel, type WorktreeChanges } from "./shell-changes.ts";
 import { paintHoverable } from "./shell-hover.ts";
 
 // Gentle Shell changes overlay: a framed two-pane view with the working
@@ -37,7 +37,7 @@ const ROLE = {
 } as const;
 
 const HEADER_PREFIXES = ["diff --git", "index ", "--- ", "+++ ", "new file mode", "deleted file mode", "similarity index", "rename from", "rename to", "Binary files"];
-const LIST_MAX_WIDTH = 36;
+const LIST_MAX_WIDTH = 48;
 const LIST_RATIO = 0.35;
 const CHROME_ROWS = 3;
 const MIN_BODY_ROWS = 1;
@@ -80,8 +80,32 @@ function fileCounts(file: ChangedFile, theme: ChangesViewTheme): string {
 	return `${theme.fg(ROLE.ADDED, `+${file.added}`)} ${theme.fg(ROLE.REMOVED, `-${file.deleted}`)}`;
 }
 
+// The name leads and the directory trails, so a narrow list clips the
+// directory instead of the part that identifies the file.
 function fileLabel(file: ChangedFile, theme: ChangesViewTheme, hovered: boolean, idleRole: string): string {
-	return `${paintHoverable(theme, `${FILE_STATUS[file.status]} ${displayText(file.path)}`, hovered, idleRole)}  ${fileCounts(file, theme)}`;
+	const directory = posix.dirname(file.path.replace(/\\/g, "/"));
+	const label = `${paintHoverable(theme, `${FILE_STATUS[file.status]} ${displayText(posix.basename(file.path.replace(/\\/g, "/")))}`, hovered, idleRole)}  ${fileCounts(file, theme)}`;
+	return directory === "." ? label : `${label}  ${theme.fg(ROLE.EMPTY, displayText(directory))}`;
+}
+
+// The diff pane's first row: the selected file's full path, clipped from the
+// left so the file name always stays visible.
+const PATH_HEADER_ROWS = 1;
+
+function pathHeader(file: ChangedFile, theme: ChangesViewTheme, width: number): string {
+	const status = `${FILE_STATUS[file.status]} `;
+	let path = displayText(file.path);
+	const room = Math.max(1, width - visibleWidth(status));
+	if (visibleWidth(path) > room) {
+		const characters = [...path];
+		while (characters.length > 0 && visibleWidth(`…${characters.join("")}`) > room) characters.shift();
+		path = `…${characters.join("")}`;
+	}
+	return theme.fg(ROLE.SELECTED, status + path);
+}
+
+function diffRows(bodyRows: number): number {
+	return Math.max(MIN_BODY_ROWS, bodyRows - PATH_HEADER_ROWS);
 }
 
 function fit(text: string, width: number): string {
@@ -90,10 +114,11 @@ function fit(text: string, width: number): string {
 }
 
 // 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, rightLines: string[], keys: string): string[] {
+function renderPanes(width: number, rows: number, theme: ChangesViewTheme, title: string, leftLine: (row: number) => string, diffLines: string[], keys: string, headerFile?: ChangedFile): string[] {
 	const inner = Math.max(8, width - 2);
 	const listWidth = Math.min(LIST_MAX_WIDTH, Math.floor(inner * LIST_RATIO));
 	const diffWidth = inner - listWidth - 4;
+	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[] = [];
@@ -292,7 +317,7 @@ export class WorktreeChangesView {
 		};
 		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);
+		return renderPanes(width, height, theme, `✎ Changes · ${this.trees.length} worktrees`, leftLine, preview, keys, selected?.file);
 	}
 
 	invalidate(): void {
@@ -406,8 +431,8 @@ export class ChangesView {
 		// the scroll keys are checked before the open key; a real Enter is CR.
 		if (data === "j" || matchesKey(data, Key.down)) this.select(this.selected + 1);
 		else if (data === "k" || matchesKey(data, Key.up)) this.select(this.selected - 1);
-		else if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.ctrl("j"))) this.scrollBy(this.bodyRows());
-		else if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("k"))) this.scrollBy(-this.bodyRows());
+		else if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.ctrl("j"))) this.scrollBy(diffRows(this.bodyRows()));
+		else if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("k"))) this.scrollBy(-diffRows(this.bodyRows()));
 		else if (data === "o" || matchesKey(data, Key.enter)) {
 			const file = this.model.files[this.selected];
 			if (file) this.deps.onOpen(file);
@@ -464,7 +489,7 @@ export class ChangesView {
 		this.fileScroll = this.clampFileScroll(this.fileScroll, rows);
 		const keys = KEYS.map(([key, label]) => `${theme.fg(ROLE.KEY, key)} ${theme.fg(ROLE.KEY_TEXT, key === "esc" ? (this.deps.backLabel ?? label) : label)}`).join("   ");
 		this.pointerLayout = pointerLayout(width, rows);
-		return renderPanes(width, rows, theme, `✎ Changes · ${changesSummary(this.model)}`, (row) => this.fileLine(row), this.visibleDiff(rows), keys);
+		return renderPanes(width, rows, theme, `✎ Changes · ${changesSummary(this.model)}`, (row) => this.fileLine(row), this.visibleDiff(rows), keys, this.model.files[this.selected]);
 	}
 
 	invalidate(): void {
@@ -500,8 +525,9 @@ export class ChangesView {
 		const lines = this.diffs.get(file.path);
 		if (!lines) return [];
 		if (lines.length === 0) return [this.deps.theme.fg(ROLE.EMPTY, EMPTY_DIFF)];
-		this.diffScroll = Math.min(this.diffScroll, Math.max(0, lines.length - rows));
-		return lines.slice(this.diffScroll, this.diffScroll + rows);
+		const visible = diffRows(rows);
+		this.diffScroll = Math.min(this.diffScroll, Math.max(0, lines.length - visible));
+		return lines.slice(this.diffScroll, this.diffScroll + visible);
 	}
 
 	private select(index: number): void {
@@ -534,7 +560,7 @@ export class ChangesView {
 		const file = this.model.files[this.selected];
 		const lines = file ? this.diffs.get(file.path) : undefined;
 		if (!lines) return false;
-		const next = Math.max(0, Math.min(Math.max(0, lines.length - rows), this.diffScroll + Math.trunc(delta)));
+		const next = Math.max(0, Math.min(Math.max(0, lines.length - diffRows(rows)), this.diffScroll + Math.trunc(delta)));
 		if (next === this.diffScroll) return false;
 		this.diffScroll = next;
 		return true;
@@ -557,7 +583,8 @@ export class ChangesView {
 		void this.deps.loadDiff(file).then(
 			(text) => {
 				if (this.disposed) return;
-				this.diffs.set(file.path, colorDiff(text, this.deps.theme));
+				// An oversized diff arrives as one plain line pointing at the editor.
+				this.diffs.set(file.path, text === DIFF_TOO_LARGE ? [this.deps.theme.fg(ROLE.EMPTY, text)] : colorDiff(text, this.deps.theme));
 				this.deps.requestRender();
 			},
 			() => {

package/lib/shell-changes.ts

@@ -27,7 +27,6 @@ export interface ChangesModel {
 	files: ChangedFile[];
 	added: number;
 	deleted: number;
-	notice?: string;
 }
 
 export interface ChangesSnapshot {
@@ -46,6 +45,11 @@ interface NumstatEntry {
 }
 
 export const CHANGES_COMMAND = "/gentle:changes";
+// One selected file's diff is the only bounded thing in Changes: past either
+// limit the panel shows DIFF_TOO_LARGE instead of buffering and coloring it.
+export const DIFF_MAX_BYTES = 1024 * 1024;
+export const DIFF_MAX_LINES = 20_000;
+export const DIFF_TOO_LARGE = "Diff too large — press o to open in editor.";
 const WIDGET_GLYPH = "✎";
 const STATUS_BY_CODE: Record<string, ChangeStatus> = {
 	A: CHANGE_STATUS.ADDED,
@@ -123,7 +127,7 @@ export function changesModel(changed: ChangedFile[]): ChangesModel {
 
 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" : ""}${model.notice ? " · capture limit reached" : ""}`;
+	return `${model.files.length} ${noun} · +${model.added} −${model.deleted}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}`;
 }
 
 // One line: summary, the files joined by dots, and the command pushed to
@@ -132,7 +136,7 @@ export function renderChangesWidget(model: ChangesModel, theme: ChangesTheme, wi
 	if (model.files.length === 0) return [];
 	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" : ""}${model.notice ? ` ${dot} ${theme.fg("warning", "capture limit reached")}` : ""}`;
+	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}`;
@@ -146,10 +150,14 @@ export function renderChangesWidget(model: ChangesModel, theme: ChangesTheme, wi
 export interface GitResult {
 	stdout: string;
 	code: number;
+	/** The runner stopped reading at its output bound; stdout is partial. */
+	truncated?: boolean;
 }
 
 export type GitRunner = (args: string[]) => Promise<GitResult>;
 export type LineCounter = (path: string) => Promise<number>;
+/** A cheap content identity (e.g. size and mtime) so same-count edits refresh their diff. */
+export type FileRevision = (path: string) => Promise<string | undefined>;
 
 export interface WorktreeChanges {
 	root: string;
@@ -189,76 +197,41 @@ export async function foreignRootBranch(git: GitRunner): Promise<string | undefi
 	return verified.code === 0 ? branch : "no commits yet";
 }
 
-// The session-evidence tracker behind /gentle:changes records roots, never
-// branches, so the overlay would label every tree "detached". This resolves
-// each root's own HEAD state once (branch, "no commits yet", undefined for a
-// real detached HEAD, or UNKNOWN_BRANCH when the root could not even be
-// asked), decorates the trees from the cache, and tells the caller when a
-// fresh answer arrived so the view can repaint. Git is touched only while the
-// overlay is open, never at startup or on evidence refresh.
-export class RootBranchLabels {
-	private readonly labels = new Map<string, string | undefined>();
-	private readonly pending = new Map<string, Promise<void>>();
-	private readonly gitForRoot: (root: string) => GitRunner;
-	private readonly onChange: () => void;
-	constructor(gitForRoot: (root: string) => GitRunner, onChange: () => void = () => {}) {
-		this.gitForRoot = gitForRoot;
-		this.onChange = onChange;
-	}
-
-	decorate(trees: readonly WorktreeChanges[]): WorktreeChanges[] {
-		return trees.map((tree) => {
-			if (tree.branch !== undefined) return tree;
-			if (!this.labels.has(tree.root)) this.resolve(tree.root);
-			const branch = this.labels.get(tree.root);
-			return branch === undefined ? tree : { ...tree, branch };
-		});
-	}
-
-	/** Every in-flight resolution has finished. */
-	async settled(): Promise<void> {
-		while (this.pending.size) await Promise.all(this.pending.values());
-	}
-
-	private resolve(root: string): void {
-		if (this.pending.has(root)) return;
-		// A rejection here means the root could not even be asked -- distinct
-		// from foreignRootBranch resolving to undefined, which means git
-		// answered and there really is no branch (a real detached HEAD).
-		const task = foreignRootBranch(this.gitForRoot(root))
-			.then(
-				(branch) => branch,
-				() => UNKNOWN_BRANCH,
-			)
-			.then((branch) => {
-				this.labels.set(root, branch);
-				this.pending.delete(root);
-				this.onChange();
-			});
-		this.pending.set(root, task);
-	}
-}
-
+// /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.
 export class WorktreeChangesTracker {
 	worktrees: WorktreeChanges[] = [];
+	failedRoots: string[] = [];
+	scannedRootCount = 0;
 	private inFlight: Promise<ChangesModel> | undefined;
 	private readonly discover: GitRunner;
 	private readonly gitForRoot: (root: string) => GitRunner;
 	private readonly linesForRoot: (root: string) => LineCounter;
 	private readonly registeredRoots: () => readonly string[];
+	private readonly revisionForRoot: (root: string) => FileRevision | undefined;
 
-	constructor(discover: GitRunner, gitForRoot: (root: string) => GitRunner, linesForRoot: (root: string) => LineCounter = () => noLines, registeredRoots: () => readonly string[] = () => []) {
+	constructor(discover: GitRunner, gitForRoot: (root: string) => GitRunner, linesForRoot: (root: string) => LineCounter = () => noLines, registeredRoots: () => readonly string[] = () => [], revisionForRoot: (root: string) => FileRevision | undefined = () => undefined) {
 		this.discover = discover;
 		this.gitForRoot = gitForRoot;
 		this.linesForRoot = linesForRoot;
 		this.registeredRoots = registeredRoots;
+		this.revisionForRoot = revisionForRoot;
 	}
 
+	private modelOf: WorktreeChanges[] | undefined;
+	private combined: ChangesModel = emptyChanges();
+
+	// Footers read this every frame; rebuild only when a scan replaced the trees.
 	get model(): ChangesModel {
-		return changesModel(this.worktrees.flatMap((tree) => tree.model.files.map((file) => ({
-			...file,
-			path: this.worktrees.length === 1 ? file.path : `${tree.root}/${file.path}`,
-		}))));
+		if (this.modelOf !== this.worktrees) {
+			this.modelOf = this.worktrees;
+			this.combined = changesModel(this.worktrees.flatMap((tree) => tree.model.files.map((file) => ({
+				...file,
+				path: this.worktrees.length === 1 ? file.path : `${tree.root}/${file.path}`,
+			}))));
+		}
+		return this.combined;
 	}
 
 	async start(): Promise<void> {
@@ -278,17 +251,29 @@ export class WorktreeChangesTracker {
 	}
 
 	private async capture(): Promise<ChangesModel> {
-		const result = await this.discover(["worktree", "list", "--porcelain", "-z"]).catch(() => ({ code: 128, stdout: "" }));
-		const trees: WorktreeChanges[] = [];
-		const metadata = new Map((result.code === 0 ? parseWorktrees(result.stdout) : []).map((tree) => [tree.root, tree]));
 		// Discovery labels registered roots; it never grants visibility to siblings.
 		const roots = new Set(this.registeredRoots());
-		for (const root of roots) {
+		// No root to scan means no Git at all, not even branch discovery.
+		if (roots.size === 0) {
+			this.worktrees = [];
+			this.failedRoots = [];
+			this.scannedRootCount = 0;
+			return this.model;
+		}
+		const result = await this.discover(["worktree", "list", "--porcelain", "-z"]).catch(() => ({ code: 128, stdout: "" }));
+		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 scanned = await Promise.all([...roots].map(async (root): Promise<WorktreeChanges | undefined> => {
 			const known = metadata.get(root);
 			try {
-				const tracker = new ChangesTracker(this.gitForRoot(root), this.linesForRoot(root));
+				const tracker = new ChangesTracker(this.gitForRoot(root), this.linesForRoot(root), this.revisionForRoot(root));
 				await tracker.start();
-				if (!tracker.model.files.length) continue;
+				if (!tracker.statusRead) {
+					failed.push(root);
+					return undefined;
+				}
+				if (!tracker.model.files.length) return undefined;
 				// A root missing from this discovery scan belongs to a different Git
 				// clone entirely (e.g. an inner repository nested inside an outer
 				// one) -- worktree list can never describe a foreign clone, so ask
@@ -299,22 +284,40 @@ export class WorktreeChangesTracker {
 				// change scan above failing -- that must label the root
 				// UNKNOWN_BRANCH, not drop real, already-captured changes.
 				const branch = known ? known.branch : await foreignRootBranch(this.gitForRoot(root)).catch(() => UNKNOWN_BRANCH);
-				trees.push({ root, ...(branch ? { branch } : {}), model: tracker.model });
+				return { root, ...(branch ? { branch } : {}), model: tracker.model };
 			} catch {
-				// Linked roots can disappear between discovery and status.
+				// A root the caller stops registering mid-scan (e.g. a removed
+				// worktree) triggers the rescan below without it, not a failure.
+				failed.push(root);
+				return undefined;
 			}
-		}
+		}));
+		const trees = scanned.filter((tree): tree is WorktreeChanges => tree !== undefined);
 		const latest = new Set(this.registeredRoots());
 		// A root admitted during status must not wait for a later poll (which may
 		// be disabled). Ordinary overlapping polls still share exactly one scan.
 		if (latest.size !== roots.size || [...latest].some((root) => !roots.has(root))) return this.capture();
 		this.worktrees = trees;
+		this.failedRoots = failed;
+		this.scannedRootCount = roots.size;
 		return this.model;
 	}
 }
 
 const noLines: LineCounter = async () => 0;
 
+// Per-file line counts and revision lookups are file IO: a large change set
+// runs this many files at a time instead of one by one or all at once.
+export const FILE_WORK_CONCURRENCY = 8;
+
+async function eachLimited<T>(items: readonly T[], limit: number, work: (item: T) => Promise<void>): Promise<void> {
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) await work(items[next++]);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+
 const NUMSTAT_ARGS = ["diff", "--numstat", "HEAD"];
 const PORCELAIN_ARGS = ["status", "--porcelain=v1", "--untracked-files=all", "-z"];
 
@@ -324,20 +327,27 @@ const PORCELAIN_ARGS = ["status", "--porcelain=v1", "--untracked-files=all", "-z
 export class ChangesTracker {
 	private readonly git: GitRunner;
 	private readonly countLines: LineCounter;
+	private readonly revision: FileRevision | undefined;
 	private current: ChangesModel = emptyChanges();
 	private available = false;
 	private inFlight: Promise<ChangesModel> | undefined;
 	private queued = false;
 
-	constructor(git: GitRunner, countLines: LineCounter = noLines) {
+	constructor(git: GitRunner, countLines: LineCounter = noLines, revision?: FileRevision) {
 		this.git = git;
 		this.countLines = countLines;
+		this.revision = revision;
 	}
 
 	get model(): ChangesModel {
 		return this.current;
 	}
 
+	/** False when the last start could not read `git status`. */
+	get statusRead(): boolean {
+		return this.available;
+	}
+
 	async start(): Promise<void> {
 		const files = await this.capture();
 		this.available = files !== undefined;
@@ -372,9 +382,14 @@ export class ChangesTracker {
 		if (porcelain.code !== 0) return undefined;
 		const files = snapshotChanges({ numstat: numstat.stdout, porcelain: porcelain.stdout });
 		// Untracked files never appear in numstat; count their lines directly.
-		for (const file of files) {
-			if (file.status === CHANGE_STATUS.UNTRACKED) file.added = await this.countLines(file.path).catch(() => 0);
-		}
+		await eachLimited(files, FILE_WORK_CONCURRENCY, async (file) => {
+			const [added, revision] = await Promise.all([
+				file.status === CHANGE_STATUS.UNTRACKED ? this.countLines(file.path).catch(() => 0) : undefined,
+				this.revision?.(file.path).catch(() => undefined),
+			]);
+			if (added !== undefined) file.added = added;
+			if (revision) file.diffRevision = revision;
+		});
 		return files;
 	}
 }

package/lib/shell-sidebar-layout.ts

@@ -179,6 +179,10 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme, placement: () =>
 	};
 	scroll.handleMouse = (event) => {
 		if (event.type === "wheel") {
+			// A bounded section (Todo) owns its inner viewport. Only wheel
+			// events it declines should move the surrounding rail.
+			const sectionResult = dispatchPartMouse(event);
+			if (sectionResult?.handled) return sectionResult;
 			// Consume even at the boundary or over blank rail space: Pi 0.85.1
 			// can send unconsumed delta to the primary transcript despite containment.
 			scroll.scrollBy(event.wheelDelta ?? 0);
@@ -375,7 +379,7 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme, placement: () =>
 		stopped = true;
 		state.active = false;
 		clearInterval(timer);
-		scroll.hideTransientScrollbar();
+		scroll.setScrollbar("hidden");
 		for (const cleanup of cleanups.reverse()) cleanup();
 		tui.requestRender();
 	};