gentle-pi 2.6.4 → 3.0.0

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { ScrollView, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { renderLayoutFrame } from "@earendil-works/pi-tui/dist/layout.js";
+import { CURSOR_MARKER, ScrollView, VStack, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { getScrollViewsAt, renderLayoutFrame, type LayoutBox } from "@earendil-works/pi-tui/dist/layout.js";
 import { installSidebar, invalidateSidebar } from "../lib/shell-sidebar-layout.ts";
 import { sidebarPart, sidebarState } from "../lib/shell-sidebar.ts";
 import { renderShellSidebarBar } from "../lib/shell-bar.ts";
@@ -32,7 +32,7 @@ test("grouped Status preserves structured fields and opaque integration text", (
 	}, theme, 46);
 	const text = lines.join("\n");
 	let previous = -1;
-	for (const heading of ["Status", "Project", "Model", "Context", "Usage", "Integrations"]) {
+	for (const heading of ["Status", "Project", "Changes", "Usage", "Integrations"]) {
 		const index = text.indexOf(heading);
 		assert.ok(index > previous, heading);
 		previous = index;
@@ -67,13 +67,13 @@ test("only fullscreen at 140 columns activates; shrinking restores bottom paint"
 	}
 });
 
-test("rail orders Status, changes, agents, TODO independent of registration order", (t) => {
+test("rail orders unified Status, agents, TODO without standalone changes", (t) => {
 	const f = fixture();
 	for (const key of ["todo", "agents", "changes"]) {
 		sidebarPart(f.tui, key, { render: () => [key, ""], invalidate() {} });
 	}
 	t.after(installSidebar(f.tui, theme));
-	assert.deepEqual(rail(f).render(50).map((line) => line.trim()), ["✿ Gentle-Pi ✿", "", "Status", "", "changes", "", "agents", "", "todo"]);
+	assert.deepEqual(rail(f).render(50).map((line) => line.trim()), ["✿ Gentle Shell ✿", "", "Status", "", "agents", "", "todo"]);
 });
 
 test("branding belongs to scroll content before Status, never transcript or narrow bottom", (t) => {
@@ -81,14 +81,14 @@ test("branding belongs to scroll content before Status, never transcript or narr
 	t.after(installSidebar(f.tui, theme));
 	const scroll = rail(f);
 	const lines = scroll.render(50);
-	const brandIndex = lines.findIndex((line) => line.includes("✿ Gentle-Pi ✿"));
+	const brandIndex = lines.findIndex((line) => line.includes("✿ Gentle Shell ✿"));
 	assert.ok(brandIndex >= 0 && brandIndex < lines.findIndex((line) => line.includes("Status")));
 	assert.doesNotMatch(lines.join("\n"), /[\u2800-\u28ff]/);
 	const heading = lines[brandIndex];
 	const usableWidth = scroll.getContentWidth(50) - 2;
-	const spare = usableWidth - visibleWidth("✿ Gentle-Pi ✿");
+	const spare = usableWidth - visibleWidth("✿ Gentle Shell ✿");
 	const scrollbarWidth = 50 - scroll.getContentWidth(50);
-	assert.equal(heading, " ".repeat(1 + Math.floor(spare / 2)) + "✿ Gentle-Pi ✿" + " ".repeat(1 + Math.ceil(spare / 2) + scrollbarWidth));
+	assert.equal(heading, " ".repeat(1 + Math.floor(spare / 2)) + "✿ Gentle Shell ✿" + " ".repeat(1 + Math.ceil(spare / 2) + scrollbarWidth));
 	assert.deepEqual(f.root.render(), ["transcript"]);
 	scroll.updateLayout(lines.length, 2, () => {});
 	scroll.scrollBy(9);
@@ -249,30 +249,30 @@ test("real layout frames reuse unchanged sidebar output and invalidate at state
 	t.after(installSidebar(f.tui, theme));
 
 	const first = renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 1, changes: 1, agents: 1, todo: 1 });
+	assert.deepEqual(counts, { footer: 1, changes: 0, agents: 1, todo: 1 });
 	const sidebarRail = first.root.children[1]?.component as ScrollView;
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 1, changes: 1, agents: 1, todo: 1 });
+	assert.deepEqual(counts, { footer: 1, changes: 0, agents: 1, todo: 1 });
 
 	todo = "Todo two";
 	sidebarRail.invalidate();
 	const changed = renderLayoutFrame(f.root, 140, 20, () => {});
 	assert.match(changed.lines.join("\n"), /Todo two/);
-	assert.deepEqual(counts, { footer: 2, changes: 2, agents: 2, todo: 2 });
+	assert.deepEqual(counts, { footer: 2, changes: 0, agents: 2, todo: 2 });
 
 	f.host.terminal.columns = 139;
 	renderLayoutFrame(f.root, 139, 20, () => {});
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 	f.host.terminal.columns = 140;
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 3, changes: 3, agents: 3, todo: 3 });
+	assert.deepEqual(counts, { footer: 3, changes: 0, agents: 3, todo: 3 });
 
 	f.host.mode = "regular";
 	renderLayoutFrame(f.root, 140, 20, () => {});
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 	f.host.mode = "fullscreen";
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 4, changes: 4, agents: 4, todo: 4 });
+	assert.deepEqual(counts, { footer: 4, changes: 0, agents: 4, todo: 4 });
 
 	let replacementRenders = 0;
 	sidebarPart(f.tui, "todo", {
@@ -385,3 +385,87 @@ test("unsupported roots, empty rails and overflowing parts leave native layout i
 	t.after(installSidebar(f.tui, theme));
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 });
+
+// A real native subtree exposes duplicate rendering hidden by empty-layout fixtures.
+function nativeSidebarFixture(legacyMeasurement = false) {
+	let transcriptRenders = 0;
+	let editorRows = 1;
+	const transcript = {
+		render(width: number) {
+			transcriptRenders++;
+			return Array.from({ length: 1000 }, (_, index) => `\x1b[32mEntry ${index} 界 é at ${width}\x1b[0m`);
+		},
+		invalidate() {},
+	};
+	const primary = new ScrollView(transcript, { primary: true, follow: "end", scrollbar: "always" });
+	const editor = { render: () => Array.from({ length: editorRows }, (_, index) => `Editor ${index}${index === editorRows - 1 ? CURSOR_MARKER : ""}`), invalidate() {} };
+	const root = new VStack([{ component: primary, basis: 0, grow: 1 }, { component: editor }]);
+	const originalRender = root.render;
+	const host = { mode: "fullscreen", terminal: { columns: 180 }, layoutRoot: root, requestRender() {} };
+	const tui = host as unknown as TUI;
+	sidebarPart(tui, "footer", { render: () => Array.from({ length: 100 }, (_, i) => `Status ${i}`), invalidate() {} });
+	const dispose = installSidebar(tui, theme);
+	const nativeRoot = root as unknown as { [NODE](): { entries: Array<{ component: { render(width: number): string[] } }> } };
+	if (legacyMeasurement) nativeRoot[NODE]().entries[0].component.render = (width) => root.render(width);
+	return {
+		root, primary, host, dispose, originalRender,
+		growEditor: () => { editorRows = 4; },
+		frame(width = host.terminal.columns, height = 30) {
+			host.terminal.columns = width;
+			transcriptRenders = 0;
+			const frame = renderLayoutFrame(root, width, height, () => {});
+			return { frame, transcriptRenders };
+		},
+	};
+}
+
+function layoutGeometry(box: LayoutBox): unknown {
+	return { rect: box.rect, clip: box.clip, lineOffset: box.lineOffset, scroll: !!box.scrollView, children: box.children.map(layoutGeometry) };
+}
+
+test("fullscreen native transcript renders once without changing bytes, geometry or primary scroll", (t) => {
+	const current = nativeSidebarFixture();
+	const legacy = nativeSidebarFixture(true);
+	t.after(current.dispose);
+	t.after(legacy.dispose);
+	for (const grow of [false, true]) {
+		if (grow) { current.growEditor(); legacy.growEditor(); }
+		for (const [width, height] of [[180, 30], [140, 18], [220, 50]]) {
+			const actual = current.frame(width, height);
+			const expected = legacy.frame(width, height);
+			assert.equal(actual.transcriptRenders, 1, "measurement must not render the native transcript");
+			assert.equal(expected.transcriptRenders, 2, "legacy control must reproduce the redundant render");
+			assert.deepEqual(actual.frame.lines, expected.frame.lines);
+			assert.deepEqual(layoutGeometry(actual.frame.root), layoutGeometry(expected.frame.root));
+			assert.equal(actual.frame.primaryScrollView, current.primary);
+			assert.equal(current.root.render, current.originalRender, "native root rendering is not patched");
+			assert.ok(actual.frame.lines.some(line => line.includes(CURSOR_MARKER)), "editor cursor remains visible");
+		}
+	}
+});
+
+test("native transcript and sidebar keep separate scroll routing across resize, breakpoint and mode transitions", (t) => {
+	const fixture = nativeSidebarFixture();
+	t.after(fixture.dispose);
+	let result = fixture.frame();
+	const rail = result.frame.root.children[1].component as ScrollView;
+	assert.equal(getScrollViewsAt(result.frame, 1, 1)[0], fixture.primary);
+	assert.equal(getScrollViewsAt(result.frame, 179, 1)[0], rail);
+	const transcriptTop = fixture.primary.scrollTop;
+	rail.scrollBy(5);
+	result = fixture.frame();
+	assert.equal(fixture.primary.scrollTop, transcriptTop);
+	assert.equal(rail.scrollTop, 5);
+	fixture.primary.scrollBy(-7);
+	result = fixture.frame();
+	assert.equal(fixture.primary.scrollTop, transcriptTop - 7);
+	assert.equal(rail.scrollTop, 5);
+	assert.equal(result.transcriptRenders, 1);
+	for (const [mode, width] of [["fullscreen", 139], ["fullscreen", 140], ["regular", 180], ["fullscreen", 180]] as const) {
+		fixture.host.mode = mode;
+		result = fixture.frame(width);
+		assert.equal(result.transcriptRenders, 1);
+		assert.equal(result.frame.primaryScrollView, fixture.primary);
+		assert.equal(result.frame.root.children.some(box => box.component === rail), mode === "fullscreen" && width >= 140);
+	}
+});

package/tests/startup-banner.test.ts

@@ -2,11 +2,63 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { syncBuiltinESMExports } from "node:module";
 import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import startup, { readGitBranch } from "../extensions/startup-banner.ts";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 
+test("startup artwork spells Gentle Shell with aligned animation spans", () => {
+	const source = readFileSync(new URL("../extensions/startup-banner.ts", import.meta.url), "utf8");
+	const logo = JSON.parse(source.match(/const TEXT_LOGO = (\[[\s\S]*?\]);/)![1].replace(/,\s*]/, "]")) as string[];
+	const weights = JSON.parse(source.match(/const LETTER_WEIGHTS = (\[[^;]+\]);/)![1]) as number[];
+	// Preserve the original script, including its descending G and dark shadow.
+	const gentle = [
+		"                  ▄▄▄▀▀▀▀▀██                                ▄▄▀▄▄",
+		"              ▄▄█▀▀▒▒▒▒▒▄▄█▀▒                   ▄██     ▄▄█▀█▄█▀▒▒",
+		"          ▄▄██▀▒▒▒▒▒▄▄▄▀▀▒▒▒▒        ▄▄▄  ▀▀▀▀██▀▀▀▀▀███▀█▄▀▀▒▒▒▒",
+		"        ▄██▀▒▒▒▒     ▒▒▄▄█ ▄▄▄▀██ ▄▄▄▀▀▀▄  ▄██▀▒▒▒▒▄██▀▀▀▒▄▄███",
+		"       ██▀▒▒▒     ▄▄▄███▀▄██▀▀▀▄▄██▀▀▄█▀▄▄██▀▒▒▒▄▄██▀▒▒▄██▀▀▀▄▄",
+		"       ▀█▄▄▄▄▄▀▀▀█▄▄███▄▒▀▀▀▀▀▀▒▀▀▒▒▀▀▀▀▒██▄▄▀▀▀ ▀█▄▀▀▀ ▀▀▀▀▀▒▒",
+		"        ▒▄▄▄█▀▀▀█▄█▀▀▒▒▒▒ ▒▒▒▒▒▒ ▒▒  ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒",
+		"     ▄▄▀▀ ▒▒▒▒▄██▀▒▒▒▒",
+		"   ▄█ ▒▒▒▄▄██▀▀▒▒▒▒",
+		"    ▀▀▀▀▀▀▒▒▒▒▒▒",
+		"     ▒▒▒▒▒▒",
+	];
+	assert.equal(logo.length, 11, "retain the full-height script silhouette");
+	for (const [row, prefix] of gentle.entries()) {
+		assert.ok(logo[row].startsWith(prefix), `original Gentle script row ${row}`);
+		assert.ok(logo[row].includes("▒") || row === 0, "retain dark shadow");
+	}
+	assert.equal(weights.length, 11, "one variable-width span per GENTLESHELL letter");
+	assert.ok(new Set(weights).size > 2, "script spans must not use fixed block-font widths");
+	assert.ok(logo.slice(0, 7).every((line) => /[▄▀█]/.test(line.slice(68))), "Shell has tall slanted strokes");
+	assert.ok(logo.slice(1, 7).every((line) => /▒/.test(line.slice(68))), "Shell retains the dark shadow");
+	const shell = logo.map((line) => line.slice(68));
+	assert.match(shell[0], /▄▄█▀▀▀██/, "S has its upper bowl");
+	assert.match(shell[3], /▀▀▀██▄▄/, "S curves into its lower bowl");
+	assert.match(shell[5], /▀█▄▄▄▄█▀▀▒▒/, "S closes with a shadowed exit stroke");
+	assert.match(shell[4], /▄██▀▄██▀██▒/, "h has a rising stem and connected arch");
+	assert.deepEqual(logo.slice(3, 6).map((line) => line.slice(93, 101)), [
+		" ▄▄▀▀██ ",
+		"▄██▄▄▀▒ ",
+		"▀█▄▄▄▄▀▀",
+	], "e has an upper loop/counter, a crossbar, and a curved lower exit rather than a wedge");
+	assert.equal(logo[3][100], " ", "e loop stays distinct from the following l");
+	assert.equal(logo[4][100], " ", "e counter opens before the l stem without moving it");
+	assert.equal(shell[0].split("▄▄▀▄▄").length - 1, 2, "both l ascenders retain looped tops");
+	assert.match(shell[5], /█▄▄▀▀▀▄▄▀█▄▄▀▀▀$/, "both l exits connect with an ascending script stroke");
+	assert.equal(Math.max(...logo.map((line) => line.length)), 120, "connected script retains glyph scale while tightening letter placement");
+	// Like Gentle, adjacent baseline strokes must meet, not merely have smaller gaps.
+	assert.match(shell[4], /▀██▄▄██▀▄██▀██▒/, "S exit meets the h entry");
+	assert.match(shell[5], /▀█▄▄▄▄▀▀█▄▄▀▀▀/, "e lower exit still meets the unchanged l stem");
+	assert.match(shell[5], /██▄▄▀▀█▄▄▄▄▀▀/, "h exit remains connected to e");
+	assert.deepEqual(weights, [22, 9, 8, 9, 8, 9, 10, 13, 8, 8, 13]);
+	assert.equal(weights.reduce((sum, width) => sum + width, 0), Math.max(...logo.map((line) => line.length)) - 3,
+		"span widths exactly cover the ink bounds from the G descender to the final l shadow");
+});
+
 test("startup branch lookup uses direct git argv and hides its Windows child", async () => {
 	const calls: Array<{ command: string; args: readonly string[]; options: Record<string, unknown> }> = [];
 	const run = ((command: string, args: readonly string[], options: Record<string, unknown>, callback: (error: Error | null, stdout: string) => void) => {
@@ -46,6 +98,7 @@ test("startup banner keeps animating after invalidate and cleans up on dispose",
 		header = factory({ requestRender() { renders++; } }, { fg: (_role: string, text: string) => text });
 	} } });
 	t.mock.timers.tick(50);
+	assert.match(header!.render(200).join("\n"), /\x1b\[38;2;95;30;60m▒/, "script shadow keeps the dark pink palette");
 	const afterBoot = renders;
 	t.mock.timers.tick(25);
 	assert.ok(renders > afterBoot, "animation timer requests renders");
@@ -91,13 +144,13 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 		} } });
 		t.mock.timers.tick(50);
 		try {
-			for (const width of [40, 80, 160]) {
+			for (const width of [40, 80, 160, 200]) {
 				const lines = header!.render(width);
 				assert.ok(lines.every((line) => visibleWidth(line) <= width));
 				const text = stripAnsi(lines.join("\n"));
 				assert.match(text, /GIT:/);
 				assert.match(text, /PATH:/);
-				if (width === 160) {
+				if (width >= 160) {
 					assert.equal(/[\u2800-\u28ff]/.test(text), showRose);
 					assert.equal(/[▒▄▀█]/.test(text), showTextLogo);
 				}

package/tests/windows-hidden-processes.test.ts

@@ -0,0 +1,303 @@
+import assert from "node:assert/strict";
+import { createRequire, syncBuiltinESMExports } from "node:module";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import type { TestContext } from "node:test";
+import test from "node:test";
+import type { ReceiptBodyV1 } from "../lib/review-transaction.ts";
+
+type Options = Record<string, unknown>;
+type Capture = {
+	kind: "execFileSync" | "execFile" | "spawnSync";
+	command: string;
+	args: readonly string[];
+	options: Options;
+};
+type Trace = { label: string; captures: Capture[] };
+type ExpectedCall = Pick<Capture, "kind" | "command" | "args">;
+
+async function trace<T>(captures: Capture[], traces: Trace[], label: string, action: () => T | Promise<T>, expected: readonly ExpectedCall[]): Promise<T> {
+	const start = captures.length;
+	const result = await action();
+	const route = captures.slice(start);
+	assert.deepEqual(route.map(({ kind, command, args }) => ({ kind, command, args })), expected, `${label} must use its documented public route`);
+	traces.push({ label, captures: route });
+	return result;
+}
+
+function childProcess(): typeof import("node:child_process") {
+	return createRequire(import.meta.url)("node:child_process") as typeof import("node:child_process");
+}
+
+function fakeGitResult(command: string, args: readonly string[], cwd: string): string {
+	if (command !== "git") return "";
+	if (args.includes("--show-toplevel")) return cwd;
+	if (args.includes("--git-common-dir")) return `${cwd}/.git`;
+	if (args.includes("--show-object-format")) return "sha1";
+	if (args.includes("--is-shallow-repository")) return "false";
+	if (args.includes("--git-path")) return join(cwd, ".git", "gentle-ai", "reviews");
+	if (args.includes("--max-parents=0")) return "a".repeat(40);
+	if (args[0] === "cat-file" && args[1] === "-t") return "tree";
+	if (args.includes("--verify")) {
+		const object = args.find((value) => value.endsWith("^{object}"));
+		return object === `${"b".repeat(40)}^{object}` ? "b".repeat(40) : "b".repeat(40);
+	}
+	if (args.includes("ls-files")) return "tests/windows-hidden-processes.test.ts\0";
+	throw new Error(`windows-hidden fixture: unexpected execFileSync git argv ${args.join(" ")}`);
+}
+
+function approvedReceipt(
+	transaction: typeof import("../lib/review-transaction.ts"),
+	fixtures: typeof import("./review-test-fixtures.ts"),
+	tree: string,
+) {
+	const current = transaction.createReviewState({
+		lineageId: "windows-hidden-gate",
+		mode: "ordinary",
+		snapshot: fixtures.testSnapshot({
+			baseTree: "1".repeat(40),
+			completeTree: "2".repeat(40),
+			initialTree: "3".repeat(40),
+			route: "standard",
+			lenses: ["review-risk"],
+		}),
+		evidenceHash: "b".repeat(64),
+		budget: { review_batches: 1, review_actors: 1, refuter_batches: 1, fix_batches: 1, validator_runs: 1, final_verifications: 1, judgment_rounds: 0, judge_runs: 0 },
+	});
+	const body: ReceiptBodyV1 = {
+		schema: "gentle-ai.review-receipt-body/v1",
+		lineage_id: current.lineage_id,
+		mode: current.mode,
+		base_tree: current.base_tree,
+		complete_snapshot_tree: current.complete_snapshot_tree,
+		review_projection: current.review_projection,
+		initial_review_tree: current.initial_review_tree,
+		final_candidate_tree: tree,
+		route: current.route,
+		lenses: current.lenses,
+		policy_hash: current.policy_hash,
+		frozen_ledger_hash: "c".repeat(64),
+		evidence_hash: current.evidence_hash,
+		budget: current.budget,
+		counters: current.counters,
+		terminal_state: "approved",
+	};
+	return transaction.createReceiptEnvelope(body);
+}
+
+function fakeSpawnResult(command: string, args: readonly string[], cwd: string): { status: number; stdout: string } {
+	if (command !== "git") return { status: 0, stdout: "" };
+	if (args.join(" ") === "rev-parse --show-toplevel") return { status: 0, stdout: `${cwd}\n` };
+	if (args.length === 3 && args[0] === "-C" && args[2] === "remote") return { status: 0, stdout: "origin\n" };
+	if (args.includes("get-url")) return { status: 0, stdout: "https://example.invalid/repo.git\n" };
+	if (args.includes("check-ref-format")) return { status: 0, stdout: "" };
+	if (args.includes("ls-remote")) return { status: 0, stdout: `${"c".repeat(40)}\trefs/heads/main\n` };
+	if (args[2] === "config") return { status: 0, stdout: "" };
+	throw new Error(`windows-hidden fixture: unexpected spawnSync git argv ${args.join(" ")}`);
+}
+
+async function captureOwnedRoutes(t: TestContext): Promise<{ captures: Capture[]; traces: Trace[] }> {
+	const cp = childProcess();
+	const original = { execFileSync: cp.execFileSync, execFile: cp.execFile, spawnSync: cp.spawnSync };
+	const captures: Capture[] = [];
+	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-windows-hidden-workspace-"));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	mkdirSync(join(cwd, ".git"), { recursive: true });
+	const fakeSync = ((command: string, args: readonly string[], options: Options = {}) => {
+		captures.push({ kind: "execFileSync", command, args, options });
+		return fakeGitResult(command, args, String(options.cwd ?? cwd));
+	}) as unknown as typeof cp.execFileSync;
+	const fakeAsync = function(command: string, args: readonly string[], options: Options, callback: (error: null, stdout: string, stderr: string) => void) {
+		captures.push({ kind: "execFile", command, args, options });
+		if (process.platform === "win32" && command === "codegraph") {
+			callback(Object.assign(new Error("fixture shim missing"), { code: "ENOENT" }) as never, "", "");
+		} else {
+			callback(null, "indexed", "");
+		}
+		return undefined;
+	} as unknown as typeof cp.execFile;
+	(fakeAsync as unknown as { [promisify.custom]?: unknown })[promisify.custom] = async (command: string, args: readonly string[], options: Options) => {
+		captures.push({ kind: "execFile", command, args, options });
+		if (process.platform === "win32" && command === "codegraph") throw Object.assign(new Error("fixture shim missing"), { code: "ENOENT" });
+		return { stdout: "indexed", stderr: "" };
+	};
+	const fakeSpawn = ((command: string, args: readonly string[], options: Options = {}) => {
+		const result = fakeSpawnResult(command, args, String(options.cwd ?? cwd));
+		captures.push({ kind: "spawnSync", command, args, options });
+		if (command === "gh") return { status: 0, stdout: '{"total_count":0,"returned":0,"checks":[]}' };
+		return { ...result, stderr: "" };
+	}) as unknown as typeof cp.spawnSync;
+	try {
+		cp.execFileSync = fakeSync;
+		cp.execFile = fakeAsync;
+		cp.spawnSync = fakeSpawn;
+		syncBuiltinESMExports();
+		let fallbackRoot: string | undefined;
+		let fallbackCalls: ExpectedCall[] = [];
+	if (process.platform === "win32") {
+		fallbackRoot = mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-contract-"));
+		t.after(() => rmSync(fallbackRoot!, { recursive: true, force: true }));
+		const packageRoot = join(fallbackRoot, "node_modules", "@colbymchenry", "codegraph");
+		mkdirSync(packageRoot, { recursive: true });
+		writeFileSync(join(fallbackRoot, "codegraph.cmd"), "@ECHO off\n");
+		writeFileSync(join(packageRoot, "package.json"), JSON.stringify({ bin: { codegraph: "entry.js" } }));
+		writeFileSync(join(packageRoot, "entry.js"), "// fixture entry\n");
+		const previousPath = process.env.Path;
+		const previousUpperPath = process.env.PATH;
+		t.after(() => { if (previousPath === undefined) delete process.env.Path; else process.env.Path = previousPath; });
+		t.after(() => { if (previousUpperPath === undefined) delete process.env.PATH; else process.env.PATH = previousUpperPath; });
+		process.env.Path = fallbackRoot;
+		process.env.PATH = fallbackRoot;
+		fallbackCalls = [{ kind: "execFile", command: process.execPath, args: [join(fallbackRoot, "node_modules", "@colbymchenry", "codegraph", "entry.js"), "init", cwd] }];
+	}
+	// The fixed query prevents accidental cache misses from becoming a fake proof.
+		const query = "?windows-hidden-contract";
+		const codegraph = await import(`../extensions/codegraph-tools.ts${query}`);
+		const repository = await import(`../lib/review-repository.ts${query}`);
+		const snapshot = await import(`../lib/review-snapshot.ts${query}`);
+		const transaction = await import(`../lib/review-transaction.ts${query}`);
+		const fixtures = await import(`./review-test-fixtures.ts${query}`);
+		const publication = await import(`../lib/review-publication-gate.ts${query}`);
+		const gentleAi = await import(`../extensions/gentle-ai.ts${query}`);
+
+		const traces: Trace[] = [];
+		const graph = codegraph.createCodeGraphTool();
+		assert.equal(typeof graph.execute, "function", "CodeGraph public handler must be registered");
+		const graphResult = await trace(captures, traces, "CodeGraph init", () => graph.execute("capture", { operation: "init" }, undefined, undefined, { cwd } as never), [
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "execFile", command: "codegraph", args: ["init", cwd] },
+			...fallbackCalls,
+		]);
+		const graphText = String((graphResult as { content?: Array<{ text?: string }> }).content?.[0]?.text ?? "");
+		assert.match(graphText, /indexed/, "CodeGraph must return the fixture command result");
+
+		const tools = new Map<string, { execute: (...args: unknown[]) => Promise<unknown> }>();
+		gentleAi.createGentleAiExtension({ nativeReviewCli: { targetStatus: async () => ({}) } as never })({
+			registerTool(definition: { name: string; execute: (...args: unknown[]) => Promise<unknown> }) { tools.set(definition.name, definition); },
+			registerCommand() {}, on() {},
+		} as never);
+		const review = tools.get("gentle_review");
+		assert.ok(review, "gentle_review public handler must be registered");
+		await trace(captures, traces, "gentle_review inspect", () => review.execute("capture", { operation: "inspect", workspaceRoot: cwd }, undefined, undefined, { cwd, hasUI: false } as never), [
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--git-common-dir"] },
+		]);
+
+		const authority = await trace(captures, traces, "repository authority", () => repository.reviewStoreRootForRepositoryV1(cwd), [
+			{ kind: "execFileSync", command: "git", args: ["-C", cwd, "rev-parse", "--path-format=absolute", "--git-common-dir"] },
+			{ kind: "execFileSync", command: "git", args: ["-C", cwd, "rev-parse", "--show-object-format"] },
+			{ kind: "execFileSync", command: "git", args: ["-C", cwd, "rev-parse", "--is-shallow-repository"] },
+			{ kind: "execFileSync", command: "git", args: ["-C", cwd, "rev-list", "--max-parents=0", "--all"] },
+		]);
+		assert.equal(authority, join(cwd, ".git", "gentle-ai", "reviews"));
+		const untracked = await trace(captures, traces, "snapshot untracked discovery", () => snapshot.discoverReviewUntrackedPaths(cwd), [
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "execFileSync", command: "git", args: ["ls-files", "--others", "--exclude-standard", "-z"] },
+		]);
+		assert.deepEqual(untracked, ["tests/windows-hidden-processes.test.ts"]);
+		const storeRoot = await trace(captures, traces, "transaction store root", () => transaction.reviewStoreRootForRepository(cwd), [
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--git-path", "gentle-ai/reviews"] },
+		]);
+		assert.equal(storeRoot, join(cwd, ".git", "gentle-ai", "reviews"));
+		const gateTree = "b".repeat(40);
+		const gate = await trace(captures, traces, "transaction intended-commit gate", () => transaction.evaluateGateTarget(
+			approvedReceipt(transaction, fixtures, gateTree),
+			{ kind: publication.GATE_TARGET_KIND.INTENDED_COMMIT, intended_commit_tree: gateTree }, cwd, gateTree,
+		), [
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--verify", `${gateTree}^{object}`] },
+			{ kind: "execFileSync", command: "git", args: ["cat-file", "-t", gateTree] },
+			{ kind: "execFileSync", command: "git", args: ["rev-parse", "--verify", `${gateTree}^{object}`] },
+			{ kind: "execFileSync", command: "git", args: ["cat-file", "-t", gateTree] },
+		]);
+		assert.equal(gate.status, publication.GATE_RESULT.ALLOW);
+		const destination = await trace(captures, traces, "publication configured destination", () => publication.resolveConfiguredPushDestinationV1(cwd, "origin"), [
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote", "get-url", "--push", "--all", "origin"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "config", "--get-all", "remote.origin.pushurl"] },
+		]);
+		assert.equal(destination.url, "https://example.invalid/repo.git");
+		await trace(captures, traces, "publication remote ref", () => publication.resolvePushRemoteRefV1(cwd, "origin", "refs/heads/main", "remote ref"), [
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote", "get-url", "--push", "--all", "origin"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "config", "--get-all", "remote.origin.pushurl"] },
+			{ kind: "spawnSync", command: "git", args: ["ls-remote", "--refs", "https://example.invalid/repo.git", "refs/heads/main"] },
+		]);
+		await trace(captures, traces, "publication destination ref", () => publication.resolvePushDestinationRefV1(cwd, "origin", "main", "refs/heads/main", "destination"), [
+			{ kind: "spawnSync", command: "git", args: ["check-ref-format", "refs/main"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote", "get-url", "--push", "--all", "origin"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "config", "--get-all", "remote.origin.pushurl"] },
+			{ kind: "spawnSync", command: "git", args: ["ls-remote", "--refs", "https://example.invalid/repo.git"] },
+		]);
+		await trace(captures, traces, "publication advertised object", () => publication.pushRemoteAdvertisesObjectV1(cwd, "origin", destination.destination_id, "c".repeat(40)), [
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote", "get-url", "--push", "--all", "origin"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "config", "--get-all", "remote.origin.pushurl"] },
+			{ kind: "spawnSync", command: "git", args: ["ls-remote", "--refs", "https://example.invalid/repo.git"] },
+		]);
+		const remoteHead = await trace(captures, traces, "publication remote head", () => publication.recheckReleaseFastPathRemoteHeadV1({ repositoryCwd: cwd, remote: "origin", expectedRemoteHead: "c".repeat(40) }), [
+			{ kind: "spawnSync", command: "git", args: ["rev-parse", "--show-toplevel"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote"] },
+			{ kind: "spawnSync", command: "git", args: ["-C", cwd, "remote", "get-url", "origin"] },
+			{ kind: "spawnSync", command: "git", args: ["ls-remote", "--refs", "https://example.invalid/repo.git", "refs/heads/main"] },
+		]);
+		assert.deepEqual(remoteHead, { advanced: false, remote_head: "c".repeat(40) });
+		const ci = await trace(captures, traces, "publication GH CI", () => publication.recheckReleaseFastPathCiStatusV1({ repositoryCwd: cwd, sha: "f".repeat(40), expectedStatus: "success" }), [
+			{ kind: "spawnSync", command: "gh", args: ["api", "repos/{owner}/{repo}/commits/ffffffffffffffffffffffffffffffffffffffff/check-runs?per_page=100", "--jq", "{total_count, returned: (.check_runs | length), checks: [.check_runs[] | [.status, .conclusion]]}"] },
+			{ kind: "spawnSync", command: "gh", args: ["api", "repos/{owner}/{repo}/commits/ffffffffffffffffffffffffffffffffffffffff/status", "--jq", ".state"] },
+		]);
+		assert.deepEqual(ci, { proven: false, status: null });
+		return { captures, traces };
+	} finally {
+		cp.execFileSync = original.execFileSync;
+		cp.execFile = original.execFile;
+		cp.spawnSync = original.spawnSync;
+		syncBuiltinESMExports();
+		t.after(() => {
+			cp.execFileSync = original.execFileSync;
+			cp.execFile = original.execFile;
+			cp.spawnSync = original.spawnSync;
+			syncBuiltinESMExports();
+		});
+	}
+}
+
+test("owned public adapters pass windowsHide at every mapped Node child-process boundary", async (t) => {
+	const { traces } = await captureOwnedRoutes(t);
+	assert.deepEqual(traces.map(({ label }) => label), [
+		"CodeGraph init",
+		"gentle_review inspect",
+		"repository authority",
+		"snapshot untracked discovery",
+		"transaction store root",
+		"transaction intended-commit gate",
+		"publication configured destination",
+		"publication remote ref",
+		"publication destination ref",
+		"publication advertised object",
+		"publication remote head",
+		"publication GH CI",
+	], "all twelve mapped public actions must complete before flag assertions");
+	for (const trace of traces) {
+		for (const capture of trace.captures) {
+			assert.equal(capture.options.windowsHide, true, `${trace.label}: ${capture.kind} ${capture.command} must hide Windows consoles`);
+		}
+	}
+});
+
+test("external editor remains the explicit interactive exemption", async () => {
+	const shell = await import("../extensions/gentle-shell.ts");
+	let received: Options | undefined;
+	const host = { stop() {}, start() {}, requestRender() {} };
+	assert.equal(shell.openInExternalEditor(host, "editor.txt", { EDITOR: "fixture-editor" }, ((_command: string, _args: readonly string[], options: Options) => {
+		received = options;
+		return { status: 0 };
+	}) as never, process.cwd()), true);
+	assert.equal(received?.shell, process.platform === "win32");
+	assert.equal(received?.stdio, "inherit");
+	assert.equal(received?.windowsHide, undefined, "the interactive editor intentionally remains unhidden");
+});