gentle-pi 2.6.4 → 2.7.0

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.4",
+	"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",

package/runtime/native-review-cli.mjs

@@ -994,6 +994,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 }),
 });
 
 

package/scripts/gentle-ai-installer.mjs

@@ -36,7 +36,7 @@ const WINDOWS_SYSTEM_ROOT = "C:\\Windows";
 // version check below) derives from this constant instead of repeating the
 // literal, so a pin bump cannot leave a stale copy behind. See
 // scripts/install-gentle-ai.mjs for the incident that motivated this.
-export const INSTALLER_VERSION = "2.9.0";
+export const INSTALLER_VERSION = "2.9.1";
 export const RELEASE_BASE_URL = `https://github.com/Gentleman-Programming/gentle-ai/releases/download/v${INSTALLER_VERSION}/`;
 export const GENTLE_AI_INSTALL_METHOD = Object.freeze({
 	SIGNED_RELEASE_ASSET: "signed-release-asset",
@@ -45,10 +45,10 @@ export const GENTLE_AI_INSTALL_METHOD = Object.freeze({
 export const GENTLE_AI_WINDOWS_SOURCE_PACKAGE_PATH = "github.com/gentleman-programming/gentle-ai/v2/cmd/gentle-ai";
 export const GENTLE_AI_WINDOWS_SOURCE_MODULE = "github.com/gentleman-programming/gentle-ai/v2";
 export const GENTLE_AI_WINDOWS_SOURCE_TAG = `v${INSTALLER_VERSION}`;
-// `go mod download -json github.com/gentleman-programming/gentle-ai/v2@v2.9.0`
+// `go mod download -json github.com/gentleman-programming/gentle-ai/v2@v2.9.1`
 // with GOSUMDB=sum.golang.org reports this exact module SumDB checksum, and the
-// tag resolves to commit be495547, the published v2.9.0 release head.
-export const GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:WqmYw1UfVYCbtOxU1uTuiYq9+ROCUIDrmKIOjyYggQI=";
+// tag resolves to commit 9ec0cf44, the published v2.9.1 release head.
+export const GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:roCuxlF+L4YOb1X0los4RpjcLfxAmwmHxteSQMcfThY=";
 export const GENTLE_AI_WINDOWS_SOURCE_PACKAGE = `${GENTLE_AI_WINDOWS_SOURCE_PACKAGE_PATH}@${GENTLE_AI_WINDOWS_SOURCE_TAG}`;
 export const GENTLE_AI_WINDOWS_MINIMUM_GO_VERSION = "1.25.10";
 export const GENTLE_AI_GO_TOOLCHAIN_UNAVAILABLE_CODE = "GENTLE_AI_GO_TOOLCHAIN_UNAVAILABLE";
@@ -67,7 +67,7 @@ export class GentleAiInstallerError extends Error {
 // Sentinel used while a re-pinned gentle-ai release is not yet published. A
 // sentinel digest can never match a real SHA-256, so installation fails closed,
 // and verify-package-files.mjs refuses to pack/publish while any digest below
-// still holds it. The v2.9.0 digests are pinned from the published release:
+// still holds it. The v2.9.1 digests are pinned from the published release:
 // archive sha256 values verified against the minisign-signed checksums.txt and
 // freshly computed hashes; binary sha256 values computed from the extracted
 // executables.
@@ -109,15 +109,15 @@ async function downloadPinnedGentleAiAsset(asset, destination, options) {
 }
 
 // Windows is absent from signed release archives on purpose. gentle-ai stopped
-// distributing unsigned Windows builds in c4b764d0, so v2.9.0 publishes signed
+// distributing unsigned Windows builds in c4b764d0, so v2.9.1 publishes signed
 // Darwin/Linux archives only. Windows x64/arm64 uses the separately verified
 // exact-tag Go SumDB source-build path below; restore archive rows only when
 // upstream ships signed Windows assets.
 export const GENTLE_AI_RELEASE_ASSETS = Object.freeze({
-	"darwin/amd64": asset("gentle-ai_2.9.0_darwin_amd64.tar.gz", "0e1ce0b117e6f15b56e05defecb33a33825c2e25eb8306df09401d41e0a176fb", "0dc22de552e0403f318770067adccd82783b1f654ed4d0410d7d969e28e39602", "gentle-ai"),
-	"darwin/arm64": asset("gentle-ai_2.9.0_darwin_arm64.tar.gz", "0a58d81cd7d76315e1d11ecf6b38abb27ee8e7e709a04c9a786e89636fb559bb", "5e72f1f34667a858fc179504e794847a1407142240361f99effd252d6ad49ee9", "gentle-ai"),
-	"linux/amd64": asset("gentle-ai_2.9.0_linux_amd64.tar.gz", "7d414cd8cba8ddc0ab9fa4bc309932638c533217b2f999b2a52e7a4fc0bf6f14", "5c47029fb6520f99b7df1b6841766b09d7184efed2e18694d83795bf4d4a5ad4", "gentle-ai"),
-	"linux/arm64": asset("gentle-ai_2.9.0_linux_arm64.tar.gz", "2bdab4684b5d415df9c9423c2022b017c7c1c1d9056f56acc08633fa0d821cfc", "56501a4d91f4e3255726b63c59b96a6d42c6952af2d265f54c8e99b361cda0c9", "gentle-ai"),
+	"darwin/amd64": asset("gentle-ai_2.9.1_darwin_amd64.tar.gz", "9e4b10c8e0ff36e51f39fad4da082f37b408234253cbbb7f8a8f710a5ee7b7f7", "96b2739365aa7513997e9ea5435cf38c019810dc3db0fb51c4c8f2fdb910de58", "gentle-ai"),
+	"darwin/arm64": asset("gentle-ai_2.9.1_darwin_arm64.tar.gz", "d876c237e4559bea6849e9f9be33c63cea053154149df4a3e1e5983c9a6232ff", "5a675f666f52e4c070ad703da01a5e3ab6b1a4a002e3ac08ca1ef2871d21ac59", "gentle-ai"),
+	"linux/amd64": asset("gentle-ai_2.9.1_linux_amd64.tar.gz", "07efddecd29fd1c3f8c8df19a3b6613c1948927d410b8502bf82b39b84d9481b", "8bd0161c51ed07e77801a92d13bdcb82ff483c273d4a182904534057d4054d97", "gentle-ai"),
+	"linux/arm64": asset("gentle-ai_2.9.1_linux_arm64.tar.gz", "c3e5a173fa1b19be0abc0c6e5de18709cd1985cff61cc140546191e809324ed2", "a311c9ae6bc8d59931eee7c686be5d51b35d60b5d2b591e17e9b432968926e4e", "gentle-ai"),
 });
 
 // A pinned asset is either a signed archive or, for a prerelease pin only,

package/scripts/verify-package-files.mjs

@@ -340,7 +340,7 @@ async function main() {
   });
 
   if (driftedContracts.length > 0) {
-    console.error("gentle-pi packaged review-integration/v1 and review-integration/v2 contract bytes drifted from the pinned v2.9.0 runtime's vendored Gentle AI contract artifacts:");
+    console.error("gentle-pi packaged review-integration/v1 and review-integration/v2 contract bytes drifted from the pinned v2.9.1 runtime's vendored Gentle AI contract artifacts:");
     for (const drift of driftedContracts) console.error(`- ${drift.relativePath}: expected ${drift.expected}, got ${drift.actual}`);
     process.exit(1);
   }
@@ -385,7 +385,7 @@ async function main() {
     process.exit(1);
   }
 
-  console.log(`gentle-pi package resource check passed (${requiredPaths.length} files; ${Object.keys(contractHashes).length} exact byte-pinned contract artifacts for the v2.9.0 runtime).`);
+  console.log(`gentle-pi package resource check passed (${requiredPaths.length} files; ${Object.keys(contractHashes).length} exact byte-pinned contract artifacts for the v2.9.1 runtime).`);
 }
 
 const isMainModule = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;

package/tests/agents-runner.test.ts

@@ -321,6 +321,20 @@ test("child observation guard is never consulted when collection is default-off"
 	assert.equal(calls, 0);
 });
 
+test("child session diff evidence travels only with a paired successful tool outcome", async () => {
+ const observed: any[] = [];
+ const h = harness({ onSuccessfulMutation: (_task, tool) => { observed.push(tool); } });
+ const task = h.runner.run(request()); await tick();
+ const child = h.children[0];
+ const evidence = {id:"w",root:"/repo",path:"src/file.ts",before:{kind:"absent"},after:{kind:"text",text:"agent\n"}};
+ child.emit({type:"tool_execution_start",toolCallId:"w",toolName:"write",args:{path:"src/file.ts"}});
+ child.emit({type:"tool_execution_end",toolCallId:"w",isError:false,result:{content:[],details:{gentleSessionChange:evidence}}});
+ assert.deepEqual(observed[0].evidence,evidence);
+ child.emit({type:"tool_execution_end",toolCallId:"w",isError:false,result:{content:[],details:{gentleSessionChange:evidence}}});
+ assert.equal(observed.length,1);
+ h.runner.cancel(task.id); await tick();
+});
+
 for (const ending of ["cancel", "failure", "hook-error", "hook-async-error"] as const) {
 	test(`successful child mutations require paired RPC events and survive ${ending}`, async () => {
 		const mutations: unknown[] = [];

package/tests/gentle-agents.test.ts

@@ -832,6 +832,40 @@ async function shutdownAndRestoreNativeSpawn(
 	}
 }
 
+for (const matching of [true, false]) {
+ test("owned child diff relay validates the exact file independently of review bookkeeping: "+matching, async () => {
+  const h=fakePi(), d=deps(), {ctx}=fakeContext();
+  const target=realpathSync(cwd);
+  (ctx as any).cwd=target;
+  ctx.sessionManager.getCwd=()=>target;
+  ctx.sessionManager.getEntries=(()=>h.entries) as any;
+  ctx.sessionManager.getBranch=(()=>h.entries) as any;
+  d.deps.resolveWorktree=(path,base)=>{
+   const full=resolve(base,path);
+   return full===target||full.startsWith(target+"/")?{root:target,commonDir:"/fixture/common"}:undefined;
+  };
+  const spawn=d.deps.spawn!;
+  d.deps.spawn=(...args)=>{
+   const child=spawn(...args),on=child.on.bind(child);
+   child.on=((event,listener)=>{if(event==="spawn")queueMicrotask(listener);return on(event,listener);}) as any;
+   return child;
+  };
+  gentleAgents(h.pi,{},d.deps);
+  await h.fire("session_start",ctx);
+  await h.tools.get("subagent_run")!.execute("diff",{agent:"explore",task:"Write",mode:"background",workspace_root:target},undefined,undefined,ctx);
+  await tick();
+  writeFileSync(join(target,"session-diff-test.ts"),"agent\n");
+  const evidence={id:"write",root:target,path:matching?"session-diff-test.ts":"different.ts",before:{kind:"text",text:"original\n"},after:{kind:"text",text:"agent\n"}};
+  d.children[0].emit({type:"tool_execution_start",toolCallId:"write",toolName:"write",args:{path:"session-diff-test.ts"}});
+  d.children[0].emit({type:"tool_execution_end",toolCallId:"write",isError:false,result:{content:[],details:{gentleSessionChange:evidence}}});
+  const relays=h.events.filter(event=>event.name==="gentle-pi:child-session-change");
+  assert.equal(relays.length,matching?1:0);
+  if(matching) assert.match((relays[0].data as any).evidence.id,/:write$/);
+  assert.equal(h.entries.filter(entry=>entry.customType===REVIEW_REMINDER_RECEIPT).length,1);
+  await h.fire("session_shutdown",ctx); await tick();
+ });
+}
+
 for (const scenario of ["own", "other-root", "escaped", "sibling", "session-switch", "shutdown", "unregistered"] as const) {
 	test(`child mutation attribution through registered subagent_run: ${scenario}`, async () => {
 		const h = fakePi();

package/tests/gentle-ai-binary.test.ts

@@ -97,7 +97,7 @@ async function writeWindowsSourceBinary(packageRoot: string): Promise<{ binaryPa
 		method: "go-sumdb-source-build",
 		package: "github.com/gentleman-programming/gentle-ai/v2/cmd/gentle-ai",
 		module: "github.com/gentleman-programming/gentle-ai/v2",
-		tag: "v2.9.0",
+		tag: "v2.9.1",
 		architecture: process.arch === "x64" ? "x64" : "arm64",
 		binarySha256: createHash("sha256").update(binary).digest("hex"),
 		moduleChecksum: GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM,