gentle-pi 2.6.3 → 2.7.0

package/extensions/gentle-shell.ts

@@ -1,13 +1,14 @@
 import { CustomEditor, keyHint, type ExtensionAPI, type ExtensionContext, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
 import { execFile, spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { statSync } from "node:fs";
+import { profilesFilePath, readProfilesFileResult } from "../lib/agent-profiles.ts";
 import * as os from "node:os";
 import { join } from "node:path";
 import { renderShellBar, renderShellSidebarBar, shellEnabled, type ShellBarModel, type ShellBarTheme } from "../lib/shell-bar.ts";
-import { CHANGE_STATUS, WorktreeChangesTracker, renderChangesWidget, type ChangedFile, type ChangesModel, type GitRunner, type LineCounter, type WorktreeChanges } from "../lib/shell-changes.ts";
+import { CHANGE_STATUS, renderChangesWidget, type ChangedFile, type ChangesModel, type GitRunner, type WorktreeChanges } from "../lib/shell-changes.ts";
 import { WorktreeChangesView } from "../lib/shell-changes-view.ts";
-import { SessionWorktreeRegistry, SESSION_WORKTREE_CHANGED, resolveSessionWorktree, toolWorktreePath, worktreeGitEnvironment, type WorktreeResolver } from "../lib/session-worktree-registry.ts";
+import { SessionWorktreeRegistry, resolveSessionWorktree, worktreeGitEnvironment, type WorktreeResolver } from "../lib/session-worktree-registry.ts";
 import { CARD_TONE, renderCard, type Card, type CardTheme } from "../lib/shell-card.ts";
 import { GentleAiDevBinaryOverrideError, resolveGentleAiDevBinaryOverride } from "../lib/gentle-ai-binary.ts";
 import { framePromptLines, PROMPT_HINT, PROMPT_STATE, withPromptHint, type PromptState } from "../lib/shell-prompt.ts";
@@ -15,6 +16,8 @@ import { accountIdFromToken, CODEX_PROVIDER, CODEX_USAGE_URL, parseCodexUsage, p
 import { UsageView } from "../lib/shell-usage-view.ts";
 import { sidebarPart } from "../lib/shell-sidebar.ts";
 import { installSidebar, invalidateSidebar } from "../lib/shell-sidebar-layout.ts";
+import { SessionChanges, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+import { installSessionChangeCapture } from "../lib/session-change-capture.ts";
 
 // Gentle Shell: the visual layer gentle-pi puts on top of pi. It installs the
 // status bar, the petal prompt, the working-tree changes widget and overlay,
@@ -39,6 +42,7 @@ interface ShellBarComponent {
 }
 
 interface BuildOptions {
+	profile?: string;
 	home?: string;
 	dirty?: number;
 	usage?: ProviderUsage;
@@ -47,6 +51,7 @@ interface BuildOptions {
 export type DevBinaryNotice = { state: "active"; path: string; sha256: string } | { state: "invalid"; reason: string };
 
 export interface ShellDeps {
+	activeProfile(): string | undefined;
 	fetch: typeof fetch;
 	now(): number;
 	devBinary(): DevBinaryNotice | undefined;
@@ -54,6 +59,31 @@ export interface ShellDeps {
 	gitRunner(cwd: string): GitRunner;
 }
 
+// The rail digest runs every frame. Cache parsing by file identity and metadata,
+// not just mtime: profile writes replace the store atomically. Keep the cache
+// local to this shell instance and recheck on the next frame after panel edits.
+export function createActiveProfileReader(env: NodeJS.ProcessEnv = process.env): () => string | undefined {
+	const path = profilesFilePath(env.GENTLE_PI_CONFIG_HOME ?? join(os.homedir(), ".pi", "gentle-ai"));
+	let fingerprint: string | undefined;
+	let name: string | undefined;
+	return () => {
+		try {
+			const stat = statSync(path, { bigint: true });
+			const next = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+			if (next !== fingerprint) {
+				const result = readProfilesFileResult(path);
+				name = result.status === "valid" ? result.file.active : undefined;
+				fingerprint = next;
+			}
+			return name;
+		} catch {
+			fingerprint = undefined;
+			name = undefined;
+			return undefined;
+		}
+	};
+}
+
 function ambientDevBinary(): DevBinaryNotice | undefined {
 	try {
 		const override = resolveGentleAiDevBinaryOverride();
@@ -64,7 +94,7 @@ function ambientDevBinary(): DevBinaryNotice | undefined {
 	}
 }
 
-const defaultShellDeps: ShellDeps = { fetch: (...args) => globalThis.fetch(...args), now: () => Date.now(), devBinary: ambientDevBinary, resolveWorktree: resolveSessionWorktree, gitRunner: shellGitRunner };
+const defaultShellDeps: Omit<ShellDeps, "activeProfile"> = { fetch: (...args) => globalThis.fetch(...args), now: () => Date.now(), devBinary: ambientDevBinary, resolveWorktree: resolveSessionWorktree, gitRunner: shellGitRunner };
 
 interface AssistantUsageEntry {
 	type: string;
@@ -104,6 +134,7 @@ export function buildShellBarModel(
 		.map(([, text]) => text);
 	return {
 		cwd: shortenHome(ctx.sessionManager.getCwd(), home),
+		profile: options.profile,
 		branch: footerData.getGitBranch(),
 		dirty: options.dirty,
 		sessionName: ctx.sessionManager.getSessionName(),
@@ -221,7 +252,6 @@ const CHANGES_WIDGET_KEY = "gentle-shell-changes";
 const CHANGES_COMMAND_NAME = "gentle:changes";
 const CHANGES_SHORTCUT_DEFAULT = "alt+g";
 const CHANGES_POLL_DEFAULT_MS = 2000;
-const CHANGES_WATCH_DEFAULT_MS = 5000;
 const GIT_TIMEOUT_MS = 5000;
 const OVERLAY_HEIGHT_RATIO = 0.8;
 const OVERLAY_MIN_ROWS = 8;
@@ -246,14 +276,6 @@ export function shellGitRunner(cwd: string, env: NodeJS.ProcessEnv = process.env
 	});
 }
 
-function lineCounter(cwd: string): LineCounter {
-	return async (path: string) => {
-		const text = await readFile(join(cwd, path), "utf8");
-		if (text.length === 0) return 0;
-		return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
-	};
-}
-
 export async function loadFileDiff(git: GitRunner, file: ChangedFile): Promise<string> {
 	const args = file.status === CHANGE_STATUS.UNTRACKED ? ["diff", "--no-index", "--", "/dev/null", file.path] : ["diff", "HEAD", "--", file.path];
 	const result = await git(args);
@@ -295,28 +317,19 @@ function changesPollMs(env: NodeJS.ProcessEnv): number {
 	return positiveMs(env.GENTLE_PI_SHELL_CHANGES_POLL_MS, CHANGES_POLL_DEFAULT_MS);
 }
 
-// Background watch: the widget and the bar follow edits made outside pi.
-// 0 or "off" disables it; tool events still refresh.
-function changesWatchMs(env: NodeJS.ProcessEnv): number | undefined {
-	const value = env.GENTLE_PI_SHELL_CHANGES_WATCH_MS?.trim().toLowerCase();
-	if (value === "0" || value === "off") return undefined;
-	return positiveMs(value, CHANGES_WATCH_DEFAULT_MS);
-}
-
 function changesFingerprint(model: ChangesModel): string {
-	return model.files.map((file) => `${file.path}:${file.status}:${file.added}:${file.deleted}`).join("|");
+	return model.files.map((file) => `${file.path}:${file.status}:${file.added}:${file.deleted}:${file.diffRevision ?? ""}:${file.countsUnavailable ?? ""}`).join("|");
 }
 
 interface OverlayDeps {
-	git(root: string): GitRunner;
+	loadDiff(root: string, file: ChangedFile): string;
 	worktrees(): WorktreeChanges[];
 	refresh(): Promise<ChangesModel>;
 	apply(ctx: ExtensionContext, model: ChangesModel): void;
 	pollMs: number;
 }
 
-// While the overlay is open, git is polled so edits made outside pi (nvim,
-// another agent, a git checkout) show up without reopening it.
+// Refresh only the captured session model. Never read live files or Git here.
 async function showChangesOverlay(ctx: ExtensionContext, deps: OverlayDeps): Promise<void> {
 	let host: ExternalEditorHost | undefined;
 	let view: WorktreeChangesView | undefined;
@@ -334,7 +347,7 @@ async function showChangesOverlay(ctx: ExtensionContext, deps: OverlayDeps): Pro
 				view = new WorktreeChangesView(deps.worktrees(), {
 					theme,
 					rows: () => Math.max(OVERLAY_MIN_ROWS, Math.floor(tui.terminal.rows * OVERLAY_HEIGHT_RATIO)),
-					loadDiff: (root, file) => loadFileDiff(deps.git(root), file),
+					loadDiff: (root, file) => Promise.resolve(deps.loadDiff(root, file)),
 					onOpen: (root, file) => done({ root, file }),
 					onRefresh: () => void refresh(),
 					onClose: () => done(null),
@@ -451,8 +464,9 @@ export async function fetchCodexUsage(token: string | undefined, fetchFn: typeof
 }
 
 export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = process.env, overrides: Partial<ShellDeps> = {}): void {
+	installSessionChangeCapture(pi, env, overrides.resolveWorktree ?? resolveSessionWorktree);
 	if (!shellEnabled(env)) return;
-	const deps: ShellDeps = { ...defaultShellDeps, ...overrides };
+	const deps: ShellDeps = { ...defaultShellDeps, activeProfile: createActiveProfileReader(env), ...overrides };
 	const usage = new UsageStore();
 	let renderHost: ShellRenderHost | undefined;
 	let usageFetchedAt = 0;
@@ -500,11 +514,9 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		},
 	});
 	let prompt: GentlePromptEditor | undefined;
-	let changes: WorktreeChangesTracker | undefined;
+	let changes: SessionChanges | undefined;
 	let registry: SessionWorktreeRegistry | undefined;
 	let currentContext: ExtensionContext | undefined;
-	const pendingTools = new Map<string, { sessionId: string; path?: string }>();
-	let watch: NodeJS.Timeout | undefined;
 	let shown = "";
 	const applyChanges = (ctx: ExtensionContext, model: ChangesModel) => {
 		const fingerprint = changesFingerprint(model);
@@ -515,22 +527,20 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 	const refreshChanges = async (ctx: ExtensionContext) => {
 		const tracker = changes;
 		if (!tracker || !ctx.hasUI || registry?.sessionId !== ctx.sessionManager.getSessionId()) return;
+		tracker.restore(ctx.sessionManager.getEntries());
 		const model = await tracker.refresh();
 		if (changes === tracker) applyChanges(ctx, model);
 	};
-	const stopWatch = () => {
-		if (watch) clearInterval(watch);
-		watch = undefined;
-	};
-	const unsubscribeWorktrees = pi.events.on(SESSION_WORKTREE_CHANGED, (data) => {
+	const unsubscribeWorktrees = pi.events.on(SESSION_CHANGE_EVENT, (data) => {
 		if (!currentContext || !registry || (data as { sessionId?: string } | undefined)?.sessionId !== registry.sessionId) return;
+		if ((data as { notice?: string }).notice) currentContext.ui.notify((data as { notice: string }).notice, "warning");
 		void refreshChanges(currentContext);
 	});
 	pi.registerTool({
 		name: "session_worktree_register",
 		renderShell: "self",
 		label: "Register session worktree",
-		description: "Register a worktree used by this session, including earlier work or opaque shell use. Only the same Git clone is accepted. Shows ALL dirty files in that root, including preexisting and untracked files; never infers roots from shell commands or prose.",
+		description: "Register a worktree in the same Git clone for session coordination. Registration does not attribute file changes; Changes shows captured write/edit operations only.",
 		parameters: { type: "object", required: ["path"], additionalProperties: false, properties: { path: { type: "string", description: "Worktree path to include in this session." } } } as never,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			if (!registry || registry.sessionId !== ctx.sessionManager.getSessionId()) throw new Error("No active session worktree registry.");
@@ -540,16 +550,13 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		},
 	});
 	pi.on("session_start", async (_event, ctx) => {
-		stopWatch();
 		registry?.close();
-		pendingTools.clear();
 		currentContext = ctx;
 		changes = undefined;
 		registry = new SessionWorktreeRegistry(pi, ctx.sessionManager, ctx.cwd, deps.resolveWorktree);
 		registry.start();
-		const sessionRegistry = registry;
 		if (!ctx.hasUI) return;
-		changes = new WorktreeChangesTracker(deps.gitRunner(ctx.cwd), deps.gitRunner, lineCounter, () => sessionRegistry.roots());
+		changes = new SessionChanges(ctx.sessionManager.getSessionId(), ctx.sessionManager.getEntries());
 		const tracker = changes;
 		ctx.ui.setFooter((tui, theme, footerData) => {
 			renderHost = { requestRender: () => tui.requestRender(), invalidateSidebar: () => invalidateSidebar(tui) };
@@ -558,7 +565,7 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 			// part for: model, effort, context, cost, session name and extension
 			// statuses. The digest is what keeps the fullscreen memo honest, and it
 			// rebuilds the model exactly as the narrow bottom bar does every frame.
-			const footerModel = () => buildShellBarModel(pi, ctx, footerData, { dirty: tracker.model.files.length, usage: usage.get(ctx.model?.provider ?? "") });
+			const footerModel = () => buildShellBarModel(pi, ctx, footerData, { dirty: tracker.model.files.length, usage: usage.get(ctx.model?.provider ?? ""), profile: deps.activeProfile() });
 			const part = sidebarPart(tui, "footer", bottom, {
 				digest: () => JSON.stringify(footerModel()),
 				render: (width) => renderShellSidebarBar(footerModel(), theme, width),
@@ -580,24 +587,15 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 				? (_tui, theme) => spaced(cardComponent(devBinaryCard(notice), theme, { expanded: true }))
 				: undefined,
 		);
-		await tracker.start();
 		if (changes !== tracker) return;
 		shown = "";
 		applyChanges(ctx, tracker.model);
-		stopWatch();
-		const watchMs = changesWatchMs(env);
-		if (watchMs) {
-			watch = setInterval(() => void refreshChanges(ctx), watchMs);
-			watch.unref();
-		}
 	});
 	pi.on("session_shutdown", () => {
-		stopWatch();
 		registry?.close();
 		registry = undefined;
 		changes = undefined;
 		currentContext = undefined;
-		pendingTools.clear();
 		unsubscribeWorktrees();
 	});
 	const openChanges = async (ctx: ExtensionContext) => {
@@ -605,19 +603,19 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		const tracker = changes;
 		const model = await tracker.refresh();
 		if (model.files.length === 0) {
-			ctx.ui.notify("No changes in the working tree.", "info");
+			ctx.ui.notify("No captured agent changes. Only successful write/edit operations from this session and its subagents are shown; shell changes are not attributed.", "info");
 			return;
 		}
-		await showChangesOverlay(ctx, { git: deps.gitRunner, worktrees: () => tracker.worktrees, refresh: () => tracker.refresh(), apply: applyChanges, pollMs: changesPollMs(env) });
+		await showChangesOverlay(ctx, { loadDiff: (root, file) => tracker.loadDiff(root, file), worktrees: () => tracker.worktrees, refresh: () => tracker.refresh(), apply: applyChanges, pollMs: changesPollMs(env) });
 	};
 	pi.registerCommand(CHANGES_COMMAND_NAME, {
-		description: "Browse this session's registered dirty worktrees and their changes against HEAD. Press o on a file to open $EDITOR.",
+		description: "Browse captured write/edit changes from this agent session and its subagents, excluding preexisting and external edits. Shell changes are not attributed. Press o to open $EDITOR.",
 		handler: async (_args, ctx) => openChanges(ctx),
 	});
 	const shortcut = changesShortcut(env);
 	if (shortcut) {
 		pi.registerShortcut(shortcut as Parameters<ExtensionAPI["registerShortcut"]>[0], {
-			description: "Open the working tree changes",
+			description: "Open captured agent session changes",
 			handler: async (ctx) => openChanges(ctx),
 		});
 	}
@@ -631,20 +629,4 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		await refreshChanges(ctx);
 		void refreshUsage(ctx, false);
 	});
-	pi.on("tool_execution_start", (event, ctx) => {
-		pendingTools.set(event.toolCallId, { sessionId: ctx.sessionManager.getSessionId() });
-	});
-	pi.on("tool_result", (event, ctx) => {
-		const pending = pendingTools.get(event.toolCallId);
-		if (pending?.sessionId === ctx.sessionManager.getSessionId()) pending.path = toolWorktreePath(event.toolName, event.input);
-	});
-	pi.on("tool_execution_end", async (event, ctx) => {
-		const pending = pendingTools.get(event.toolCallId);
-		pendingTools.delete(event.toolCallId);
-		if (!event.isError && pending?.path !== undefined && pending.sessionId === registry?.sessionId && pending.sessionId === ctx.sessionManager.getSessionId()) {
-			try { registry.register(pending.path, `tool:${event.toolName}`); }
-			catch { /* Non-project paths and missing roots do not expand the registry. */ }
-		}
-		await refreshChanges(ctx);
-	});
 }

package/lib/agents-runner.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isSessionChangeEvidence, type SessionChangeEvidence } from "./session-changes.ts";
 import type { Duplex, Readable, Writable } from "node:stream";
 import { stripVTControlCharacters } from "node:util";
 import { RESEARCH_SELECTION_ENV, RESEARCH_ARTIFACT_ENV, type ResearchArtifactIntent } from "./sdd-research-capabilities.ts";
@@ -100,7 +101,7 @@ export interface RunnerHooks {
 	onNotification?(task: TaskRecord, message: string): boolean | void;
 	onQuery?(task: TaskRecord, requestId: string, message: string): boolean | void;
 	// Parent-only observation of a paired successful filesystem tool, not prose.
-	onSuccessfulMutation?(task: TaskRecord, tool: { toolName: "write" | "edit"; toolCallId: string; path: string }): void | Promise<void>;
+	onSuccessfulMutation?(task: TaskRecord, tool: { toolName: "write" | "edit"; toolCallId: string; path: string; evidence?: SessionChangeEvidence }): void | Promise<void>;
 }
 
 export interface RemediationHarnessPlan { command?: string; naReason?: string }
@@ -821,7 +822,11 @@ export class AgentRunner {
 				live.mutationStarts.delete(event.callId);
 				const task = this.store.get(id);
 				if (mutation && task && raw.isError === false && !event.isError) {
-					try { void Promise.resolve(this.hooks.onSuccessfulMutation?.(task, mutation)).catch(() => {}); }
+					try {
+						const evidence = (raw.result as { details?: { gentleSessionChange?: unknown } } | undefined)?.details?.gentleSessionChange;
+						const observed = isSessionChangeEvidence(evidence) && evidence.id === mutation.toolCallId ? { ...mutation, evidence: structuredClone(evidence) } : mutation;
+						void Promise.resolve(this.hooks.onSuccessfulMutation?.(task, observed)).catch(() => {});
+					}
 					catch { /* Bookkeeping failure must not rewrite a successful tool or stop the child. */ }
 				}
 			}

package/lib/native-review-cli.ts

@@ -993,6 +993,15 @@ export const NATIVE_CLI_CONTRACTS = Object.freeze({
 	// remain dark because neither is proven to reach the negotiated START
 	// path Pi consumes.
 	"2.9.0": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	// v2.9.1 shipped restoring compatible OpenCode review consent (#4584) and
+	// deriving Claude Code SDD dispatch authority from the session transcript
+	// (#4575, #4551). Ground-truthed by diffing contracts/review-integration/v2
+	// and contracts/review-provider-contract between the v2.9.0 and v2.9.1 tags
+	// in the gentle-ai source tree: zero bytes changed. Neither change touches
+	// the closed START/STATUS fields this row negotiates, so it repeats 2.9.0
+	// exactly. riskEvidence and hint remain dark because neither is proven to
+	// reach the negotiated START path Pi consumes.
+	"2.9.1": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
 });
 
 export interface NativeReviewProcessDiagnostics {

package/lib/session-change-capture.ts

@@ -0,0 +1,87 @@
+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 });
+		pi.events.emit(SESSION_CHANGE_EVENT, { sessionId: store.sessionId, notice: store.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,140 @@
+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;
+	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 }))));
+	}
+	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,7 @@ export { gaugeTone, renderGauge, type GaugeTone };
 // verified without a live TUI.
 
 export interface ShellBarModel {
+	profile?: string;
 	cwd: string;
 	branch: string | null;
 	dirty: number | undefined;
@@ -138,7 +139,11 @@ export function renderShellSidebarBar(model: ShellBarModel, theme: ShellBarTheme
 		},
 		{
 			title: "Model",
-			lines: [value(model.modelId), ...(model.effort ? [`${label("Effort")} ${theme.fg(ROLE.EFFORT, model.effort)}`] : [])],
+			lines: [
+				value(model.modelId),
+				...(model.effort ? [`${label("Effort")} ${theme.fg(ROLE.EFFORT, model.effort)}`] : []),
+				...(model.profile ? [`${label("Profile")} ${value(sanitizeStatus(model.profile))}`] : []),
+			],
 		},
 		{
 			title: "Context",

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,6 +19,8 @@ export interface ChangedFile {
 	added: number;
 	deleted: number;
 	status: ChangeStatus;
+	countsUnavailable?: string;
+	diffRevision?: string;
 }
 
 export interface ChangesModel {
@@ -115,7 +117,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" : ""}`;
 }
 
 // One line: summary, the files joined by dots, and the command pushed to
@@ -124,7 +126,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" : ""}`;
 	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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gentle-pi",
-	"version": "2.6.3",
+	"version": "2.7.0",
 	"description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
 	"license": "MIT",
 	"type": "module",