gentle-pi 2.6.4 → 3.0.0

package/lib/session-change-capture.ts

@@ -0,0 +1,88 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
+import { lstat, realpath } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { resolveSessionWorktree, type WorktreeResolver } from "./session-worktree-registry.ts";
+import { SessionChanges, readChangeSnapshot, sameSnapshot, textSnapshot, isSessionChangeEvidence,
+	SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT, SESSION_CHANGE_RELAY, type SessionChangeEvidence, type ChangeSnapshot } from "./session-changes.ts";
+
+interface Pending { sessionId: string; inputPath: string; path: string; root: string; relativePath: string; before: ChangeSnapshot; toolName: string; evidence?: SessionChangeEvidence }
+const normalized = (text: string) => text.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+const unknown = (): ChangeSnapshot => ({ kind: "unavailable", reason: "Tool snapshots could not be verified; diff unavailable." });
+
+/** Observe explicit write/edit outcomes, never infer ownership from Git status or shell text. */
+export function installSessionChangeCapture(pi: ExtensionAPI, env: NodeJS.ProcessEnv = process.env, resolver: WorktreeResolver = resolveSessionWorktree): void {
+	const child = env.GENTLE_PI_AGENTS_CHILD === "1";
+	const pending = new Map<string, Pending>();
+	let current: ExtensionContext | undefined;
+	let store: SessionChanges | undefined;
+	const publish = (evidence: SessionChangeEvidence) => {
+		if (!current || !store || current.sessionManager.getSessionId() !== store.sessionId) return;
+		if (store.record(evidence)) pi.appendEntry(SESSION_CHANGE_ENTRY, { sessionId: store.sessionId, evidence });
+		const notice = store.takeNotice();
+		pi.events.emit(SESSION_CHANGE_EVENT, { sessionId: store.sessionId, ...(notice ? { notice } : {}) });
+	};
+	pi.on("session_start", (_event, ctx) => {
+		pending.clear(); current = ctx;
+		store = new SessionChanges(ctx.sessionManager.getSessionId(), ctx.sessionManager.getEntries());
+	});
+	const off = pi.events.on(SESSION_CHANGE_RELAY, (value) => {
+		const data = value as { sessionId?: string; evidence?: unknown };
+		if (child || !current || data?.sessionId !== current.sessionManager.getSessionId() || !isSessionChangeEvidence(data.evidence)) return;
+		try {
+			const own = resolver(current.cwd, current.cwd);
+			const target = resolver(data.evidence.root, current.cwd);
+			if (own && target?.root === data.evidence.root && own.commonDir === target.commonDir) publish(data.evidence);
+		} catch { /* Observation cannot change tool outcomes. */ }
+	});
+	pi.on("tool_call", async (event, ctx) => {
+		const input = event.input as Record<string, unknown>;
+		if (!["write", "edit"].includes(event.toolName) || typeof input.path !== "string" || pending.size >= 32) return;
+		const sessionId = ctx.sessionManager.getSessionId();
+		try {
+			let spelling = input.path.replace(/^@/, "").replace(/[\u00a0\u2000-\u200a\u202f\u205f\u3000]/g, " ");
+			if (spelling === "~" || spelling.startsWith("~/")) spelling = homedir() + spelling.slice(1);
+			const path = resolve(ctx.cwd, spelling);
+			try { if ((await lstat(path)).isSymbolicLink()) return; } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") return; }
+			let ancestor = dirname(path);
+			for (let depth = 0; depth < 32; depth++) {
+				try { await lstat(ancestor); break; } catch { if (dirname(ancestor) === ancestor) return; ancestor = dirname(ancestor); }
+			}
+			const canonicalAncestor = await realpath(ancestor);
+			const canonicalPath = resolve(canonicalAncestor, relative(ancestor, path));
+			const own = resolver(ctx.cwd, ctx.cwd), target = resolver(canonicalAncestor, ctx.cwd);
+			if (!own || !target || own.commonDir !== target.commonDir) return;
+			const before = await readChangeSnapshot(canonicalPath);
+			if (ctx.sessionManager.getSessionId() !== sessionId || current?.sessionManager.getSessionId() !== sessionId) return;
+			pending.set(event.toolCallId, { sessionId, inputPath: input.path, path: canonicalPath, root: target.root, relativePath: relative(target.root, canonicalPath), before, toolName: event.toolName });
+		} catch { /* No bookkeeping error blocks an edit. */ }
+	});
+	pi.on("tool_result", async (event, ctx) => {
+		const item = pending.get(event.toolCallId);
+		if (!item || item.sessionId !== ctx.sessionManager.getSessionId() || item.toolName !== event.toolName || event.input.path !== item.inputPath || event.isError !== false) { pending.delete(event.toolCallId); return; }
+		try {
+			const after = await readChangeSnapshot(item.path);
+			let before = item.before;
+			let verified = after;
+			if (event.toolName === "write" && after.kind === "text" && (typeof event.input.content !== "string" || !sameSnapshot(after, textSnapshot(event.input.content)))) {
+				before = unknown(); verified = unknown();
+			}
+			if (event.toolName === "edit" && before.kind === "text" && after.kind === "text") {
+				const patch = (event.details as { patch?: unknown } | undefined)?.patch;
+				if (typeof event.input.path !== "string" || patch !== generateUnifiedPatch(event.input.path, normalized(before.text), normalized(after.text))) { before = unknown(); verified = unknown(); }
+			}
+			if (item.sessionId !== ctx.sessionManager.getSessionId() || pending.get(event.toolCallId) !== item) return;
+			item.evidence = { id: event.toolCallId, root: item.root, path: item.relativePath, before, after: verified };
+			// Use the existing RPC tool-result envelope, not a new IPC channel or a model message.
+			if (child) return { details: { ...(event.details && typeof event.details === "object" ? event.details : {}), gentleSessionChange: item.evidence } };
+		} catch { pending.delete(event.toolCallId); }
+	});
+	pi.on("tool_execution_end", (event, ctx) => {
+		const item = pending.get(event.toolCallId); pending.delete(event.toolCallId);
+		if (!child && event.isError === false && item?.evidence && item.sessionId === ctx.sessionManager.getSessionId()) {
+			try { publish(item.evidence); } catch { /* Preserve the tool's outcome. */ }
+		}
+	});
+	pi.on("session_shutdown", () => { pending.clear(); current = undefined; store = undefined; off(); });
+}

