gentle-pi 4.0.0 → 4.2.0

package/tests/shell-changes-view.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { TuiAltScreen, visibleWidth, type Terminal, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { CHANGE_STATUS, changesModel, type ChangedFile } from "../lib/shell-changes.ts";
+import { CHANGE_STATUS, DIFF_TOO_LARGE, changesModel, type ChangedFile } from "../lib/shell-changes.ts";
 import { WorktreeChangesView, ChangesView, colorDiff, type ChangesViewDeps } from "../lib/shell-changes-view.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 
@@ -106,8 +106,8 @@ test("worktree accordion keeps groups and nested files beside a framed lazy diff
 	const lines = component.render(100);
 	assert.equal(lines.length, 10);
 	assert.match(lines[0], /^╭─ ✎ Changes/);
-	assert.match(lines[1], /^│   ▾ main · main +│ \+\/main:same.ts +│$/);
-	assert.match(lines[2], /^│ ▸   M same.ts +\+1 -0 +│/);
+	assert.match(lines[1], /^│   ▾ main · main +│ M same.ts +│$/);
+	assert.match(lines[2], /^│ ▸   M same.ts +\+1 -0 +│ \+\/main:same.ts +│$/);
 	assert.match(lines[3], /^│   ▸ detached · linked +│/);
 	assert.match(lines[9], /^╰─+╯$/);
 	for (const line of lines) assert.equal(visibleWidth(line), 100);
@@ -131,6 +131,34 @@ test("worktree accordion keeps groups and nested files beside a framed lazy diff
 	assert.equal(closed, 1);
 });
 
+// Long paths were clipped to `tools/linkedin-automation/scr…`, hiding the file
+// name. Rows lead with the name and trail the directory; the diff pane shows
+// the full path, clipped from the left so the name always survives.
+test("changes rows lead with the file name and the diff pane shows the full path", async () => {
+	const path = "tools/linkedin-automation/scripts/connect.mjs";
+	const trees = [{ root: "/main", branch: "feat/linkedin", model: changesModel([file(path, 214, 0, CHANGE_STATUS.ADDED)]) }];
+	const component = new WorktreeChangesView(trees, {
+		theme: plainTheme, rows: 10,
+		loadDiff: async () => "@@ -0,0 +1,1 @@\n+# Scheduled",
+		onOpen: () => {}, onClose: () => {}, requestRender() {}, onRefresh() {},
+	});
+	component.handleInput("\r");
+	component.handleInput("j");
+	await settle();
+	const lines = component.render(120);
+	assert.match(lines[2]!, /^│ ▸   A connect\.mjs  \+214 -0  tools/, "the file name leads the row");
+	assert.match(lines[1]!, /│ A tools\/linkedin-automation\/scripts\/connect\.mjs +│$/, "the diff pane starts with the full path");
+	assert.match(lines[2]!, /│ @@ -0,0 \+1,1 @@ +│$/, "the diff follows the path line");
+	assert.match(component.render(70)[1]!, /│ A …[^│]*\/connect\.mjs *│$/, "a narrow pane clips the path from the left");
+
+	const standalone = view({ loadDiff: async () => "+x" }, [file(path, 1, 0, CHANGE_STATUS.ADDED)]).view;
+	await settle();
+	const single = standalone.render(120);
+	assert.match(single[1]!, /│ ▸ A connect\.mjs  \+1 -0  tools/);
+	assert.match(single[1]!, /│ A tools\/linkedin-automation\/scripts\/connect\.mjs +│$/);
+	assert.match(single[2]!, /│ \+x +│$/);
+});
+
 test("worktree accordion selects a clicked file without opening its editor", () => {
 	const opened: string[] = [];
 	const component = new WorktreeChangesView([{ root: "/main", branch: "main", model: changesModel([file("a.ts", 1, 0), file("b.ts", 1, 0)]) }], {
@@ -147,9 +175,10 @@ test("worktree accordion selects a clicked file without opening its editor", ()
 
 test("worktree accordion receives native fullscreen press and release as a file click", async () => {
 	let onInput: ((data: string) => void) | undefined;
-	const terminal: Terminal = {
-		start(input) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 8; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {},
+	const terminalFixture = {
+		start(input: Parameters<Terminal["start"]>[0]) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 8; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {}, setProgramStatus() {},
 	};
+	const terminal: Terminal = terminalFixture;
 	const opened: string[] = [];
 	const component = new WorktreeChangesView([{ root: "/main", branch: "main", model: changesModel([file("a.ts", 1, 0), file("b.ts", 1, 0)]) }], {
 		theme: plainTheme, rows: 8, loadDiff: async () => "+preview",
@@ -297,9 +326,10 @@ test("non-left gestures pass through with current, stale, and missing layouts in
 test("right press reaches the native Windows paste fallback when eligible", () => {
 	let onInput: ((data: string) => void) | undefined;
 	let pasted = 0;
-	const terminal: Terminal = {
-		start(input) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 12; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {},
+	const terminalFixture = {
+		start(input: Parameters<Terminal["start"]>[0]) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 12; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {}, setProgramStatus() {},
 	};
+	const terminal: Terminal = terminalFixture;
 	const { view: component } = view();
 	const tui = new TuiAltScreen(terminal, false, undefined, { mouse: true, onRightClickPaste: () => { pasted++; } });
 	const platform = Object.getOwnPropertyDescriptor(process, "platform")!;
@@ -413,9 +443,10 @@ test("accordion selection scrolls flattened rows and diff scrolling does not ope
 	await settle();
 	assert.match(component.render(100).join("\n"), /▸   M file-19.ts/);
 	component.handleInput("\x0a");
-	assert.match(component.render(100)[1], /\+line 5/);
+	assert.match(component.render(100)[1], /M file-19\.ts/, "the path line stays fixed while the diff scrolls");
+	assert.match(component.render(100)[2], /\+line 4/, "a page is the diff rows below the path line");
 	component.handleInput("\x0b");
-	assert.match(component.render(100)[1], /\+line 0/);
+	assert.match(component.render(100)[2], /\+line 0/);
 	assert.equal(opened, 0);
 	for (const width of [1, 8, 20, 40, 100]) {
 		for (const line of component.render(width)) assert.ok(visibleWidth(line) <= width);
@@ -502,8 +533,9 @@ test("ChangesView renders a framed two-pane layout at the requested size", async
 	for (const line of lines) assert.equal(visibleWidth(line), 80, `"${stripAnsi(line)}" is not 80 wide`);
 	const plain = lines.map(stripAnsi);
 	assert.match(plain[0], /^╭─ ✎ Changes · 2 files · \+12 −1 ─+╮$/);
-	assert.match(plain[1], /^│ ▸ M lib\/a\.ts +\+2 -1 +│ @@ -1,2 \+1,3 @@ +│$/);
-	assert.match(plain[2], /^│   A lib\/b\.ts +\+10 -0 +│  const a = 1; +│$/);
+	assert.match(plain[1], /^│ ▸ M a\.ts  \+2 -1  lib +│ M lib\/a\.ts +│$/);
+	assert.match(plain[2], /^│   A b\.ts  \+10 -0  lib +│ @@ -1,2 \+1,3 @@ +│$/);
+	assert.match(plain[3], /^│ +│  const a = 1; +│$/);
 	assert.match(plain[11], /^╰─+╯$/);
 	assert.match(plain[10], /j\/k file .* o open in editor .* esc close/);
 });
@@ -532,8 +564,9 @@ test("ChangesView renders tabbed CRLF modified diffs with aligned frame columns"
 		assert.ok(!line.includes("\t"), "raw tab must not leak into rendered line");
 	}
 	const plain = lines.map(stripAnsi);
-	assert.match(plain[1], /^│ ▸ M lib\/a\.ts +\+2 -1 +│ @@ -1,2 \+1,3 @@ +│$/);
-	assert.match(plain[2], /^│   A lib\/b\.ts +\+10 -0 +│ +const a = 1; +│$/);
+	assert.match(plain[1], /^│ ▸ M a\.ts  \+2 -1  lib +│ M lib\/a\.ts +│$/);
+	assert.match(plain[2], /^│   A b\.ts  \+10 -0  lib +│ @@ -1,2 \+1,3 @@ +│$/);
+	assert.match(plain[3], /^│ +│ +const a = 1; +│$/);
 });
 
 test("ChangesView loads the selected diff lazily and moves with j/k and arrows", async () => {
@@ -543,11 +576,11 @@ test("ChangesView loads the selected diff lazily and moves with j/k and arrows",
 	component.handleInput("j");
 	await settle();
 	assert.deepEqual(calls, ["lib/a.ts", "lib/b.ts"]);
-	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A lib\/b\.ts/);
+	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A b\.ts/);
 	component.handleInput("\x1b[A");
-	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M lib\/a\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M a\.ts/);
 	component.handleInput("k");
-	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M lib\/a\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M a\.ts/);
 	assert.ok(events.filter((event) => event === "render").length >= 2);
 });
 
@@ -557,16 +590,33 @@ test("ChangesView scrolls the diff pane and shows an empty state for files witho
 	await settle();
 	component.handleInput("\x1b[6~");
 	const plain = component.render(80).map(stripAnsi);
-	assert.doesNotMatch(plain[1], /@@/);
-	assert.match(plain[1], /\+line \d+/);
+	assert.doesNotMatch(plain[2], /@@/);
+	assert.match(plain[2], /\+line \d+/);
 	component.handleInput("\x0b");
-	assert.match(stripAnsi(component.render(80)[1]), /@@/, "ctrl+k scrolls back to the top");
+	assert.match(stripAnsi(component.render(80)[2]), /@@/, "ctrl+k scrolls back to the top");
 	component.handleInput("\x0a");
-	assert.doesNotMatch(stripAnsi(component.render(80)[1]), /@@/, "ctrl+j scrolls a page down");
+	assert.doesNotMatch(stripAnsi(component.render(80)[2]), /@@/, "ctrl+j scrolls a page down");
 
 	const empty = view({ async loadDiff() { return ""; } });
 	await settle();
-	assert.match(stripAnsi(empty.view.render(80)[1]), /no diff for this file/);
+	assert.match(stripAnsi(empty.view.render(80)[2]), /no diff for this file/);
+});
+
+test("ChangesView shows an oversized diff as one plain open-in-editor line and stays responsive", async () => {
+	const tagged = view({ theme: taggedTheme, async loadDiff() { return DIFF_TOO_LARGE; } }).view;
+	await settle();
+	const rendered = tagged.render(100).join("\n");
+	assert.match(rendered, /<dim>Diff too large/, "one plain line instead of a colored diff");
+	assert.doesNotMatch(rendered, /<toolDiff\w+>Diff too large/);
+	const { view: component, events } = view({ async loadDiff(target) { return target.path === "lib/a.ts" ? DIFF_TOO_LARGE : DIFF_A; } });
+	await settle();
+	assert.match(stripAnsi(component.render(140).join("\n")), /Diff too large — press o to open in editor\./);
+	component.handleInput("j");
+	await settle();
+	assert.match(stripAnsi(component.render(140).join("\n")), /\+const c = 4;/);
+	component.handleInput("k");
+	component.handleInput("o");
+	assert.ok(events.includes("open:lib/a.ts"));
 });
 
 test("ChangesView opens the selected file and closes on escape or q", async () => {
@@ -589,7 +639,7 @@ test("ChangesView paints the shared hover role over an unselected file row, neve
 	// Row y=1 is the selected file (lib/a.ts, index 0); row y=2 is lib/b.ts.
 	const hoverOther = component.handleMouse(mouseButton("move", "none", 3, 2, 12));
 	assert.deepEqual(hoverOther, { handled: true, render: true });
-	assert.match(component.render(80)[2]!, /<warning>[^<]*lib\/b\.ts/, "the hovered, unselected row paints the shared hover role");
+	assert.match(component.render(80)[2]!, /<warning>A b\.ts/, "the hovered, unselected row paints the shared hover role");
 	assert.doesNotMatch(component.render(80)[1]!, /<warning>/, "the selected row keeps its own role instead");
 
 	const hoverSelected = component.handleMouse(mouseButton("move", "none", 3, 1, 12));
@@ -610,15 +660,16 @@ test("ChangesView click selects a file without opening it", async () => {
 	component.handleMouse(mouse("release", 3, 2));
 	component.handleMouse(mouse("click", 3, 2));
 	await settle();
-	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A lib\/b\.ts/);
+	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A b\.ts/);
 	assert.deepEqual(events.filter((event) => event.startsWith("open:")), []);
 });
 
 test("ChangesView receives native fullscreen press and release as a click", async () => {
 	let onInput: ((data: string) => void) | undefined;
-	const terminal: Terminal = {
-		start(input) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 12; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {},
+	const terminalFixture = {
+		start(input: Parameters<Terminal["start"]>[0]) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 12; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {}, setProgramStatus() {},
 	};
+	const terminal: Terminal = terminalFixture;
 	const { view: component, events } = view();
 	const tui = new TuiAltScreen(terminal, false, undefined, { mouse: true });
 	tui.setLayoutRoot(component);
@@ -627,7 +678,7 @@ test("ChangesView receives native fullscreen press and release as a click", asyn
 	try {
 		onInput?.("\x1b[<0;4;3M");
 		onInput?.("\x1b[<0;4;3m");
-		assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A lib\/b\.ts/);
+		assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A b\.ts/);
 		assert.deepEqual(events.filter((event) => event.startsWith("open:")), []);
 	} finally {
 		tui.stop();
@@ -643,7 +694,7 @@ test("ChangesView rebuilds pointer geometry when its overlay height changes", as
 	assert.deepEqual(component.handleMouse(mouse("click", 3, 2, undefined, 8)), { handled: true, render: false });
 	component.render(80);
 	assert.deepEqual(component.handleMouse(mouse("click", 3, 2, undefined, 8)), { handled: true, render: true });
-	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A lib\/b\.ts/);
+	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A b\.ts/);
 });
 
 test("ChangesView scrolls the file list and diff independently, ignores hover, and clears stale pointer layouts", async () => {
@@ -653,15 +704,15 @@ test("ChangesView scrolls the file list and diff independently, ignores hover, a
 	await settle();
 	component.render(80);
 	component.handleMouse(mouse("move", 3, 2, undefined, 8));
-	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M lib\/0\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M 0\.ts/);
 	assert.deepEqual(events.filter((event) => event.startsWith("open:")), []);
 
 	assert.deepEqual(component.handleMouse(mouse("wheel", 3, 1, 2, 8)), { handled: true, render: true });
-	assert.match(stripAnsi(component.render(80)[1]), /^│   M lib\/2\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│   M 2\.ts/);
 	component.update(changesModel(files));
-	assert.match(stripAnsi(component.render(80)[1]), /^│   M lib\/2\.ts/, "an unchanged live refresh preserves the independently scrolled file viewport");
+	assert.match(stripAnsi(component.render(80)[1]), /^│   M 2\.ts/, "an unchanged live refresh preserves the independently scrolled file viewport");
 	assert.deepEqual(component.handleMouse(mouse("wheel", 50, 1, 2, 8)), { handled: true, render: true });
-	assert.doesNotMatch(stripAnsi(component.render(80)[1]), /@@/);
+	assert.doesNotMatch(stripAnsi(component.render(80)[2]), /@@/);
 	assert.deepEqual(component.handleMouse(mouse("wheel", 50, 1, -100, 8)), { handled: true, render: true });
 	assert.deepEqual(component.handleMouse(mouse("wheel", 50, 1, -1, 8)), { handled: true, render: false });
 
@@ -679,9 +730,9 @@ test("ChangesView keeps keyboard selection visible after file-list scrolling", a
 	component.render(80);
 	component.handleMouse(mouse("wheel", 3, 1, 2, 8));
 	component.handleInput("j");
-	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M lib\/1\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│ ▸ M 1\.ts/);
 	component.update(changesModel(files.slice(0, 3)));
-	assert.match(stripAnsi(component.render(80)[1]), /^│   M lib\/0\.ts/);
+	assert.match(stripAnsi(component.render(80)[1]), /^│   M 0\.ts/);
 });
 
 test("ChangesView.update keeps the selected file, reloads moved diffs, and survives an empty tree", async () => {
@@ -693,7 +744,7 @@ test("ChangesView.update keeps the selected file, reloads moved diffs, and survi
 
 	component.update(changesModel([file("lib/a.ts", 5, 1), file("lib/b.ts", 10, 0, CHANGE_STATUS.ADDED), file("lib/c.ts", 1, 0)]));
 	await settle();
-	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A lib\/b\.ts/);
+	assert.match(stripAnsi(component.render(80)[2]), /^│ ▸ A b\.ts/);
 	assert.deepEqual(calls, ["lib/a.ts", "lib/b.ts"], "unchanged selected file must not reload");
 	component.handleInput("k");
 	await settle();

package/tests/shell-changes.test.ts

@@ -9,8 +9,8 @@ import { visibleWidth } from "@earendil-works/pi-tui";
 import {
 	CHANGE_STATUS,
 	ChangesTracker,
+	FILE_WORK_CONCURRENCY,
 	WorktreeChangesTracker,
-	RootBranchLabels,
 	UNKNOWN_BRANCH,
 	foreignRootBranch,
 	parseWorktrees,
@@ -112,14 +112,6 @@ test("changesSummary and the widget describe the session at a glance", () => {
 	assert.equal(visibleWidth(line), 120, "the command sits on the right edge");
 });
 
-test("changesSummary and the widget surface the capture limit", () => {
-	const model = changesModel([file("a.ts", 1, 0)]);
-	model.notice = "Session change capture limit reached; additional changes are not displayed.";
-	assert.equal(changesSummary(model), "1 file · +1 −0 · capture limit reached");
-	assert.match(renderChangesWidget(model, plainTheme, 200)[0], /capture limit reached/);
-	assert.doesNotMatch(changesSummary(changesModel([file("a.ts", 1, 0)])), /capture limit reached/);
-});
-
 test("renderChangesWidget colors counts by direction and yields nothing when clean", () => {
 	const model = changesModel([file("a.ts", 1, 2)]);
 	const [line] = renderChangesWidget(model, taggedTheme, 400);
@@ -167,6 +159,24 @@ test("ChangesTracker reads the working tree on start and again on refresh", asyn
 	assert.deepEqual(calls[1], ["status", "--porcelain=v1", "--untracked-files=all", "-z"]);
 });
 
+test("ChangesTracker skips untracked dependency backups but preserves tracked edits and legitimate new files", async () => {
+	const backup = "node_modules.backup-20261007-192802/pkg/index.js";
+	const nestedBackup = "packages/app/node_modules.backup-local/pkg/index.js";
+	const tracked = "node_modules.backup-local/tracked.ts";
+	const legitimate = ["src/new.ts", "node_modules.backup-notes.md", "node_modules.backup-/new.ts"];
+	const { git } = fakeGit(
+		[`4\t2\t${tracked}\n`],
+		[[`?? ${backup}`, `?? ${nestedBackup}`, ` M ${tracked}`, ...legitimate.map((path) => `?? ${path}`)].join("\0") + "\0"],
+	);
+	const counted: string[] = [];
+	const tracker = new ChangesTracker(git, async (path) => { counted.push(path); return 3; });
+	await tracker.start();
+	assert.deepEqual(counted.sort(), [...legitimate].sort());
+	assert.deepEqual(tracker.model, changesModel([
+		file(tracked, 4, 2), ...legitimate.map((path) => file(path, 3, 0, CHANGE_STATUS.UNTRACKED)),
+	]));
+});
+
 test("ChangesTracker stays quiet outside a git repository", async () => {
 	const { git, calls } = fakeGit([""], [""], 128);
 	const tracker = new ChangesTracker(git);
@@ -210,6 +220,7 @@ test("registered roots hide clean and missing worktrees while metadata never adm
 	assert.equal(tracker.model.files.length, 2, "identical filenames in different roots remain distinct");
 	assert.equal(new Set(tracker.model.files.map((file) => file.path)).size, 2);
 	assert.ok(!calls.includes("/pruned") && !calls.includes("/bare"));
+	assert.deepEqual(tracker.failedRoots, ["/gone"], "a registered root Git cannot read is a failure, not a clean root");
 	roots += "worktree /new\0branch refs/heads/new\0\0";
 	registered.push("/new");
 	await tracker.refresh();
@@ -221,6 +232,29 @@ test("registered roots hide clean and missing worktrees while metadata never adm
 	assert.deepEqual(tracker.model, emptyChanges());
 });
 
+test("a root whose Git status fails or rejects is kept apart from clean roots", async () => {
+	let broken = true;
+	const tracker = new WorktreeChangesTracker(async () => ({ stdout: "", code: 0 }), (root) => async (args) => {
+		if (broken && root === "/rejects") throw new Error("git timed out");
+		if (broken && root === "/fails" && args[0] === "status") return { stdout: "", code: 128 };
+		return { stdout: args[0] === "status" && root === "/dirty" ? "?? a.ts\0" : "", code: 0 };
+	}, undefined, () => ["/dirty", "/clean", "/fails", "/rejects"]);
+	await tracker.start();
+	assert.deepEqual(tracker.worktrees.map((tree) => tree.root), ["/dirty"]);
+	assert.deepEqual([...tracker.failedRoots].sort(), ["/fails", "/rejects"], "a failed scan is not a clean root");
+	assert.equal(tracker.scannedRootCount, 4);
+	broken = false;
+	await tracker.refresh();
+	assert.deepEqual(tracker.failedRoots, [], "a later successful scan clears the failure");
+});
+
+test("no registered root is neither a failure nor a scan", async () => {
+	const tracker = new WorktreeChangesTracker(async () => { throw new Error("no Git expected"); }, () => async () => { throw new Error("no Git expected"); });
+	await tracker.start();
+	assert.deepEqual(tracker.failedRoots, []);
+	assert.equal(tracker.scannedRootCount, 0);
+});
+
 test("only registered worktrees are scanned, with whole preexisting and untracked contents", async () => {
 	const queried: string[] = [];
 	const roots = ["/used"];
@@ -244,7 +278,7 @@ test("worktree refresh shares one scan so polling faster than discovery cannot p
 		scans++;
 		if (scans === 2) await new Promise<void>((resolve) => { release = resolve; });
 		return { stdout: "", code: 0 };
-	}, () => async () => ({ stdout: "", code: 0 }));
+	}, () => async () => ({ stdout: "", code: 0 }), undefined, () => ["/root"]); // A root to scan; none means no Git at all.
 	await tracker.start();
 	const first = tracker.refresh();
 	const overlapping = tracker.refresh();
@@ -479,57 +513,40 @@ test("ChangesTracker counts the lines of untracked files, which git numstat leav
 	assert.deepEqual(counted, ["notes.md", "empty.md"]);
 });
 
-// The session-evidence tracker behind /gentle:changes knows roots, never
-// branches. The overlay decorates its trees with each root's own HEAD state,
-// resolved once per root and reported back so the view can repaint; until git
-// answers the tree shows no branch (the view's "detached" fallback), and a
-// genuinely detached HEAD stays that way.
-test("RootBranchLabels decorates session trees with each root's branch once git answers", async () => {
-	const calls = new Map<string, string[][]>();
-	const answers: Record<string, { symbolic: { stdout: string; code: number }; verify: { stdout: string; code: number } }> = {
-		"/repo": { symbolic: { stdout: "feature\n", code: 0 }, verify: { stdout: "deadbeef\n", code: 0 } },
-		"/fresh": { symbolic: { stdout: "main\n", code: 0 }, verify: { stdout: "", code: 1 } },
-		"/pinned": { symbolic: { stdout: "", code: 1 }, verify: { stdout: "deadbeef\n", code: 0 } },
+test("ChangesTracker counts lines and reads revisions for every file with bounded concurrency", async () => {
+	const paths = Array.from({ length: 30 }, (_, index) => `file-${String(index).padStart(2, "0")}.ts`);
+	const porcelain = [" M tracked.ts\0", ...paths.map((path) => `?? ${path}\0`)].join("");
+	const git = async (args: string[]) => ({ stdout: args[0] === "status" ? porcelain : "4\t1\ttracked.ts\n", code: 0 });
+	const pending = new Map<string, number>();
+	const counted: string[] = [];
+	let maxFiles = 0;
+	let overlapped = false;
+	// Every per-file call stays pending for a moment, so concurrent work overlaps.
+	const work = async <T>(path: string, result: () => T): Promise<T> => {
+		pending.set(path, (pending.get(path) ?? 0) + 1);
+		if (pending.get(path)! > 1) overlapped = true;
+		maxFiles = Math.max(maxFiles, pending.size);
+		await new Promise((resolve) => setTimeout(resolve, 2));
+		const left = pending.get(path)! - 1;
+		if (left === 0) pending.delete(path); else pending.set(path, left);
+		return result();
 	};
-	let changed = 0;
-	const labels = new RootBranchLabels((root) => async (args) => {
-		calls.set(root, [...(calls.get(root) ?? []), args]);
-		await new Promise((resolve) => setImmediate(resolve));
-		return args[0] === "symbolic-ref" ? answers[root]!.symbolic : answers[root]!.verify;
-	}, () => changed++);
-	const trees = Object.keys(answers).map((root) => ({ root, model: changesModel([]) }));
-	const first = labels.decorate(trees);
-	assert.deepEqual(first.map((tree) => tree.branch), [undefined, undefined, undefined], "nothing is labelled before git answers");
-	await labels.settled();
-	assert.equal(changed, 3, "each resolved root asks the view to repaint once");
-	const second = labels.decorate(trees);
-	assert.deepEqual(second.map((tree) => tree.branch), ["feature", "no commits yet", undefined]);
-	labels.decorate(trees);
-	await labels.settled();
-	assert.deepEqual([...calls.values()].map((list) => list.length), [2, 2, 1], "one resolution per root, never per decorate call");
-	assert.equal(changed, 3);
-});
-
-// A root that could not even be asked (removed, git unavailable, the runner
-// itself rejecting) must read UNKNOWN_BRANCH -- never the same undefined a
-// genuine detached HEAD produces, and never silently stay unlabelled forever.
-test("RootBranchLabels labels a root UNKNOWN_BRANCH when it could not be asked, distinct from a real detached HEAD", async () => {
-	let changed = 0;
-	const labels = new RootBranchLabels((root) => async () => {
-		await new Promise((resolve) => setImmediate(resolve));
-		if (root === "/gone") throw new Error("root removed");
-		return { stdout: "", code: 1 };
-	}, () => changed++);
-	const trees = [
-		{ root: "/gone", model: changesModel([]) },
-		{ root: "/detached", model: changesModel([]) },
-	];
-	labels.decorate(trees);
-	await labels.settled();
-	assert.deepEqual(
-		labels.decorate(trees).map((tree) => tree.branch),
-		[UNKNOWN_BRANCH, undefined],
-		"a failed ask reads UNKNOWN_BRANCH; a real detached HEAD still reads undefined (the view's detached fallback)",
-	);
-	assert.equal(changed, 2, "a failed ask still resolves and asks the view to repaint, instead of hanging forever");
+	const tracker = new ChangesTracker(git, (path) => work(path, () => {
+		counted.push(path);
+		if (path === "file-07.ts") throw new Error("unreadable");
+		return 2;
+	}), (path) => work(path, () => {
+		if (path === "file-07.ts") throw new Error("unreadable");
+		return `rev:${path}`;
+	}));
+	await tracker.start();
+	const files = new Map(tracker.model.files.map((entry) => [entry.path, entry]));
+	assert.equal(maxFiles, FILE_WORK_CONCURRENCY, "files run concurrently up to the limit, never past it");
+	assert.equal(FILE_WORK_CONCURRENCY, 8);
+	assert.ok(overlapped, "a file's line count and revision lookup run together");
+	assert.deepEqual([...counted].sort(), paths, "every untracked file is counted once; tracked files keep numstat counts");
+	assert.equal(files.size, 31);
+	assert.deepEqual(files.get("tracked.ts"), { ...file("tracked.ts", 4, 1), diffRevision: "rev:tracked.ts" });
+	assert.deepEqual(files.get("file-07.ts"), file("file-07.ts", 0, 0, CHANGE_STATUS.UNTRACKED), "a failing lookup keeps its fallback");
+	for (const path of paths.filter((path) => path !== "file-07.ts")) assert.deepEqual(files.get(path), { ...file(path, 2, 0, CHANGE_STATUS.UNTRACKED), diffRevision: `rev:${path}` });
 });

package/tests/shell-render-cache-runtime.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { initTheme, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, TuiAltScreen } from "@earendil-works/pi-tui";
+import { createChatViewport } from "../node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/chat-viewport.js";
+import { buildShellBarModel, type ShellFooterData } from "../extensions/gentle-shell.ts";
+import { createQuietToolRenderer } from "../extensions/quiet-tools.ts";
+
+initTheme("dark");
+
+test("native fullscreen scroll frames reuse complete tool cards and session statistics", () => {
+	let decoration = 0;
+	let scans = 0;
+	let projections = 0;
+	const theme = {
+		fg: (_color: string, text: string) => { decoration++; return text; },
+		bg: (_color: string, text: string) => { decoration++; return `\x1b[48;5;235m${text}\x1b[49m`; },
+		bold: (text: string) => text,
+	};
+	const ctx = {
+		model: { id: "model", contextWindow: 1000 },
+		getContextUsage() { projections++; return { percent: 10, contextWindow: 1000 }; },
+		modelRegistry: { isUsingOAuth: () => false },
+		sessionManager: {
+			getEntries() { scans++; return []; }, getSessionId: () => "session", getLeafId: () => "leaf",
+			getCwd: () => "/repo", getSessionName: () => "session",
+		},
+	} as unknown as ExtensionContext;
+	const footerData = { getGitBranch: () => "main", getExtensionStatuses: () => new Map() } as unknown as ShellFooterData;
+	const pi = { getThinkingLevel: () => "high" } as unknown as ExtensionAPI;
+	const document = new Container();
+	const renderer = createQuietToolRenderer("read");
+	for (let tool = 0; tool < 50; tool++) {
+		const context = { args: { path: `src/file-${tool}.ts` }, state: {}, isPartial: false, executionStarted: true };
+		document.addChild(renderer.renderCall!(context.args, theme as never, context as never));
+		document.addChild(renderer.renderResult!({ content: [{ type: "text", text: `result-${tool}` }], details: {} },
+			{ expanded: false, isPartial: false }, theme as never, context as never));
+	}
+	const footer = new Container();
+	footer.addChild({ render: () => [`cost ${buildShellBarModel(pi, ctx, footerData).costTotal}`], invalidate() {} });
+	const viewport = createChatViewport({
+		document, pendingMessages: new Container(), status: new Container(), widgetsAbove: new Container(),
+		editor: { render: () => ["prompt"], invalidate() {} }, widgetsBelow: new Container(), footer, scrollbar: "hidden",
+	});
+	const terminal = {
+		start() {}, stop() {}, async drainInput() {}, write() {}, columns: 100, rows: 24,
+		moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {},
+		setTitle() {}, setProgress() {}, kittyProtocolActive: false, getBufferedInput() { return ""; }, hasPendingInput() { return false; },
+	} as never;
+	const tui = new TuiAltScreen(terminal, false);
+	tui.setLayoutRoot(viewport.root);
+	const host = tui as unknown as { doRender(): void; previousScreen: string[] };
+	tui.start();
+	try {
+		host.doRender();
+		const warmDecoration = decoration;
+		assert.deepEqual([scans, projections], [1, 1]);
+		const screens: string[] = [];
+		for (let frame = 0; frame < 20; frame++) {
+			if (frame % 2) viewport.transcript.scrollToEnd();
+			else viewport.transcript.scrollTo(0, { disableFollow: true });
+			host.doRender();
+			screens.push(host.previousScreen.join("\n"));
+		}
+		assert.notEqual(screens[0], screens[1], "scroll really changes the visible transcript");
+		assert.equal(decoration, warmDecoration, "even the native frame path reuses settled chrome");
+		assert.deepEqual([scans, projections], [1, 1], "scroll/pulse-like frames do not rescan unchanged session state");
+	} finally { tui.stop(); }
+});