gentle-pi 2.6.4 → 2.7.0

package/tests/gentle-shell.test.ts

@@ -1,12 +1,12 @@
 import assert from "node:assert/strict";
 import { execFileSync, execFile } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import { initTheme, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TUI } from "@earendil-works/pi-tui";
-import installGentleShell, { buildShellBarModel, changesShortcut, devBinaryCard, fetchCodexUsage, loadFileDiff, shellGitRunner, openInExternalEditor, type GentlePromptEditor } from "../extensions/gentle-shell.ts";
+import installGentleShell, { buildShellBarModel, createActiveProfileReader, changesShortcut, devBinaryCard, fetchCodexUsage, loadFileDiff, shellGitRunner, openInExternalEditor, type GentlePromptEditor } from "../extensions/gentle-shell.ts";
 import { CHANGE_STATUS } from "../lib/shell-changes.ts";
 import { sidebarState, type SidebarRail } from "../lib/shell-sidebar.ts";
 import type { ShellBarTheme } from "../lib/shell-bar.ts";
@@ -232,7 +232,8 @@ test("gentleShell installs the footer on session_start when a UI exists", () =>
 
 test("the fullscreen Status rail carries a live digest so a model switch refreshes it", async () => {
 	const { pi, handlers } = fakePi();
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" });
+	let profile: string | undefined = "team";
+	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" }, { activeProfile: () => profile });
 	const entries: unknown[] = [];
 	const { ctx, ui } = fakeContext({ entries });
 	await fire(handlers, "session_start", ctx);
@@ -248,6 +249,14 @@ test("the fullscreen Status rail carries a live digest so a model switch refresh
 		assert.equal(typeof rail.digest, "function", "the Status card paints live state and must declare a digest");
 		assert.match(rail.render(46).join("\n"), /gpt-5\.5/);
 
+		assert.match(rail.render(46).join("\n"), /Profile.*team/);
+		const beforeProfile = live();
+		profile = "other";
+		assert.notEqual(live(), beforeProfile);
+		assert.match(rail.render(46).join("\n"), /Profile.*other/);
+		profile = undefined;
+		assert.doesNotMatch(rail.render(46).join("\n"), /Profile/);
+
 		const beforeModel = live();
 		(ctx.model as { id: string }).id = "gpt-5.6";
 		assert.notEqual(live(), beforeModel, "/model must change the digest");
@@ -273,10 +282,44 @@ test("the fullscreen Status rail carries a live digest so a model switch refresh
 	}
 });
 
+test("profile reader follows store changes and rejects missing or invalid active markers", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "shell-profile-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const path = join(root, "profiles.json");
+	const read = createActiveProfileReader({ GENTLE_PI_CONFIG_HOME: root });
+	const save = (active: string | undefined) => writeFileSync(path, JSON.stringify({
+		kind: "gentle-pi.agent_model_profiles", version: 1, active, profiles: { team: {}, other: {} },
+	}));
+	assert.equal(read(), undefined);
+	save("team");
+	assert.equal(read(), "team");
+	assert.equal(read(), "team");
+	save("other");
+	assert.equal(read(), "other");
+	const replacement = join(root, "replacement.json");
+	writeFileSync(replacement, JSON.stringify({ kind: "gentle-pi.agent_model_profiles", version: 1, active: "team", profiles: { team: {} } }));
+	renameSync(replacement, path);
+	assert.equal(read(), "team", "atomic replacement refreshes the cached profile");
+	const isolated = createActiveProfileReader({ GENTLE_PI_CONFIG_HOME: join(root, "other-home") });
+	assert.equal(isolated(), undefined);
+	assert.equal(read(), "team", "another shell's config home does not alter this cache");
+	save("missing");
+	assert.equal(read(), undefined);
+	save(undefined);
+	assert.equal(read(), undefined);
+	writeFileSync(path, "{broken");
+	assert.equal(read(), undefined);
+	save("team");
+	assert.equal(read(), "team");
+	rmSync(path);
+	assert.equal(read(), undefined);
+});
+
 test("gentleShell stays out of the way without a UI or when disabled", () => {
 	const disabled = fakePi();
 	gentleShell(disabled.pi, { GENTLE_PI_SHELL: "0" });
-	assert.equal(disabled.handlers.size, 0);
+	assert.equal(disabled.commands.size, 0);
+	assert.ok(disabled.handlers.has("tool_call"), "capture remains available to headless children");
 
 	const headless = fakePi();
 	gentleShell(headless.pi, {});
@@ -364,152 +407,87 @@ function renderFooter(ui: FakeUi): string {
 	return factory(fakeTui, plainTheme, footerData).render(160)[0];
 }
 
-test("gentleShell shows working-tree changes in a widget below the editor and in the bar", async () => {
-	const { pi, handlers, git } = fakePi([
-		{ numstat: "", porcelain: "" },
-		{ numstat: "10\t0\tlib/b.ts\n", porcelain: "A  lib/b.ts\0" },
-	]);
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" });
-	const { ctx, ui } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	assert.deepEqual(git[0].slice(0, 2), ["-C", "/repo"]);
-	assert.equal(ui.widgets.has("gentle-shell-changes"), false);
-	assert.doesNotMatch(renderFooter(ui), /±/);
-
-	await fire(handlers, "tool_execution_end", ctx);
-	const factory = ui.widgets.get("gentle-shell-changes") as (tui: unknown, theme: ShellBarTheme) => { render(width: number): string[] };
-	const [line] = factory(fakeTui, plainTheme).render(120);
-	assert.match(line, /^✎ 1 file · \+10 −0 · lib\/b\.ts +\/gentle:changes$/);
-	assert.match(renderFooter(ui), /main ±1/);
-});
-
-test("gentleShell registers /gentle:changes and opens the overlay only when there are changes", async () => {
-	const { pi, handlers, commands } = fakePi([
-		{ numstat: "", porcelain: "" },
-		{ numstat: "", porcelain: "" },
-		{ numstat: "10\t0\tlib/b.ts\n", porcelain: "A  lib/b.ts\0" },
-	]);
-	gentleShell(pi, {});
-	const { ctx, ui } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	const command = commands.get("gentle:changes");
-	assert.ok(command, "command not registered");
-
-	await command.handler("", ctx);
-	assert.deepEqual(ui.notices, ["No changes in the working tree."]);
-	assert.equal(ui.overlay, undefined);
+function sessionChange(ctx: ExtensionContext, id: string, root: string, path: string, before = "", after = "agent\n"): void {
+ const entries = ctx.sessionManager.getEntries() as any[];
+ entries.push({ type: "custom", customType: "gentle-pi.session-change/v1", data: {
+  sessionId: ctx.sessionManager.getSessionId(),
+  evidence: { id, root, path, before: before ? {kind:"text",text:before} : {kind:"absent"}, after:{kind:"text",text:after} },
+ } });
+}
 
-	await fire(handlers, "tool_execution_end", ctx);
-	const opened = command.handler("", ctx);
-	await new Promise((resolve) => setTimeout(resolve, 0));
-	assert.equal(typeof ui.overlay, "function");
-	ui.closeOverlay?.();
-	await opened;
+test("captured changes update the widget and bar without repository scans", async () => {
+ const { pi, handlers, git } = fakePi([{numstat:"999\t0\tforeign.ts\n",porcelain:"?? foreign.ts\0"}]);
+ gentleShell(pi,{});
+ const {ctx,ui}=fakeContext();
+ await fire(handlers,"session_start",ctx);
+ assert.equal(git.length,0);
+ assert.equal(ui.widgets.has("gentle-shell-changes"),false);
+ sessionChange(ctx,"a","/repo","lib/b.ts","","one\ntwo\n");
+ pi.events.emit("gentle-pi:session-change",{sessionId:ctx.sessionManager.getSessionId()});
+ await new Promise(resolve=>setImmediate(resolve));
+ const factory=ui.widgets.get("gentle-shell-changes") as any;
+ assert.match(factory(fakeTui,plainTheme).render(140)[0],/1 file · \+2 −0/);
+ assert.match(renderFooter(ui),/main ±1/);
+ assert.equal(git.length,0);
+ await fire(handlers,"session_shutdown",ctx);
 });
 
-test("changes overlay follows registered linked roots on open, refresh and polling and scopes diff git cwd", async () => {
-	const { pi, handlers, commands, tools } = fakePi();
-	let roots = ["/repo"];
-	const diffs: string[][] = [];
-	pi.exec = (async (_command: string, args: string[]) => {
-		let stdout = "";
-		if (args.includes("worktree")) stdout = roots.map((root) => `worktree ${root}\0branch refs/heads/${root.slice(1)}\0\0`).join("");
-		else if (args.includes("status")) stdout = " M same.ts\0";
-		else if (args.includes("--numstat")) stdout = "1\t1\tsame.ts\n";
-		else { diffs.push(args); stdout = `+${args[1]}`; }
-		return { stdout, stderr: "", code: 0, killed: false };
-	}) as ExtensionAPI["exec"];
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off", GENTLE_PI_SHELL_CHANGES_POLL_MS: "5" });
-	const { ctx, ui } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	roots.push("/linked");
-	await tools.get("session_worktree_register")!.execute("register", { path: "/linked" }, undefined, undefined, ctx);
-	const open = commands.get("gentle:changes")!.handler("", ctx);
-	try {
-		await new Promise((resolve) => setTimeout(resolve, 20));
-		assert.match(ui.overlayView!.render(120).join("\n"), /linked · linked/);
-		assert.equal(diffs.length, 0);
-		ui.overlayView!.handleInput("j");
-		ui.overlayView!.handleInput("\r");
-		ui.overlayView!.handleInput("j");
-		await new Promise((resolve) => setTimeout(resolve, 0));
-		assert.deepEqual(diffs[0], ["-C", "/linked", "diff", "HEAD", "--", "same.ts"]);
-		ui.overlayView!.handleInput("\x1b[D");
-		roots.push("/new");
-		await tools.get("session_worktree_register")!.execute("register", { path: "/new" }, undefined, undefined, ctx);
-		ui.overlayView!.handleInput("r");
-		await new Promise((resolve) => setTimeout(resolve, 20));
-		assert.match(ui.overlayView!.render(120).join("\n"), /new · new/);
-		roots.push("/polled");
-		await tools.get("session_worktree_register")!.execute("register", { path: "/polled" }, undefined, undefined, ctx);
-		await new Promise((resolve) => setTimeout(resolve, 20));
-		assert.match(ui.overlayView!.render(120).join("\n"), /polled · polled/);
-	} finally {
-		ui.closeOverlay?.();
-		await open;
-		await fire(handlers, "session_shutdown", ctx);
-	}
+test("Changes opens only for captured mutations, not registered dirty roots", async () => {
+ const {pi,handlers,commands,tools,git}=fakePi();
+ gentleShell(pi,{});
+ const {ctx,ui,overlayReady}=fakeContext();
+ await fire(handlers,"session_start",ctx);
+ await tools.get("session_worktree_register")!.execute("r",{path:"/linked"},undefined,undefined,ctx);
+ await commands.get("gentle:changes")!.handler("",ctx);
+ assert.match(ui.notices.join("\n"),/No captured agent changes/);
+ assert.equal(ui.overlay,undefined);
+ sessionChange(ctx,"a","/linked","file.ts");
+ await fire(handlers,"agent_end",ctx);
+ const opened=commands.get("gentle:changes")!.handler("",ctx);
+ await overlayReady;
+ assert.match(ui.overlayView!.render(140).join("\n"),/linked/);
+ assert.equal(git.length,0);
+ ui.closeOverlay?.(); await opened;
+ await fire(handlers,"session_shutdown",ctx);
 });
 
-test("successful direct tools register whole roots, failures and shell contents do not, and all UI counts agree", async () => {
-	const { pi, handlers, tools, commands } = fakePi();
-	const queried: string[] = [];
-	pi.exec = (async (_command: string, args: string[]) => {
-		const root = args[1];
-		if (args.includes("status")) queried.push(root);
-		const stdout = args.includes("worktree") ? ["/repo", "/used", "/failed", "/opaque", "/hidden"].map((path) => `worktree ${path}\0\0`).join("")
-			: args.includes("status") ? " M preexisting.ts\0?? new.ts\0"
-			: args.includes("--numstat") ? "2\t1\tpreexisting.ts\n" : "+diff";
-		return { stdout, stderr: "", code: 0, killed: false };
-	}) as ExtensionAPI["exec"];
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" });
-	const { ctx, ui, overlayReady } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	const emit = async (name: string, event: unknown) => {
-		for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
-	};
-	const complete = async (toolName: string, input: unknown, isError = false) => {
-		await emit("tool_execution_start", { toolCallId: "call", toolName, args: input });
-		await emit("tool_result", { toolCallId: "call", toolName, input, isError: false });
-		await emit("tool_execution_end", { toolCallId: "call", toolName, isError });
-	};
-	await complete("read", { path: "/failed" }, true);
-	await complete("bash", { command: "cd /opaque && edit stuff", path: "/opaque" });
-	assert.deepEqual(new Set(queried), new Set(["/repo"]));
-	await complete("read", { path: "/used" });
-	await complete("write", { path: "/used" });
-	assert.deepEqual(new Set(queried), new Set(["/repo", "/used"]));
-	assert.equal(ctx.sessionManager.getEntries().length, 2, "multiple completed tools dedupe");
-	assert.match(renderFooter(ui), /±4/);
-	const widget = ui.widgets.get("gentle-shell-changes") as (host: unknown, theme: unknown) => { render(width: number): string[] };
-	assert.match(widget(fakeTui, plainTheme).render(140)[0], /4 files/);
-	const open = commands.get("gentle:changes")!.handler("", ctx);
-	await overlayReady;
-	assert.doesNotMatch(ui.overlayView!.render(140).join("\n"), /hidden|opaque|failed/);
-	ui.closeOverlay?.();
-	await open;
-	await tools.get("session_worktree_register")!.execute("explicit", { path: "/opaque" }, undefined, undefined, ctx);
-	assert.match(renderFooter(ui), /±6/);
-	await fire(handlers, "session_shutdown", ctx);
+test("overlay groups captured roots and refreshes same-count diffs without HEAD or external files", async () => {
+ const {pi,handlers,commands,git}=fakePi();
+ gentleShell(pi,{GENTLE_PI_SHELL_CHANGES_POLL_MS:"5"});
+ const {ctx,ui,overlayReady}=fakeContext();
+ sessionChange(ctx,"a","/repo","same.ts","old\n","first\n");
+ sessionChange(ctx,"child:a","/linked","same.ts","old\n","child\n");
+ await fire(handlers,"session_start",ctx);
+ const opened=commands.get("gentle:changes")!.handler("",ctx);
+ await overlayReady;
+ try {
+  ui.overlayView!.handleInput("\r"); ui.overlayView!.handleInput("j");
+  await new Promise(resolve=>setTimeout(resolve,10));
+  assert.match(ui.overlayView!.render(140).join("\n"),/first/);
+  sessionChange(ctx,"b","/repo","same.ts","first\n","second\n");
+  pi.events.emit("gentle-pi:session-change",{sessionId:ctx.sessionManager.getSessionId()});
+  await new Promise(resolve=>setTimeout(resolve,20));
+  assert.match(ui.overlayView!.render(140).join("\n"),/second/);
+  assert.doesNotMatch(ui.overlayView!.render(140).join("\n"),/first/);
+  assert.equal(git.length,0);
+ } finally { ui.closeOverlay?.(); await opened; await fire(handlers,"session_shutdown",ctx); }
 });
 
-test("session switching drops pending tool and foreign launch events while same-session entries restore", async () => {
-	const h = fakePi([{ numstat: "1\t0\ta.ts\n", porcelain: " M a.ts\0" }]);
-	gentleShell(h.pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" });
-	const first = fakeContext();
-	await fire(h.handlers, "session_start", first.ctx);
-	for (const handler of h.handlers.get("tool_execution_start") ?? []) await handler({ toolCallId: "old", toolName: "read", args: { path: "/foreign" } }, first.ctx);
-	const next = fakeContext({ entries: [...first.ctx.sessionManager.getEntries()] });
-	(next.ctx.sessionManager as unknown as { getSessionId(): string }).getSessionId = () => "new-session";
-	await fire(h.handlers, "session_start", next.ctx);
-	for (const handler of h.handlers.get("tool_result") ?? []) await handler({ toolCallId: "old", toolName: "read", input: { path: "/foreign" } }, next.ctx);
-	for (const handler of h.handlers.get("tool_execution_end") ?? []) await handler({ toolCallId: "old", toolName: "read", isError: false }, next.ctx);
-	const before = h.git.length;
-	h.pi.events.emit("gentle-pi:session-worktree-changed", { sessionId: "shell-session", root: "/foreign" });
-	assert.equal(h.git.length, before);
-	assert.match(renderFooter(next.ui), /±1/);
-	assert.ok(!h.git.some((args) => args[1] === "/foreign"));
-	await fire(h.handlers, "session_shutdown", next.ctx);
+test("new sessions ignore inherited captures, while reload restores the same session", async () => {
+ const h=fakePi(); gentleShell(h.pi,{});
+ const first=fakeContext();
+ sessionChange(first.ctx,"a","/repo","own.ts");
+ await fire(h.handlers,"session_start",first.ctx);
+ assert.match(renderFooter(first.ui),/±1/);
+ await fire(h.handlers,"session_start",first.ctx);
+ assert.match(renderFooter(first.ui),/±1/);
+ const next=fakeContext({entries:[...first.ctx.sessionManager.getEntries()]});
+ (next.ctx.sessionManager as any).getSessionId=()=>"new-session";
+ await fire(h.handlers,"session_start",next.ctx);
+ h.pi.events.emit("gentle-pi:session-change",{sessionId:"shell-session"});
+ assert.doesNotMatch(renderFooter(next.ui),/±1/);
+ assert.equal(h.git.length,0);
+ await fire(h.handlers,"session_shutdown",next.ctx);
 });
 
 test("registered canonical root governs real Git discovery, status and diff despite inherited routing", async (t) => {
@@ -550,10 +528,7 @@ test("registered canonical root governs real Git discovery, status and diff desp
 	installGentleShell(h.pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" }, { devBinary: () => undefined, gitRunner: (cwd) => shellGitRunner(cwd, poisoned) });
 	await fire(h.handlers, "session_start", ctx);
 	t.after(() => fire(h.handlers, "session_shutdown", ctx));
-	const widget = ui.widgets.get("gentle-shell-changes") as (host: unknown, theme: unknown) => { render(width: number): string[] };
-	const rendered = widget(fakeTui, plainTheme).render(300).join("\n");
-	assert.match(rendered, /selected-only\.txt/);
-	assert.doesNotMatch(rendered, /foreign-only\.txt/);
+	assert.equal(ui.widgets.has("gentle-shell-changes"), false, "preexisting dirty files are not agent changes");
 	const diff = await loadFileDiff(run, { path: "tracked.txt", added: 1, deleted: 1, status: CHANGE_STATUS.MODIFIED });
 	assert.match(diff, /\+selected change/);
 	assert.doesNotMatch(diff, /foreign change/);
@@ -567,12 +542,8 @@ test("registered canonical root governs real Git discovery, status and diff desp
 	assert.equal(largeDiff.code, 0);
 	assert.ok(largeDiff.stdout.length > 1024 * 1024, "output must not inherit execFile's default one MiB cap");
 	assert.match(largeDiff.stdout, /\+selected final marker/);
-	const open = h.commands.get("gentle:changes")!.handler("", ctx);
-	await overlayReady;
-	ui.overlayView!.handleInput("\r");
-	ui.overlayView!.handleInput("j");
-	ui.closeOverlay?.();
-	await open;
+	await h.commands.get("gentle:changes")!.handler("", ctx);
+	assert.equal(ui.overlay, undefined);
 });
 
 test("loadFileDiff asks git for a HEAD diff, or a no-index diff for untracked files", async () => {
@@ -644,55 +615,24 @@ test("gentleShell binds the changes shortcut to the same handler as the command"
 	const shortcut = shortcuts.get("alt+g");
 	assert.ok(shortcut, "alt+g not registered");
 	await shortcut.handler(ctx);
-	assert.deepEqual(ui.notices, ["No changes in the working tree."]);
+	assert.match(ui.notices.join("\n"), /No captured agent changes/);
 
 	const silent = fakePi();
 	gentleShell(silent.pi, { GENTLE_PI_SHELL_CHANGES_KEY: "off" });
 	assert.equal(silent.shortcuts.size, 0);
 });
 
-test("gentleShell keeps the open overlay in sync with git while it stays open", async () => {
-	const { pi, handlers, commands } = fakePi([
-		{ numstat: "10\t0\tlib/b.ts\n", porcelain: "A  lib/b.ts\0" },
-		{ numstat: "10\t0\tlib/b.ts\n", porcelain: "A  lib/b.ts\0" },
-		{ numstat: "10\t0\tlib/b.ts\n3\t1\tlib/c.ts\n", porcelain: "A  lib/b.ts\0 M lib/c.ts\0" },
-	]);
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_POLL_MS: "5" });
-	const { ctx, ui } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	const open = commands.get("gentle:changes")!.handler("", ctx);
-	await new Promise((resolve) => setTimeout(resolve, 40));
-	ui.overlayView!.handleInput("\r");
-	const plain = ui.overlayView!.render(100).map(stripAnsi);
-	assert.match(plain[2], /2 files · \+13 −1/);
-	assert.match(plain[3], /lib\/c\.ts/);
-	assert.match(renderFooter(ui), /main ±2/);
-	ui.closeOverlay?.();
-	await open;
-});
-
-test("gentleShell watches git in the background so the widget and bar follow external edits", async () => {
-	const { pi, handlers, git } = fakePi([
-		{ numstat: "", porcelain: "" },
-		{ numstat: "", porcelain: "" },
-		{ numstat: "3\t1\tlib/c.ts\n", porcelain: " M lib/c.ts\0" },
-	]);
-	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "5" });
-	const { ctx, ui } = fakeContext();
-	await fire(handlers, "session_start", ctx);
-	assert.equal(ui.widgets.has("gentle-shell-changes"), false);
-	await new Promise((resolve) => setTimeout(resolve, 40));
-	assert.equal(ui.widgets.has("gentle-shell-changes"), true);
-	assert.match(renderFooter(ui), /main ±1/);
-	assert.ok(git.length >= 6, "background watch should keep polling git");
-
-	const widgetSetsBefore = ui.widgetSets;
-	await new Promise((resolve) => setTimeout(resolve, 20));
-	assert.equal(ui.widgetSets, widgetSetsBefore, "unchanged tree must not rewrite the widget");
-	await fire(handlers, "session_shutdown", ctx);
-	const gitCallsAfterShutdown = git.length;
-	await new Promise((resolve) => setTimeout(resolve, 20));
-	assert.equal(git.length, gitCallsAfterShutdown, "shutdown must stop the watch");
+test("external edits do not pollute Changes or trigger background Git scans", async () => {
+ const {pi,handlers,git}=fakePi([{numstat:"4\t2\texternal.ts\n",porcelain:" M external.ts\0"}]);
+ gentleShell(pi,{GENTLE_PI_SHELL_CHANGES_WATCH_MS:"5"});
+ const {ctx,ui}=fakeContext();
+ await fire(handlers,"session_start",ctx);
+ await new Promise(resolve=>setTimeout(resolve,30));
+ await fire(handlers,"agent_end",ctx);
+ assert.equal(git.length,0);
+ assert.equal(ui.widgets.has("gentle-shell-changes"),false);
+ assert.doesNotMatch(renderFooter(ui),/±/);
+ await fire(handlers,"session_shutdown",ctx);
 });
 
 const JWT = `h.${Buffer.from(JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acct-1" } })).toString("base64url")}.s`;

package/tests/native-review-capability-contract.test.ts

@@ -232,11 +232,25 @@ test("2.9.0 repeats 2.8.2 because the negotiated lane Pi consumes is unchanged",
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.8.2"] as Record<string, boolean>);
 });
 
+test("2.9.1 repeats 2.9.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// v2.9.1 shipped restoring compatible OpenCode review consent (#4584) and
+	// deriving Claude Code SDD dispatch authority from the session transcript
+	// (#4575, #4551). 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 showed zero byte changes, so this row
+	// repeats 2.9.0. riskEvidence and hint remain dark because neither is
+	// proven to reach Pi's negotiated START path.
+	const contract = NATIVE_CLI_CONTRACTS["2.9.1"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.9.0"] as Record<string, boolean>);
+});
+
 test("no shipped version key was added beyond the pin bump", () => {
 	// Rows are promises to consumers, so a new key only ever appears in a
 	// dedicated commit alongside a pin bump, never as a side effect. v2.2.4 and
 	// v2.3.0 shipped upstream while Pi stayed on 2.2.3 and were never pinned,
 	// so they get no row: a row asserts ground truth measured against a binary
 	// Pi actually ran, and the table only has to be ascending, not gapless.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0"]);
+	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1"]);
 });

package/tests/package-manifest.test.ts

@@ -278,20 +278,20 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 	);
 });
 
-test("package verification binds the published Gentle AI v2.9.0 runtime pin", () => {
+test("package verification binds the published Gentle AI v2.9.1 runtime pin", () => {
 	const installer = readFileSync(join(PACKAGE_ROOT, "scripts", "gentle-ai-installer.mjs"), "utf8");
 	const binary = readFileSync(join(PACKAGE_ROOT, "lib", "gentle-ai-binary.ts"), "utf8");
 	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
 
-	assert.match(installer, /INSTALLER_VERSION = "2\.9\.0"/);
+	assert.match(installer, /INSTALLER_VERSION = "2\.9\.1"/);
 	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_PACKAGE.*GENTLE_AI_WINDOWS_SOURCE_MODULE/);
-	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:WqmYw1UfVYCbtOxU1uTuiYq9\+ROCUIDrmKIOjyYggQI="/);
+	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:roCuxlF\+L4YOb1X0los4RpjcLfxAmwmHxteSQMcfThY="/);
 	assert.match(installer, /GOTOOLCHAIN: "local"/);
 	assert.match(installer, /GOSUMDB: "sum\.golang\.org"/);
 	assert.match(binary, /GENTLE_AI_VERSION = INSTALLER_VERSION/);
 	assert.match(binary, /GO_SUMDB_SOURCE_BUILD/);
 	assert.match(binary, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM/);
-	assert.match(verifier, /v2\.9\.0/);
+	assert.match(verifier, /v2\.9\.1/);
 });
 
 
@@ -1509,9 +1509,9 @@ test("pi-pretty wrapper uses real package path resolution for pnpm symlink insta
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("v2.6.4 release package and runtime stop before publication", () => {
+test("v2.7.0 release package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "2.6.4", "the release manifest must remain explicitly pinned to v2.6.4");
+	assert.equal(packageJson.version, "2.7.0", "the release manifest must remain explicitly pinned to v2.7.0");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",

package/tests/session-change-capture.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, writeFile, rm, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { installSessionChangeCapture } from "../lib/session-change-capture.ts";
+import { SessionChanges, SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+
+async function fixture(run: (f: any) => Promise<void>, child = false) {
+	const root = await realpath(await mkdtemp(join(tmpdir(), "change-capture-")));
+	const handlers = new Map<string, Function>();
+	const entries: any[] = [];
+	const listeners = new Map<string, Function>();
+	const pi = { on: (key, fn) => handlers.set(key, fn), appendEntry: (customType, data) => entries.push({type:"custom",customType,data}),
+		events: { on: (key, fn) => { listeners.set(key, fn); return () => listeners.delete(key); }, emit: (key, data) => listeners.get(key)?.(data) } };
+	let id = "session";
+	const ctx = { cwd:root, sessionManager: { getSessionId: () => id, getEntries: () => entries } };
+	installSessionChangeCapture(pi as never, child ? {GENTLE_PI_AGENTS_CHILD:"1"} : {}, () => ({root,commonDir:root}));
+	const fire = (key, event = {}) => handlers.get(key)?.(event, ctx);
+	try { await fire("session_start"); await run({root, entries, ctx, fire, switchSession: () => id = "other"}); }
+	finally { await rm(root, {recursive:true,force:true}); }
+}
+
+test("capture reads no inventory at startup and ignores read-only tools", async () => fixture(async ({fire, entries}) => {
+	await fire("tool_call", {toolCallId:"r",toolName:"read",input:{path:"missing"}});
+	await fire("tool_result", {toolCallId:"r",toolName:"read",input:{path:"missing"},isError:false});
+	await fire("tool_execution_end", {toolCallId:"r",toolName:"read",isError:false});
+	assert.deepEqual(entries, []);
+}));
+
+test("successful writes capture only the exact tool target and persist for reload", async () => fixture(async ({root,fire,entries}) => {
+	await writeFile(join(root,"file"),"human baseline\n");
+	const event = {toolCallId:"w",toolName:"write",input:{path:"file",content:"agent output\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"file"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	assert.equal(entries.length,0);
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:false});
+	assert.equal(entries[0].customType,SESSION_CHANGE_ENTRY);
+	await writeFile(join(root,"file"),"later human output\n");
+	const changes = new SessionChanges("session",entries);
+	assert.match(changes.loadDiff(root,changes.model.files[0]),/\+agent output/);
+	assert.doesNotMatch(changes.loadDiff(root,changes.model.files[0]),/later human/);
+}));
+
+test("failed and stale-session tool outcomes never add session changes", async () => fixture(async ({root,fire,entries,switchSession}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"new"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:true});
+	assert.equal(entries.length,0);
+	await fire("tool_call",{...event,toolCallId:"x"});
+	switchSession();
+	await fire("tool_result",{...event,toolCallId:"x",isError:false});
+	await fire("tool_execution_end",{toolCallId:"x",toolName:"write",isError:false});
+	assert.equal(entries.length,0);
+}));
+
+test("child carries bounded evidence in the existing tool-result details transport", async () => fixture(async ({root,fire,entries}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event); await writeFile(join(root,"new"),event.input.content);
+	const result=await fire("tool_result",{...event,isError:false,details:{original:"preserved"}});
+	assert.equal(result.details.original,"preserved");
+	assert.equal(result.details.gentleSessionChange.id,"w");
+	assert.equal(result.details.gentleSessionChange.path,"new");
+	assert.deepEqual(entries,[]);
+},true));

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

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import shell from "../extensions/gentle-shell.ts";
+import { SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+
+function fixture(entries: any[] = []) {
+	const handlers = new Map<string, Function[]>(), listeners = new Map<string, Function[]>();
+	const commands = new Map<string, any>(), widgets = new Map<string, any>();
+	let gitCalls = 0;
+	const pi: any = { on: (key, fn) => handlers.set(key, [...(handlers.get(key) ?? []), fn]),
+		events: { on: (key, fn) => { listeners.set(key,[...(listeners.get(key) ?? []), fn]); return () => {}; }, emit: (key,data) => listeners.get(key)?.forEach(fn=>fn(data)) },
+		appendEntry: (customType,data) => entries.push({type:"custom",customType,data}), registerTool() {}, registerShortcut() {}, registerMessageRenderer() {},
+		registerCommand: (key, registration) => commands.set(key,registration) };
+	const notices: string[] = [];
+	const ctx: any = { hasUI:true, cwd:"/repo", sessionManager:{getSessionId:()=>"session",getEntries:()=>entries},
+		ui: { setFooter() {}, getEditorComponent:()=>({}), setWorkingVisible() {}, setWidget:(key,value)=>widgets.set(key,value), notify:(text)=>notices.push(text) } };
+	shell(pi,{}, {resolveWorktree:()=>({root:"/repo",commonDir:"/git"}),devBinary:()=>undefined,
+		gitRunner:()=>async()=>{gitCalls++; return await new Promise<any>(()=>{});} });
+	const fire=async(key,event={})=>{for(const fn of handlers.get(key)??[]) await fn(event,ctx);};
+	return {pi,ctx,entries,notices,commands,widgets,fire,gitCalls:()=>gitCalls};
+}
+test("Gentle Shell startup never waits for a repository scan",async()=>{
+	const f=fixture();
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked by Git inventory")),100))]);
+	assert.equal(f.gitCalls(),0);
+	await f.commands.get("gentle:changes").handler("",f.ctx);
+	assert.match(f.notices.join("\n"),/captured.*agent|agent.*changes/i);
+	await f.fire("session_shutdown");
+});
+test("reload and new evidence refresh Changes without Git or live file reads",async()=>{
+	const f=fixture([{type:"custom",customType:SESSION_CHANGE_ENTRY,data:{sessionId:"session",evidence:{id:"child:1",root:"/repo",path:"own.ts",before:{kind:"absent"},after:{kind:"text",text:"own\n"}}}}]);
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked")),100))]);
+	f.pi.events.emit(SESSION_CHANGE_EVENT,{sessionId:"session"});
+	await new Promise(resolve=>setImmediate(resolve));
+	assert.equal(f.gitCalls(),0);
+	assert.equal(typeof f.widgets.get("gentle-shell-changes"),"function");
+	await f.fire("session_shutdown");
+});