package/lib/session-changes.ts

@@ -0,0 +1,147 @@
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
+import { changesModel, type ChangedFile, type WorktreeChanges } from "./shell-changes.ts";
+
+export const SESSION_CHANGE_ENTRY = "gentle-pi.session-change/v1";
+export const SESSION_CHANGE_EVENT = "gentle-pi:session-change";
+export const SESSION_CHANGE_RELAY = "gentle-pi:child-session-change";
+export const MAX_CHANGE_BYTES = 64 * 1024;
+const MAX_RECORDS = 256;
+const MAX_SESSION_BYTES = 4 * 1024 * 1024;
+const MAX_LINES = 2000;
+export type ChangeSnapshot = { kind: "text"; text: string } | { kind: "absent" } | { kind: "unavailable"; reason: string };
+export interface SessionChangeEvidence {
+	id: string;
+	root: string;
+	path: string;
+	before: ChangeSnapshot;
+	after: ChangeSnapshot;
+}
+type Entry = { type?: string; customType?: string; data?: unknown };
+interface FileState { before: ChangeSnapshot; after: ChangeSnapshot; unavailable?: string; diff?: string }
+
+const unavailable = (reason: string): ChangeSnapshot => ({ kind: "unavailable", reason });
+export function textSnapshot(text: string): ChangeSnapshot {
+	if (Buffer.byteLength(text) > MAX_CHANGE_BYTES || text.split("\n", MAX_LINES + 1).length > MAX_LINES) return unavailable("File exceeds the session diff limit.");
+	if (text.includes("\0")) return unavailable("Binary file; line counts unavailable.");
+	return { kind: "text", text };
+}
+
+/** Read only the named mutation target. Never traverse, follow symlinks, or open a FIFO for blocking I/O. */
+export async function readChangeSnapshot(path: string): Promise<ChangeSnapshot> {
+	let file: Awaited<ReturnType<typeof open>> | undefined;
+	try {
+		file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+		const stat = await file.stat();
+		if (!stat.isFile() || stat.size > MAX_CHANGE_BYTES) return unavailable("Nonregular or large file; diff unavailable.");
+		const buffer = Buffer.alloc(MAX_CHANGE_BYTES + 1);
+		const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+		if (bytesRead !== stat.size) return unavailable("File changed while its snapshot was being read.");
+		return textSnapshot(new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead)));
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "ENOENT" ? { kind: "absent" } : unavailable("Snapshot unavailable.");
+	} finally { await file?.close().catch(() => {}); }
+}
+
+function validSnapshot(value: unknown): value is ChangeSnapshot {
+	if (!value || typeof value !== "object") return false;
+	const v = value as ChangeSnapshot;
+	return v.kind === "absent" || (v.kind === "text" && typeof v.text === "string" && textSnapshot(v.text).kind === "text") ||
+		(v.kind === "unavailable" && typeof v.reason === "string" && v.reason.length <= 200);
+}
+export function isSessionChangeEvidence(value: unknown): value is SessionChangeEvidence {
+	if (!value || typeof value !== "object") return false;
+	const v = value as SessionChangeEvidence;
+	return typeof v.id === "string" && v.id.length > 0 && v.id.length <= 256 &&
+		typeof v.root === "string" && isAbsolute(v.root) && v.root.length <= 4096 &&
+		typeof v.path === "string" && v.path.length > 0 && v.path.length <= 4096 &&
+		!isAbsolute(v.path) && !/[\0\r\n]/.test(v.root + v.path) &&
+		!v.path.split(/[\\/]/).some(part => part === ".." || part === ".git") &&
+		validSnapshot(v.before) && validSnapshot(v.after);
+}
+export const sameSnapshot = (a: ChangeSnapshot, b: ChangeSnapshot): boolean =>
+	a.kind === b.kind && (a.kind === "absent" || (a.kind === "text" && b.kind === "text" && a.text === b.text));
+const snapshotText = (value: ChangeSnapshot) => value.kind === "text" ? value.text : "";
+
+export class SessionChanges {
+	private readonly seen = new Set<string>();
+	private readonly files = new Map<string, Map<string, FileState>>();
+	private bytes = 0;
+	private announced = false;
+	notice: string | undefined;
+	readonly sessionId: string;
+	private cached: WorktreeChanges[] | undefined;
+	constructor(sessionId: string, entries: readonly Entry[] = []) { this.sessionId = sessionId; this.restore(entries); }
+
+	restore(entries: readonly Entry[]): void {
+		for (const entry of entries) {
+			if (entry.type !== "custom" || entry.customType !== SESSION_CHANGE_ENTRY) continue;
+			const data = entry.data as { sessionId?: string; evidence?: unknown } | undefined;
+			if (data?.sessionId === this.sessionId && isSessionChangeEvidence(data.evidence)) this.record(data.evidence);
+		}
+	}
+	record(evidence: SessionChangeEvidence): boolean {
+		if (!isSessionChangeEvidence(evidence) || this.seen.has(evidence.id)) return false;
+		const bytes = Buffer.byteLength(JSON.stringify(evidence));
+		if (this.seen.size >= MAX_RECORDS || this.bytes + bytes > MAX_SESSION_BYTES) {
+			this.notice = "Session change capture limit reached; additional changes are not displayed.";
+			return false;
+		}
+		this.seen.add(evidence.id);
+		this.bytes += bytes;
+		if (sameSnapshot(evidence.before, evidence.after)) return false;
+		let files = this.files.get(evidence.root);
+		if (!files) this.files.set(evidence.root, files = new Map());
+		const previous = files.get(evidence.path);
+		const state: FileState = { before: previous?.before ?? structuredClone(evidence.before), after: structuredClone(evidence.after) };
+		state.unavailable = previous?.unavailable;
+		if (previous && !sameSnapshot(previous.after, evidence.before)) state.unavailable = "Snapshot continuity lost (external or unobserved edit); session diff unavailable.";
+		if (evidence.before.kind === "unavailable") state.unavailable ??= evidence.before.reason;
+		if (evidence.after.kind === "unavailable") state.unavailable ??= evidence.after.reason;
+		// Keep the final state even after an own revert, to detect later external edits.
+		this.patch(evidence.path, state);
+		files.set(evidence.path, state);
+		this.cached = undefined;
+		return true;
+	}
+	private changed(root: string): ChangedFile[] {
+		return [...(this.files.get(root) ?? [])].flatMap(([path, state]) => {
+			if (!state.unavailable && sameSnapshot(state.before, state.after)) return [];
+			const patch = this.patch(path, state);
+			const patchLines = patch.split("\n");
+			const firstHunk = patchLines.findIndex(line => line.startsWith("@@"));
+			const lines = firstHunk < 0 ? [] : patchLines.slice(firstHunk + 1);
+			return [{
+				path, diffRevision: createHash("sha256").update(patch).digest("hex"), status: state.before.kind === "absent" ? "added" as const : state.after.kind === "absent" ? "deleted" as const : "modified" as const,
+				added: state.unavailable ? 0 : lines.filter(line => line.startsWith("+")).length,
+				deleted: state.unavailable ? 0 : lines.filter(line => line.startsWith("-")).length,
+				...(state.unavailable ? { countsUnavailable: state.unavailable } : {}),
+			}];
+		});
+	}
+	private patch(path: string, state: FileState): string {
+		if (state.unavailable) return state.unavailable;
+		return state.diff ??= generateUnifiedPatch(path, snapshotText(state.before), snapshotText(state.after));
+	}
+	get worktrees(): WorktreeChanges[] {
+		return this.cached ??= [...this.files.keys()].map(root => ({ root, model: changesModel(this.changed(root)) })).filter(tree => tree.model.files.length > 0);
+	}
+	get model() {
+		const trees = this.worktrees;
+		return { ...changesModel(trees.flatMap(tree => tree.model.files.map(file => ({ ...file, path: trees.length === 1 ? file.path : tree.root + "/" + file.path })))), ...(this.notice ? { notice: this.notice } : {}) };
+	}
+	/** Return the capture-limit notice once, for a single user notification. The `notice` field stays set. */
+	takeNotice(): string | undefined {
+		if (!this.notice || this.announced) return undefined;
+		this.announced = true;
+		return this.notice;
+	}
+	async refresh() { return this.model; }
+	loadDiff(root: string, file: ChangedFile): string {
+		const state = this.files.get(root)?.get(file.path);
+		return state ? this.patch(file.path, state) : "No captured agent diff for this file.";
+	}
+}

