gentle-pi 4.3.0 → 4.5.0

package/tests/shell-bar.test.ts

@@ -107,7 +107,7 @@ test("visual visibility hides only selected optional status segments", () => {
 	assert.doesNotMatch(renderShellHeaderBar(buildShellHeaderModel(data), plainTheme, 160, undefined, settings).text, /gpt-5\.5|ctx|\$9\.49|usage/);
 });
 
-test("Status groups running job descriptions beside RDD without a compact count", () => {
+test("Status keeps RDD beside structured groups while running jobs moved to their own card", () => {
 	const data = model({ jobs: [
 		{ id: "job-2", label: "CI for PR 1860", startedAt: 2 },
 		{ id: "job-1", label: "Build runtime", startedAt: 1 },
@@ -115,12 +115,12 @@ test("Status groups running job descriptions beside RDD without a compact count"
 	for (const width of [30, 60]) {
 		const lines = renderShellSidebarBar(data, plainTheme, width);
 		const text = lines.join("\n");
-		assert.match(text, /Jobs[\s\S]*CI for PR 1860[\s\S]*Build runtime/);
+		// Running jobs live in their own sidebar card; the Status card never
+		// prints them, so the two surfaces cannot duplicate one job.
+		assert.doesNotMatch(text, /Jobs|CI for PR 1860|Build runtime/);
 		assert.match(text, /🌹 RDD/);
-		assert.doesNotMatch(text, /2 jobs/);
 		assert.ok(lines.every((line) => visibleWidth(line) <= width));
 	}
-	assert.doesNotMatch(renderShellSidebarBar(model({ jobs: [] }), plainTheme, 60).join("\n"), /Jobs/);
 });
 
 test("header shows only the running job count when requested and preserves it at mobile widths", () => {
@@ -355,7 +355,7 @@ test("renderShellSidebarBar paints the Status card frame with border and the tit
 });
 
 test("sidebar unifies project, captured changes and integrations in one frame", () => {
-	const data = model({ changes: { files: 2, added: 7, deleted: 3, notice: "capture warning" }, statuses: ["MCP connected"] });
+	const data = model({ changes: { files: 2, added: 7, deleted: 3 }, statuses: ["MCP connected"] });
 	const lines = renderShellSidebarBar(data, plainTheme, 46);
 	const text = lines.join("\n");
 	assert.equal(lines.filter((line) => line.startsWith("╭")).length, 1);
@@ -366,7 +366,6 @@ test("sidebar unifies project, captured changes and integrations in one frame",
 		previous = index;
 	}
 	assert.match(text, /2 files.*\+7.*−3/);
-	assert.match(text, /capture warning/);
 	assert.match(text, /\/gentle:changes/);
 	assert.match(text, /main/);
 	for (const width of [1, 8, 24, 46]) assert.ok(renderShellSidebarBar(data, plainTheme, width).every((line) => visibleWidth(line) <= width));
@@ -856,6 +855,19 @@ test("unified below-input float includes optional Changes and sanitized statuses
 	assert.equal(renderShellBelowInputFloat(model(), theme, 140, "alt+u", presentation, changes), undefined);
 });
 
+// The idle Changes row exists only when files are actually tracked; an empty
+// capture — including an unborn-only root, which the tracker never scans — is
+// silence (explained by /gentle:changes on demand), never an instruction row.
+test("the below-input float shows no Changes row without tracked files", (t) => {
+	useCardStyle(t, CARD_STYLE.FLOAT);
+	const theme = withBackground(plainTheme);
+	const presentation = { ...DEFAULT_VISUAL_SETTINGS, headerPlacement: "below-input" as const };
+	const empty = { files: [], added: 0, deleted: 0 };
+	const chrome = renderShellBelowInputFloat(model(), theme, 140, "alt+u", presentation, empty)!;
+	assert.equal(chrome.headerRow, 2, "an empty capture is silence, not a Changes row");
+	assert.doesNotMatch(stripAnsi(chrome.rows.join("\n")), /make a commit to start tracking/);
+});
+
 test("the narrow-layout bottom-only bar stays unchanged in the float style", (t) => {
 	const theme = withBackground(taggedTheme);
 	const data = model({ usage: USAGE_TWO_WINDOWS, statuses: ["mcp ok"] });

package/tests/shell-changes.test.ts

@@ -15,6 +15,7 @@ import {
 	foreignRootBranch,
 	parseWorktrees,
 	changesSummary,
+	changesDigest,
 	emptyChanges,
 	parseNumstat,
 	parsePorcelain,
@@ -101,6 +102,36 @@ test("changesModel sorts files by path and totals the counts", () => {
 	assert.equal(model.deleted, 2);
 });
 
+// The footer Status memo reads the changes digest on every keystroke, so the
+// model stores it once per build and reading it never walks the file list.
+// The digest hashes every per-file tuple the renderer consumes (path, status,
+// counts, diffRevision, countsUnavailable); a 64-bit collision could only
+// skip one refresh until the next change moves it again -- never render a
+// wrong picture.
+test("the changes digest is stored on the model and stays equal while nothing moves", () => {
+	const files = [file("lib/a.ts", 4, 2), file("lib/b.ts", 10, 0, CHANGE_STATUS.ADDED)];
+	const model = changesModel([...files]);
+	assert.equal(Object.hasOwn(model, "digest"), true, "the digest is a stored field, not recomputed per read");
+	assert.equal(model.digest, changesDigest(model), "the stored digest matches an independently computed one");
+	assert.equal(changesModel([...files]).digest, model.digest, "an unchanged model rebuilds to the same digest");
+	assert.equal(emptyChanges().digest, emptyChanges().digest, "the empty model carries a stable digest");
+});
+
+test("the changes digest moves with every per-file detail the renderer consumes", () => {
+	const base = changesModel([file("lib/a.ts", 4, 2)]).digest;
+	const digestFor = (files: ChangedFile[]) => changesModel(files).digest!;
+	assert.notEqual(digestFor([file("lib/a.ts", 4, 2, CHANGE_STATUS.RENAMED)]), base, "a status change moves the digest even at equal counts");
+	assert.notEqual(digestFor([file("lib/a.ts", 5, 2)]), base, "an added-count change moves the digest");
+	assert.notEqual(digestFor([file("lib/a.ts", 4, 3)]), base, "a deleted-count change moves the digest");
+	assert.notEqual(digestFor([file("lib/b.ts", 4, 2)]), base, "a path change moves the digest");
+	const revised = file("lib/a.ts", 4, 2);
+	revised.diffRevision = "abc123";
+	assert.notEqual(digestFor([revised]), base, "a diffRevision change moves the digest");
+	const partial = file("lib/a.ts", 4, 2);
+	partial.countsUnavailable = "timeout";
+	assert.notEqual(digestFor([partial]), base, "countsUnavailable moves the digest");
+});
+
 test("changesSummary and the widget describe the session at a glance", () => {
 	const model = changesModel([file("extensions/gentle-shell.ts", 31, 0, CHANGE_STATUS.ADDED), file("lib/shell-bar.ts", 9, 7), file("tests/x.test.ts", 2, 0)]);
 	assert.equal(changesSummary(model), "3 files · +42 −7");
@@ -121,6 +152,14 @@ test("renderChangesWidget colors counts by direction and yields nothing when cle
 	assert.deepEqual(renderChangesWidget(emptyChanges(), plainTheme, 120), []);
 });
 
+// The unborn state (no commits yet) is silence in the idle bar: the widget
+// renders only tracked files, and /gentle:changes explains the state on demand.
+test("renderChangesWidget stays silent when nothing is tracked", () => {
+	assert.deepEqual(renderChangesWidget(emptyChanges(), plainTheme, 120), []);
+	assert.deepEqual(renderChangesWidget(emptyChanges(), taggedTheme, 400), []);
+	assert.deepEqual(renderChangesWidget(emptyChanges(), plainTheme, 12), []);
+});
+
 test("renderChangesWidget drops the file list before truncating on narrow terminals", () => {
 	const model = changesModel([file("a/very/long/path/one.ts", 1, 0), file("a/very/long/path/two.ts", 1, 0)]);
 	const [line] = renderChangesWidget(model, plainTheme, 40);
@@ -132,6 +171,67 @@ test("renderChangesWidget drops the file list before truncating on narrow termin
 	assert.match(tiny, /^✎ 2 files/);
 });
 
+// Repeated frames hit the widget from two surfaces (the sidebar part and the
+// below-input header row), but its paint depends only on what the model digest
+// already covers plus the width and the theme. A counting theme is the seam: a
+// cache hit paints nothing, so theme.fg stays silent instead of walking files.
+function countingTheme() {
+	let calls = 0;
+	return {
+		get fgCalls() {
+			return calls;
+		},
+		fg(_color: string, text: string) {
+			calls += 1;
+			return text;
+		},
+	};
+}
+
+test("renderChangesWidget memoizes a frame per digest, width and theme so an unchanged model repaints nothing", () => {
+	const model = changesModel([file("lib/a.ts", 4, 2), file("lib/b.ts", 10, 0, CHANGE_STATUS.ADDED)]);
+	const theme = countingTheme();
+	const first = renderChangesWidget(model, theme, 120);
+	assert.ok(theme.fgCalls > 0, "the first render paints");
+	const afterFirst = theme.fgCalls;
+	const second = renderChangesWidget(model, theme, 120);
+	assert.deepEqual(second, first, "an unchanged model, width and theme return the same rows");
+	assert.equal(theme.fgCalls, afterFirst, "a memo hit repaints nothing: no per-file iteration");
+});
+
+test("renderChangesWidget re-renders when the digest moves", () => {
+	const theme = countingTheme();
+	const before = changesModel([file("lib/a.ts", 4, 2)]);
+	renderChangesWidget(before, theme, 120);
+	const afterFirst = theme.fgCalls;
+	const moved = changesModel([file("lib/a.ts", 5, 2)]);
+	assert.notEqual(moved.digest, before.digest, "a count change moves the digest");
+	const lines = renderChangesWidget(moved, theme, 120);
+	assert.ok(theme.fgCalls > afterFirst, "a digest change re-renders");
+	assert.match(lines.join("\n"), /\+5/, "the re-render shows the new totals");
+});
+
+test("renderChangesWidget re-renders when the width or the theme changes", () => {
+	const model = changesModel([file("lib/a.ts", 4, 2)]);
+	const theme = countingTheme();
+	const wide = renderChangesWidget(model, theme, 400);
+	const afterWide = theme.fgCalls;
+	renderChangesWidget(model, theme, 40);
+	assert.ok(theme.fgCalls > afterWide, "a width change re-renders");
+	const otherTheme = countingTheme();
+	assert.deepEqual(renderChangesWidget(model, otherTheme, 400), wide, "a new theme object repaints the same wide frame");
+	assert.ok(otherTheme.fgCalls > 0, "the new theme did the painting");
+});
+
+test("renderChangesWidget never caches a digest-less model", () => {
+	const model = { files: [file("lib/a.ts", 4, 2)], added: 4, deleted: 2 };
+	const theme = countingTheme();
+	renderChangesWidget(model, theme, 120);
+	const afterFirst = theme.fgCalls;
+	renderChangesWidget(model, theme, 120);
+	assert.ok(theme.fgCalls > afterFirst, "a hand-built model without a digest re-renders every call");
+});
+
 function fakeGit(numstats: string[], porcelains: string[], code = 0) {
 	const calls: string[][] = [];
 	let round = 0;
@@ -336,7 +436,6 @@ test("foreignRootBranch still reports a genuine detached HEAD as undefined, not
 test("a root missing from worktree list resolves its own branch instead of defaulting to detached", async (t) => {
 	const scenarios: Array<{ name: string; symbolic: { stdout: string; code: number }; verify: { stdout: string; code: number }; expected: string | undefined }> = [
 		{ name: "a normal branch on a foreign clone", symbolic: { stdout: "feature\n", code: 0 }, verify: { stdout: "deadbeef\n", code: 0 }, expected: "feature" },
-		{ name: "an unborn branch (no commits yet)", symbolic: { stdout: "main\n", code: 0 }, verify: { stdout: "", code: 1 }, expected: "no commits yet" },
 		{ name: "a genuinely detached HEAD", symbolic: { stdout: "", code: 1 }, verify: { stdout: "deadbeef\n", code: 0 }, expected: undefined },
 	];
 	for (const scenario of scenarios) {
@@ -358,9 +457,57 @@ test("a root missing from worktree list resolves its own branch instead of defau
 			assert.deepEqual(tracker.worktrees.map((tree) => [tree.root, tree.branch]), [["/foreign", scenario.expected]]);
 			assert.ok(calls.some((args) => args[0] === "symbolic-ref"), "a root absent from worktree list must be asked directly");
 		});
+		// An unborn foreign root is a holder before it is a branch question: with
+		// no commits there is no baseline to diff against, so it is skipped --
+		// neither dirty nor failed -- before any branch lookup happens.
+		await t.test("an unborn foreign root is skipped as a holder before the branch ask", async () => {
+			const calls: string[][] = [];
+			const tracker = new WorktreeChangesTracker(
+				async () => ({ stdout: "", code: 0 }),
+				() => async (args) => {
+					calls.push(args);
+					if (args[0] === "rev-parse") return { stdout: "", code: 1 };
+					return { stdout: "", code: 0 };
+				},
+				undefined,
+				() => ["/foreign"],
+			);
+			await tracker.start();
+			assert.deepEqual(tracker.worktrees, []);
+			assert.deepEqual(tracker.unbornRoots, ["/foreign"]);
+			assert.deepEqual(tracker.failedRoots, []);
+			assert.ok(!calls.some((args) => args[0] === "symbolic-ref"), "a skipped holder is never asked for a branch");
+		});
 	}
 });
 
+// A worktree-holder repository (no commits, only linked worktrees inside) has
+// no baseline: `git diff HEAD` is meaningless and every file reports
+// untracked, so scanning it floods Changes with thousands of phantom files.
+// It is skipped as neither dirty nor failed, and its first commit starts
+// tracking it on the next scan.
+test("a root with no commits is skipped as a holder, neither dirty nor failed, and recovers on its first commit", async () => {
+	let holderHasCommits = false;
+	const tracker = new WorktreeChangesTracker(
+		async () => ({ stdout: "worktree /real\0branch refs/heads/main\0\0", code: 0 }),
+		(root) => async (args) => {
+			if (args[0] === "rev-parse") return { stdout: "", code: root === "/holder" && !holderHasCommits ? 1 : 0 };
+			return { stdout: args[0] === "status" && (root === "/real" || (root === "/holder" && holderHasCommits)) ? "?? a.ts\0" : "", code: 0 };
+		},
+		undefined,
+		() => ["/holder", "/real"],
+	);
+	await tracker.start();
+	assert.deepEqual(tracker.worktrees.map((tree) => tree.root), ["/real"], "an unborn root is skipped, not scanned");
+	assert.deepEqual(tracker.unbornRoots, ["/holder"]);
+	assert.deepEqual(tracker.failedRoots, [], "no commits is not a Git failure");
+	assert.equal(tracker.scannedRootCount, 2);
+	holderHasCommits = true;
+	await tracker.refresh();
+	assert.deepEqual(tracker.worktrees.map((tree) => tree.root), ["/holder", "/real"], "the first commit starts tracking");
+	assert.deepEqual(tracker.unbornRoots, []);
+});
+
 // The direct per-root ask (for a root missing from worktree list) can fail on
 // its own -- root gone, git unavailable -- independently of the change scan
 // that already found real files. That failure must label the root

package/tests/shell-prompt.test.ts

@@ -8,15 +8,15 @@ import {
 	PROMPT_STATE,
 	petalGlyph,
 	petalTone,
-	SHELL_PULSE_MS,
+	SHELL_PULSE_WATCHDOG_MS,
 	SHELL_SCANNER_STEPS,
 	withPromptHint,
 	type PromptFrameOptions,
 } from "../lib/shell-prompt.ts";
 
-test("scanner reflects a symmetric light wave across working text at Pi's original cadence", () => {
+test("scanner reflects a symmetric light wave across working text at the watchdog cadence", () => {
 	const fg = (role: string, char: string) => `<${role}>${char}</${role}>`;
-	assert.equal(SHELL_PULSE_MS, 80);
+	assert.equal(SHELL_PULSE_WATCHDOG_MS, 1000);
 	assert.equal(SHELL_SCANNER_STEPS, 15);
 	for (const word of ["working…", "Thinking…"]) {
 		for (let tick = 0; tick < SHELL_SCANNER_STEPS; tick++) {

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

@@ -1,7 +1,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { initTheme, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { buildShellBarModel, type ShellFooterData } from "../extensions/gentle-shell.ts";
+import { buildShellBarModel, createFooterStatusMemo, type ShellFooterData } from "../extensions/gentle-shell.ts";
+import { CHANGE_STATUS } from "../lib/shell-changes.ts";
+import type { RunningJobDisplay } from "../lib/jobs-sidebar-state.ts";
+import type { ReviewSidebarSnapshot } from "../lib/review-sidebar-state.ts";
+import type { ProviderUsage } from "../lib/shell-usage.ts";
 import { createQuietToolRenderer } from "../extensions/quiet-tools.ts";
 import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
 
@@ -127,3 +131,132 @@ test("image renderers keep their live geometry instead of caching opaque compone
 		{ expanded: true, isPartial: false }, theme as never, {} as never);
 	assert.notDeepEqual(card.render(80), card.render(80));
 });
+
+function footerMemoFixture() {
+	let reads = 0;
+	let projections = 0;
+	let leaf = "leaf-1";
+	const entries = [{ type: "message", message: { role: "assistant", usage: { cost: { total: 1 } } } }];
+	// One stable model object, replaced only by setModelId: real hosts keep the
+	// model identity stable, and sessionStatsKey compares it by identity.
+	let model: { id: string; contextWindow: number } = { id: "model", contextWindow: 1000 };
+	const ctx = {
+		get model() { return model; },
+		getContextUsage() { projections++; return { percent: 10, contextWindow: 1000 }; },
+		modelRegistry: { isUsingOAuth: () => false },
+		sessionManager: {
+			getEntries() { reads++; return [...entries]; },
+			getEntryCount: () => entries.length,
+			getSessionId: () => "session-1",
+			getLeafId: () => leaf,
+			getCwd: () => "/repo",
+			getSessionName: () => "session",
+		},
+	};
+	let branch: string | null = "main";
+	let statuses = new Map<string, string>();
+	let usage: ProviderUsage | undefined;
+	let added = 0;
+	let deleted = 0;
+	let unbornRoots = 0;
+	let review: ReviewSidebarSnapshot | undefined;
+	let jobs: RunningJobDisplay[] | undefined;
+	let settings: unknown = { statusPlacement: "auto" };
+	let style: unknown = "comfortable";
+	const footerData = { getGitBranch: () => branch, getExtensionStatuses: () => statuses } as unknown as ShellFooterData;
+	let profile: string | undefined = "team";
+	const memo = createFooterStatusMemo({
+		pi, ctx: ctx as unknown as ExtensionContext, footerData,
+		usage: () => usage,
+		profile: () => profile,
+		jobs: () => jobs,
+		review: () => review,
+		tracker: () => ({ model: { files: [{ path: "a.ts", status: CHANGE_STATUS.MODIFIED, added, deleted }], added, deleted }, unbornRoots: Array.from({ length: unbornRoots }, () => "root") }),
+		visualSettings: () => settings,
+		cardStyle: () => style,
+	});
+	return {
+		ctx: ctx as unknown as ExtensionContext & { sessionManager: { getLeafId?: () => string } },
+		memo,
+		counts: () => [reads, projections],
+		setLeaf: (value: string) => { leaf = value; },
+		spend: () => { entries[0]!.message.usage.cost.total += 1; },
+		setModelId: (value: string) => { model = { ...model, id: value }; },
+		setProfile: (value: string | undefined) => { profile = value; },
+		setBranch: (value: string | null) => { branch = value; },
+		setStatuses: (value: Map<string, string>) => { statuses = value; },
+		setUsage: (value: ProviderUsage | undefined) => { usage = value; },
+		setChangeCounts: (nextAdded: number, nextDeleted: number) => { added = nextAdded; deleted = nextDeleted; },
+		setUnbornRoots: (value: number) => { unbornRoots = value; },
+		setReview: (value: ReviewSidebarSnapshot | undefined) => { review = value; },
+		setJobs: (value: RunningJobDisplay[] | undefined) => { jobs = value; },
+		setSettings: (value: unknown) => { settings = value; },
+		setStyle: (value: unknown) => { style = value; },
+	};
+}
+
+test("the footer status memo reuses one model while live inputs hold still", () => {
+	const f = footerMemoFixture();
+	const first = f.memo.model();
+	assert.equal(first.costTotal, 1);
+	assert.deepEqual(first.changes, { files: 1, added: 0, deleted: 0 });
+	for (let frame = 0; frame < 10; frame++) assert.equal(f.memo.model(), first, "stable inputs reuse the built model");
+	assert.deepEqual(f.counts(), [1, 1], "warm frames never rescan the session");
+});
+
+test("the footer status digest key notices every live input the model reads", () => {
+	const f = footerMemoFixture();
+	const before = f.memo.key();
+	assert.equal(f.memo.key(), before, "the key is deterministic while nothing moves");
+	const mutations: Array<[string, () => void]> = [
+		["branch", () => f.setBranch("feature")],
+		["profile", () => f.setProfile("other (local)")],
+		["statuses", () => f.setStatuses(new Map([["jobs", "1 running"]]))],
+		["usage", () => f.setUsage({ provider: "p", plan: undefined, limits: [], fetchedAt: 1 })],
+		["change counts", () => f.setChangeCounts(2, 1)],
+		["unborn roots", () => f.setUnbornRoots(1)],
+		["review", () => f.setReview({ state: "open", scope: undefined } as unknown as ReviewSidebarSnapshot)],
+		["jobs", () => f.setJobs([{ id: "j", label: "l", startedAt: 0 }])],
+		["visual settings", () => f.setSettings({ statusPlacement: "bottom" })],
+		["card style", () => f.setStyle("compact")],
+		["model", () => f.setModelId("new-model")],
+		["cwd", () => (f.ctx.sessionManager as { getCwd(): string }).getCwd = () => "/other"],
+		["session name", () => (f.ctx.sessionManager as { getSessionName(): string }).getSessionName = () => "renamed"],
+		["leaf", () => f.setLeaf("leaf-2")],
+	];
+	let previous = before;
+	for (const [name, mutate] of mutations) {
+		mutate();
+		const current = f.memo.key();
+		assert.notEqual(current, previous, `a moved ${name} changes the digest key`);
+		previous = current;
+	}
+	// A branch or profile move rebuilds the model without rescanning statistics:
+	// the model object identity stays stable across those rebuilds.
+	const settled = f.memo.model();
+	const [reads, projections] = f.counts();
+	f.setBranch("release");
+	assert.notEqual(f.memo.model(), settled);
+	assert.deepEqual(f.counts(), [reads, projections]);
+});
+
+test("a moved leaf rebuilds the footer model with fresh statistics", () => {
+	const f = footerMemoFixture();
+	const first = f.memo.model();
+	f.setLeaf("leaf-2");
+	const second = f.memo.model();
+	assert.notEqual(second, first);
+	assert.deepEqual(f.counts(), [2, 2]);
+	assert.equal(f.memo.model(), second, "the fresh model is memoized again");
+});
+
+test("hosts without leaf identity stay honest through the digest key's values", () => {
+	const f = footerMemoFixture();
+	assert.equal(f.memo.key(), f.memo.key(), "the key stays deterministic on uncached hosts");
+	Reflect.deleteProperty(f.ctx.sessionManager, "getLeafId");
+	const first = f.memo.model();
+	f.spend();
+	const second = f.memo.model();
+	assert.notEqual(second, first, "a changed cost value rebuilds the model without leaf identity");
+	assert.equal(second.costTotal, 2);
+});

package/tests/shell-sidebar-layout.test.ts

@@ -589,6 +589,73 @@ test("a rail digest refreshes live state that no invalidation announces", (t) =>
 	assert.equal(todoRenders, 2, "explicit invalidation still reaches a rail without a digest");
 });
 
+test("the jobs rail section paints between Status and Agents", (t) => {
+	const f = fixture();
+	sidebarPart(f.tui, "jobs", { render: () => ["jobs"], invalidate() {} }, { digest: () => "jobs", render: () => ["Jobs card"], invalidate() {} });
+	sidebarPart(f.tui, "agents", { render: () => ["agents"], invalidate() {} }, { digest: () => "agents", render: () => ["Agents card"], invalidate() {} });
+	sidebarPart(f.tui, "todo", { render: () => ["todo"], invalidate() {} }, { digest: () => "todo", render: () => ["Todo card"], invalidate() {} });
+	t.after(installSidebar(f.tui, theme));
+	const text = renderLayoutFrame(f.root, 140, 20, () => {}).lines.join("\n");
+	const footer = text.indexOf("Status");
+	const jobs = text.indexOf("Jobs card");
+	const agents = text.indexOf("Agents card");
+	const todo = text.indexOf("Todo card");
+	for (const [name, index] of [["Status", footer], ["Jobs card", jobs], ["Agents card", agents], ["Todo card", todo]] as const) {
+		assert.ok(index >= 0, `${name} paints in the rail`);
+	}
+	assert.ok(footer < jobs && jobs < agents && agents < todo, `sections paint in order, got: ${text}`);
+});
+
+test("a theme switch repaints rail sections whose digest did not change", (t) => {
+	const f = fixture();
+	// Pi hands extensions a live theme proxy and announces a switch only through
+	// ui.invalidate(), which never reaches the rail inside the layout tree.
+	let code = 31;
+	const live = { fg: (_color: string, text: string) => `\x1b[${code}m${text}\x1b[39m`, bold: (text: string) => text };
+	for (const key of ["footer", "agents", "todo"]) {
+		sidebarPart(f.tui, key, { render: () => [key], invalidate() {} }, {
+			digest: () => "stable",
+			render: () => [live.fg("accent", `${key} card`)],
+			invalidate() {},
+		});
+	}
+	t.after(installSidebar(f.tui, live));
+
+	const before = renderLayoutFrame(f.root, 140, 20, () => {}).lines.join("\n");
+	for (const key of ["footer", "agents", "todo"]) assert.ok(before.includes(`\x1b[31m${key} card`), `${key} paints with the first theme`);
+
+	code = 32;
+	const after = renderLayoutFrame(f.root, 140, 20, () => {}).lines.join("\n");
+	for (const key of ["footer", "agents", "todo"]) {
+		assert.ok(after.includes(`\x1b[32m${key} card`), `${key} repaints with the new theme`);
+		assert.ok(!after.includes(`\x1b[31m${key} card`), `${key} drops the old theme`);
+	}
+});
+
+test("structural cache misses skip the whole-rail digest pass", (t) => {
+	const f = fixture();
+	let digests = 0;
+	sidebarPart(f.tui, "todo", { render: () => ["Todo"], invalidate() {} }, {
+		digest: () => { digests++; return "stable"; },
+		render: () => [`Todo ${digests}`],
+		invalidate() {},
+	});
+	t.after(installSidebar(f.tui, theme));
+
+	// Every frame evaluates the digest exactly once: the whole-rail comparison
+	// reuses it for the section cache instead of calling each digest twice per
+	// prepare (issue #1681).
+	renderLayoutFrame(f.root, 140, 20, () => {});
+	const prepared = digests;
+	assert.equal(prepared, 1, "preparing the rail evaluates the digest once");
+	renderLayoutFrame(f.root, 140, 20, () => {});
+	assert.equal(digests, prepared + 1, "a cache hit compares the digest once");
+	renderLayoutFrame(f.root, 141, 20, () => {});
+	assert.equal(digests, prepared + 2, "a structural miss re-prepares with a single digest pass");
+	renderLayoutFrame(f.root, 140, 20, () => {});
+	assert.equal(digests, prepared + 3, "returning to the cached structure stays on a single digest pass");
+});
+
 test("reuses final sidebar presentation until a relevant invalidation", (t) => {
 	const f = fixture();
 	sidebarPart(f.tui, "todo", { render: () => Array.from({ length: 10 }, (_, index) => `Todo ${index}`), invalidate() {} });

package/tests/short-check-routing-contract.test.ts

@@ -36,7 +36,7 @@ for (const [name, text] of Object.entries({ registeredDescription: background.de
 test("inline still means the same parent, and the public background API stays asynchronous", () => {
 	assert.ok(core.includes("Small path: inline (parent; `bash_background` policy);"));
 	assert.ok(guide.includes("Inline means the same parent, not necessarily synchronous bash"));
-	assert.ok(core.includes("run the focused test and the suite inline, once each"));
+	assert.ok(core.includes("run the focused test and the suite inline in one command"));
 	assert.match(background.description, /return a job id at once/);
 	assert.match(background.description, /notified once, automatically/);
 	assert.match(background.description, /do not poll, sleep, or delegate a subagent to wait/);

package/tests/skill-collision-prefixes.test.ts

@@ -25,7 +25,9 @@ const PREFIXED_NAMES: Record<string, string> = {
 	"work-unit-commits": "gentle-ai-work-unit-commits",
 };
 
-const UNPREFIXED_DIRS = ["gentle-ai"];
+// gentle-pi-owned skills that gentle-ai does not install keep their own
+// gentle- namespace, so they need no gentle-ai- prefix to avoid a collision.
+const UNPREFIXED_DIRS = ["gentle-ai", "design"];
 
 for (const [dir, expectedName] of Object.entries(PREFIXED_NAMES)) {
 	test(`skills/${dir}/SKILL.md frontmatter name is prefixed`, () => {

package/tests/skill-registry-watcher.test.ts

@@ -16,7 +16,7 @@ for (const code of ["ENOENT", "EMFILE"]) {
 			import assert from "node:assert/strict";
 			import fs from "node:fs";
 			import { syncBuiltinESMExports } from "node:module";
-			import { join } from "node:path";
+			import { join, sep } from "node:path";
 			const root = ${JSON.stringify(root)};
 			const cwd = join(root, "workspace");
 			const home = join(root, "home");
@@ -52,6 +52,8 @@ for (const code of ["ENOENT", "EMFILE"]) {
 			});
 			const ctx = { cwd, hasUI: true, ui: { notify: (message, level) => notices.push({ message, level }) } };
 			const waitFor = async (predicate) => {
+				// Must stay well below the parent's spawnSync timeout so a missed
+				// outcome fails with this assertion instead of an opaque ETIMEDOUT.
 				const deadline = Date.now() + 5000;
 				while (!predicate() && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 25));
 				assert.ok(predicate(), "timed out waiting for watcher outcome");
@@ -66,18 +68,28 @@ for (const code of ["ENOENT", "EMFILE"]) {
 				if (code === "ENOENT" && process.platform !== "darwin" && process.platform !== "win32") {
 					// Force the transient missing-directory race at Node's real recursive
 					// readdir boundary, after watcher creation, not in our refresh callback.
+					// Older Node rescans the parent folder; Node 24.22+ resolves new files
+					// via lstat and only readdirs a newly added directory, so trigger with
+					// a directory and fail whichever readdir lands under assets.
 					const nativeReaddir = fs.readdirSync;
 					let reachedRescan = false;
 					fs.readdirSync = function (path, options) {
-						if (path === assets) {
+						if (typeof path === "string" && (path === assets || path.startsWith(assets + sep))) {
 							fs.readdirSync = nativeReaddir;
 							reachedRescan = true;
 							throw Object.assign(new Error("ENOENT: transient skill assets disappeared"), { code, syscall: "scandir", path });
 						}
 						return nativeReaddir(path, options);
 					};
-					fs.writeFileSync(join(assets, "trigger.txt"), "trigger directory rescan");
-					await waitFor(() => reachedRescan);
+					fs.mkdirSync(join(assets, "trigger"));
+					// The rescan race needs live recursive-watch events. Where the OS
+					// cannot deliver them (an exhausted inotify budget, some WSL2
+					// setups), waiting the full waitFor budget is pointless: settle
+					// briefly for the natural race, then exercise the public error
+					// listener directly, as the manual fallback below always did.
+					const raceDeadline = Date.now() + 2000;
+					while (!reachedRescan && Date.now() < raceDeadline) await new Promise((resolve) => setTimeout(resolve, 25));
+					fs.readdirSync = nativeReaddir;
 					// Newer Node versions swallow rescan ENOENT themselves. Still
 					// exercise our public error listener without requiring Node's bug.
 					if (!notices.some(({ message, level }) => level === "warning" && message.includes(code))) {
@@ -112,7 +124,7 @@ for (const code of ["ENOENT", "EMFILE"]) {
 			timeout: 15_000,
 			env: { ...process.env, GIT_CEILING_DIRECTORIES: root },
 		});
-		assert.equal(child.error, undefined, child.error?.message);
+		assert.equal(child.error, undefined, `${child.error?.message}\n${child.stderr}`);
 		assert.equal(child.status, 0, child.stderr);
 		assert.match(child.stdout, new RegExp(`SURVIVED ${code}`));
 	});