package/lib/shell-bar.ts

@@ -11,6 +11,8 @@ export { gaugeTone, renderGauge, type GaugeTone };
 // verified without a live TUI.
 
 export interface ShellBarModel {
+	profile?: string;
+	changes?: { files: number; added: number; deleted: number; notice?: string };
 	cwd: string;
 	branch: string | null;
 	dirty: number | undefined;
@@ -122,7 +124,7 @@ function joinSegments(segments: string[], theme: ShellBarTheme): string {
 export function renderShellSidebarBar(model: ShellBarModel, theme: ShellBarTheme, width: number): string[] {
 	const value = (text: string) => theme.fg(ROLE.VALUE, theme.bold(text));
 	const label = (text: string) => theme.fg(ROLE.LABEL, text);
-	const dirty = model.dirty ? theme.fg(ROLE.DIRTY, `±${model.dirty}`) : "";
+	const changes = model.changes;
 	const branch = model.branch ? `${label("Branch")} ${value(model.branch)}` : "";
 	const percent = model.contextPercent === null ? "?%" : `${Math.round(model.contextPercent)}%`;
 	const capacity = label(`${formatTokens(model.contextWindow)} tokens`);
@@ -132,23 +134,35 @@ export function renderShellSidebarBar(model: ShellBarModel, theme: ShellBarTheme
 			title: "Project",
 			lines: [
 				value(model.cwd),
-				...((branch || dirty) ? [[branch, dirty].filter(Boolean).join(" ")] : []),
+				...(branch ? [branch] : []),
 				...(model.sessionName ? [`${label("Session")} ${value(model.sessionName)}`] : []),
+				`${label("Model")} ${value(model.modelId)}`,
+				...(model.effort ? [`${label("Effort")} ${theme.fg(ROLE.EFFORT, model.effort)}`] : []),
+				...(model.profile ? [`${label("Profile")} ${value(sanitizeStatus(model.profile))}`] : []),
 			],
 		},
 		{
-			title: "Model",
-			lines: [value(model.modelId), ...(model.effort ? [`${label("Effort")} ${theme.fg(ROLE.EFFORT, model.effort)}`] : [])],
-		},
-		{
-			title: "Context",
-			lines: [`${paintGauge(model.contextPercent, theme)} ${value(percent)}  ${capacity}`],
+			title: "Changes",
+			lines: [
+				changes?.files
+					? `${changes.files} ${changes.files === 1 ? "file" : "files"} · ${theme.fg("success", `+${changes.added}`)} ${theme.fg("error", `−${changes.deleted}`)}`
+					: label("No captured changes"),
+				...(changes?.notice ? [theme.fg("warning", sanitizeStatus(changes.notice))] : []),
+				label("/gentle:changes"),
+			],
 		},
 		{
 			title: "Usage",
-			lines: [`${label("Cost")} ${value(formatCost(model.costTotal, model.subscription))}`, ...(usage ? [usage] : [])],
+			lines: [
+				`${label("Context")} ${paintGauge(model.contextPercent, theme)} ${value(percent)}`,
+				capacity,
+				`${label("Cost")} ${value(formatCost(model.costTotal, model.subscription))}`,
+				...(usage ? [usage] : []),
+			],
 		},
-		...(model.statuses.length ? [{ title: "Integrations", lines: model.statuses.map((status) => theme.fg(ROLE.STATUS, sanitizeStatus(status))) }] : []),
+		{ title: "Integrations", lines: model.statuses.length
+			? model.statuses.map((status) => theme.fg(ROLE.STATUS, sanitizeStatus(status)))
+			: [label("No status reported")] },
 	];
 	// Pre-wrap values before indenting so Unicode/ANSI continuation lines keep
 	// the same inset without consuming the card's right border.

package/lib/shell-card.ts

@@ -60,12 +60,8 @@ function bodyLines(card: Card, innerWidth: number): string[] {
 	return card.body.flatMap((paragraph) => (paragraph === "" ? [""] : wrapTextWithAnsi(paragraph, innerWidth)));
 }
 
-// The left rail, corners included, carries the tone at full strength; the
-// rest of the frame stays in the theme's border color, so the state reads from the rail.
-const FRAME_ROLE = "border";
-
-function soft(theme: CardTheme, _tone: CardTone, text: string): string {
-	return theme.fg(FRAME_ROLE, text);
+function frame(theme: CardTheme, tone: CardTone, text: string): string {
+	return theme.fg(TONE_ROLE[tone], text);
 }
 
 export function cardTop(card: Card, theme: CardTheme, width: number, hint?: string): string {
@@ -74,7 +70,7 @@ export function cardTop(card: Card, theme: CardTheme, width: number, hint?: stri
 	if (targetWidth < 5) {
 		const left = theme.fg(TONE_ROLE[card.tone], "╭");
 		if (targetWidth === 1) return left;
-		return left + soft(theme, card.tone, `${rule(targetWidth - 2)}╮`);
+		return left + frame(theme, card.tone, `${rule(targetWidth - 2)}╮`);
 	}
 
 	const title = titleText(card, theme);
@@ -86,7 +82,7 @@ export function cardTop(card: Card, theme: CardTheme, width: number, hint?: stri
 	const styledTitleWidth = title.width <= titleWidth ? title.width : visibleWidth(styledTitle);
 	const fill = rule(targetWidth - styledTitleWidth - 5 - hintWidth);
 	const tail = shownHint ? ` ${theme.fg(HINT_ROLE, shownHint)} ` : "";
-	return theme.fg(TONE_ROLE[card.tone], "╭") + soft(theme, card.tone, "─ ") + styledTitle + soft(theme, card.tone, ` ${fill}`) + tail + soft(theme, card.tone, "╮");
+	return theme.fg(TONE_ROLE[card.tone], "╭") + frame(theme, card.tone, "─ ") + styledTitle + frame(theme, card.tone, ` ${fill}`) + tail + frame(theme, card.tone, "╮");
 }
 
 export function cardLine(text: string, tone: CardTone, theme: CardTheme, width: number): string {
@@ -94,13 +90,13 @@ export function cardLine(text: string, tone: CardTone, theme: CardTheme, width:
 	if (targetWidth === 0) return "";
 	const left = theme.fg(TONE_ROLE[tone], "│");
 	if (targetWidth === 1) return left;
-	if (targetWidth === 2) return left + soft(theme, tone, "│");
-	if (targetWidth === 3) return `${left} ${soft(theme, tone, "│")}`;
+	if (targetWidth === 2) return left + frame(theme, tone, "│");
+	if (targetWidth === 3) return `${left} ${frame(theme, tone, "│")}`;
 
 	const innerWidth = targetWidth - FRAME_COLUMNS;
 	const clipped = innerWidth === 0 ? "" : truncateToWidth(text, innerWidth, "…");
 	const padding = " ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
-	return `${left} ${clipped}${padding} ${soft(theme, tone, "│")}`;
+	return `${left} ${clipped}${padding} ${frame(theme, tone, "│")}`;
 }
 
 export function cardBottom(tone: CardTone, theme: CardTheme, width: number): string {
@@ -108,7 +104,7 @@ export function cardBottom(tone: CardTone, theme: CardTheme, width: number): str
 	if (targetWidth === 0) return "";
 	const left = theme.fg(TONE_ROLE[tone], "╰");
 	if (targetWidth === 1) return left;
-	return left + soft(theme, tone, `${rule(targetWidth - 2)}╯`);
+	return left + frame(theme, tone, `${rule(targetWidth - 2)}╯`);
 }
 
 export function cardInnerWidth(width: number): number {

package/lib/shell-changes-view.ts

@@ -74,6 +74,7 @@ const FILE_STATUS = {
 } as const;
 
 function fileCounts(file: ChangedFile, theme: ChangesViewTheme): string {
+	if (file.countsUnavailable) return theme.fg("dim", "counts unavailable");
 	return `${theme.fg(ROLE.ADDED, `+${file.added}`)} ${theme.fg(ROLE.REMOVED, `-${file.deleted}`)}`;
 }
 
@@ -126,7 +127,7 @@ function displayText(text: string): string {
 }
 
 function fingerprint(file: ChangedFile): string {
-	return `${file.status}:${file.added}:${file.deleted}`;
+	return `${file.status}:${file.added}:${file.deleted}:${file.diffRevision ?? ""}:${file.countsUnavailable ?? ""}`;
 }
 
 export interface WorktreeChangesViewDeps {

package/lib/shell-changes.ts

@@ -19,12 +19,15 @@ export interface ChangedFile {
 	added: number;
 	deleted: number;
 	status: ChangeStatus;
+	countsUnavailable?: string;
+	diffRevision?: string;
 }
 
 export interface ChangesModel {
 	files: ChangedFile[];
 	added: number;
 	deleted: number;
+	notice?: string;
 }
 
 export interface ChangesSnapshot {
@@ -115,7 +118,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}`;
+	return `${model.files.length} ${noun} · +${model.added} −${model.deleted}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}${model.notice ? " · capture limit reached" : ""}`;
 }
 
 // One line: summary, the files joined by dots, and the command pushed to
@@ -124,7 +127,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}`)}`;
+	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 hint = theme.fg("dim", CHANGES_COMMAND);
 	const list = model.files.map((file) => theme.fg("muted", file.path)).join(` ${dot} `);
 	const left = `${head} ${dot} ${list}`;

package/lib/shell-prompt.ts

@@ -23,9 +23,24 @@ const PETAL_TONE = {
 
 export type PetalTone = (typeof PETAL_TONE)[keyof typeof PETAL_TONE];
 
-// The Gentle themes map these to the rose ramp: active pink, rose, soft
-// rose, deep pink. The spin walks the ramp one shade per frame.
-const PETAL_TONE_FRAMES = [PETAL_TONE.BRIGHT, PETAL_TONE.ROSE, PETAL_TONE.SOFT, PETAL_TONE.DEEP] as const;
+// Keep Pi's original loader cadence while carrying the banner's reflected-light
+// language into the compact working labels. The highlight enters before the
+// word, crosses it as a soft symmetric wave, then exits before wrapping.
+export const SHELL_PULSE_MS = 80;
+export const SHELL_SCANNER_STEPS = 15;
+const SCANNER_ENTRY_OFFSET = 3;
+
+/** Banner-style reflected-light wave across text; foreground only. */
+export function scanWorkingText(text: string, tick: number, fg: (role: string, text: string) => string): string {
+	const phase = ((Math.floor(tick) % SHELL_SCANNER_STEPS) + SHELL_SCANNER_STEPS) % SHELL_SCANNER_STEPS;
+	const head = phase - SCANNER_ENTRY_OFFSET;
+	return Array.from(text, (char, index) => {
+		const distance = Math.abs(head - index);
+		const role = distance === 0 ? "borderAccent" : distance === 1 ? "accent" : distance === 2 ? "thinkingHigh" : "muted";
+		return fg(role, char);
+	}).join("");
+}
+const PETAL_TONE_FRAMES = [PETAL_TONE.DEEP, PETAL_TONE.SOFT, PETAL_TONE.ROSE, PETAL_TONE.BRIGHT, PETAL_TONE.ROSE, PETAL_TONE.SOFT, PETAL_TONE.DEEP, PETAL_TONE.DEEP] as const;
 
 export interface PromptFrameOptions {
 	state: PromptState;
@@ -46,7 +61,7 @@ const FAKE_CURSOR = "\x1b[7m \x1b[0m";
 const SCROLL_INDICATOR = /[↑↓] \d+ more/;
 const STATE_LABEL: Record<PromptState, string | undefined> = {
 	[PROMPT_STATE.IDLE]: undefined,
-	[PROMPT_STATE.WORKING]: "working",
+	[PROMPT_STATE.WORKING]: "working…",
 	[PROMPT_STATE.QUEUED]: "queued",
 };
 
@@ -71,13 +86,15 @@ function rule(length: number): string {
 
 function topRule(width: number, options: PromptFrameOptions, indicator: string | undefined): string {
 	const label = indicator ?? STATE_LABEL[options.state];
+	const scanning = options.state === PROMPT_STATE.WORKING;
 	const glyph = petalGlyph(options.state, options.tick);
 	const petal = options.fg(petalTone(options.state, options.tick), options.bold ? options.bold(glyph) : glyph);
-	const labelText = label ? ` ${options.fg(LABEL_ROLE, label)}` : "";
-	const labelWidth = label ? label.length + 1 : 0;
-	const fill = width - 3 - visibleWidth(glyph) - labelWidth - 1 - 1;
+	const paintedLabel = label && scanning && !indicator ? scanWorkingText(label, options.tick, options.fg) : label ? options.fg(LABEL_ROLE, label) : "";
+	const title = [petal, paintedLabel].filter(Boolean).join(" ");
+	const titleWidth = visibleWidth(glyph) + (label ? visibleWidth(label) + (glyph ? 1 : 0) : 0);
+	const fill = width - titleWidth - 5;
 	if (fill < 0) return options.borderColor(`╭${rule(width - 2)}╮`);
-	return options.borderColor("╭─ ") + petal + labelText + options.borderColor(` ${rule(fill)}╮`);
+	return options.borderColor("╭─ ") + title + options.borderColor(` ${rule(fill)}╮`);
 }
 
 function bottomRule(width: number, options: PromptFrameOptions, indicator: string | undefined): string {

package/lib/shell-sidebar-banner.ts

@@ -2,10 +2,10 @@ import { visibleWidth } from "@earendil-works/pi-tui";
 import type { ShellBarTheme } from "./shell-bar.ts";
 
 export function renderSidebarBanner(theme: ShellBarTheme, width: number): string[] {
-	const label = "✿ Gentle-Pi ✿";
+	const label = "✿ Gentle Shell ✿";
 	const space = width - visibleWidth(label);
 	if (space < 0) return [];
 	// Gentleman's accent is pink; card titles use a separate champagne role.
-	const title = theme.fg("accent", "✿") + " " + theme.fg("text", "Gentle-Pi") + " " + theme.fg("accent", "✿");
+	const title = theme.fg("accent", "✿") + " " + theme.fg("text", "Gentle Shell") + " " + theme.fg("accent", "✿");
 	return [" ".repeat(Math.floor(space / 2)) + title + " ".repeat(Math.ceil(space / 2))];
 }

package/lib/shell-sidebar-layout.ts

@@ -134,7 +134,7 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 		}
 		try {
 			const contentWidth = scroll.getContentWidth(RAIL_WIDTH);
-			const sections = ["footer", "changes", "agents", "todo"].map((key) => {
+			const sections = ["footer", "agents", "todo"].map((key) => {
 				const component = state.parts.get(key);
 				const lines = [...(component?.render(contentWidth - RAIL_PADDING * 2) ?? [])];
 				while (lines.length && lines[lines.length - 1]?.trim() === "") lines.pop();
@@ -171,7 +171,10 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 			if (roots.has(root)) return;
 			const original = root[NODE]!;
 			const descriptor = Object.getOwnPropertyDescriptor(root, NODE);
-			const left = { render: (width: number) => root.render(width), invalidate() {}, [NODE]: () => original.call(root) };
+			// Fullscreen gives this stretched stack an explicit viewport height.
+			// Its intrinsic-height probe is unused; real painting traverses NODE.
+			// Delegating that probe to root.render would render the transcript twice.
+			const left = { render: () => [], invalidate() {}, [NODE]: () => original.call(root) };
 			const replacement = () => {
 				if (!prepare(tui.terminal.columns, root)) return original.call(root);
 				const current = prepared!;