gentle-pi 3.7.0 → 4.0.0

package/tests/rdd-aware-verification-contract.test.ts

@@ -2,6 +2,8 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 
 // ---------------------------------------------------------------------------
 // gentle-pi#661/#662: RDD-aware verification rule for delegated work.
@@ -130,10 +132,11 @@ test("delegation overlay keeps the required headings", () => {
 		"### Delegation Rules",
 		"#### Background Subagent Policy",
 		"#### Allowed edit surfaces (MANDATORY)",
-		"### 3. SDD (optional)",
+		"### 2. Simple Delegation",
 	]) {
 		assert.ok(delegation.includes(heading), `delegation overlay lost required heading: ${heading}`);
 	}
+	assert.doesNotMatch(delegation, /### 3\. SDD \(optional\)/);
 });
 
 test("worker asset declares the Verification section after Test discipline", () => {
@@ -224,3 +227,75 @@ test("worker asset keeps the existing Return contract fields", () => {
 		assert.ok(worker.includes(field), `worker asset lost Return contract field: ${field}`);
 	}
 });
+
+// ---------------------------------------------------------------------------
+// gentle-pi#1175: the verification policy is stated on three surfaces -- the
+// `gentle_review` tool contract (description, guidelines, parameters), the
+// delegation asset, and docs/delegated-verification.md -- and they must say
+// the same thing about the behavior ASSESS implements: closure only from the
+// native `candidate.consumed` fact for this candidate, the runtime writer
+// profile with a caller fallback, the conservative small-model bias, the
+// declined/unavailable/unknown fallback, and functional checks that a native
+// review never replaces. Assertions use short stable phrases, normalized for
+// case, quoting, and line wrapping, not whole paragraphs.
+// ---------------------------------------------------------------------------
+
+interface RegisteredPolicyTool {
+	name: string;
+	description?: string;
+	promptSnippet?: string;
+	promptGuidelines?: readonly string[];
+	parameters?: unknown;
+}
+
+function registeredReviewToolContract(): string {
+	const tools = new Map<string, RegisteredPolicyTool>();
+	const pi = {
+		on() {},
+		registerCommand() {},
+		registerTool(definition: RegisteredPolicyTool) {
+			tools.set(definition.name, definition);
+		},
+	} as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null })(pi);
+	const tool = tools.get("gentle_review");
+	assert.ok(tool, "gentle_review must be registered");
+	return [tool.description ?? "", tool.promptSnippet ?? "", ...(tool.promptGuidelines ?? []), JSON.stringify(tool.parameters)].join("\n");
+}
+
+function normalizePolicyText(text: string): string {
+	return text.replace(/\\"/g, "").replace(/[`"']/g, "").replace(/\s+/g, " ").toLowerCase();
+}
+
+const POLICY_SURFACES: ReadonlyArray<readonly [string, string]> = [
+	["gentle_review tool contract", normalizePolicyText(registeredReviewToolContract())],
+	["assets/orchestrator-delegation.md", normalizePolicyText(delegation)],
+	["docs/delegated-verification.md", normalizePolicyText(read("docs/delegated-verification.md"))],
+];
+
+const SHARED_POLICY_PHRASES: ReadonlyArray<readonly [string, string]> = [
+	["closure only from native consumed evidence", "only from the native candidate.consumed fact for this exact candidate"],
+	["caller closure claim is not authority", "a caller-supplied closed is not authority"],
+	["runtime writer profile", "runtime-recorded model and effort of the pending mutations"],
+	["caller profile is only a fallback", "only a fallback when no runtime evidence exists"],
+	["conservative small-model bias", "keeps the conservative small-model bias"],
+	["non-closed outcomes fall back", "declined, unavailable, or unknown"],
+	["unknown is never closed", "unknown is never treated as closed"],
+	["functional checks still run", "a native code review is not a substitute for applicable functional checks"],
+];
+
+test("the three verification policy surfaces carry the same ASSESS closure, profile, fallback, and functional-check statements (gentle-pi#1175)", () => {
+	for (const [surface, text] of POLICY_SURFACES) {
+		for (const [statement, phrase] of SHARED_POLICY_PHRASES) {
+			assert.ok(text.includes(phrase), `${surface} is missing the ${statement} statement: "${phrase}"`);
+		}
+	}
+});
+
+test("no verification policy surface still tells callers to pass closed explicitly (gentle-pi#1175)", () => {
+	for (const [surface, text] of POLICY_SURFACES) {
+		for (const stale of ["closed is never derived", "closed is never auto-derived", "closed is never inferred", "pass it explicitly", "pass it only right after"]) {
+			assert.ok(!text.includes(stale), `${surface} still carries the retired explicit-closure wording: "${stale}"`);
+		}
+	}
+});

package/tests/rdd-status-line.test.ts

@@ -176,10 +176,15 @@ test("resolveRddModeStatus resolves to undefined within the deadline when review
 	const neverSettling = fakeReviewMode(() => new Promise<never>(() => {}));
 	const deadlineMs = 150;
 	const start = Date.now();
-	const status = await resolveRddModeStatus(neverSettling, "/repo-hung", AbortSignal.timeout(deadlineMs));
-	const elapsed = Date.now() - start;
-	assert.equal(status, undefined);
-	assert.ok(elapsed < deadlineMs + 1000, `expected the read to resolve near the ${deadlineMs}ms deadline, took ${elapsed}ms`);
+	const keepalive = setTimeout(() => {}, deadlineMs + 2000);
+	try {
+		const status = await resolveRddModeStatus(neverSettling, "/repo-hung", AbortSignal.timeout(deadlineMs));
+		const elapsed = Date.now() - start;
+		assert.equal(status, undefined);
+		assert.ok(elapsed < deadlineMs + 1000, `expected the read to resolve near the ${deadlineMs}ms deadline, took ${elapsed}ms`);
+	} finally {
+		clearTimeout(keepalive);
+	}
 });
 
 test("resolveRddModeStatus memoizes a resolved status per cwd for RDD_STATUS_MEMO_TTL_MS", async () => {

package/tests/resume-hint-extension.test.ts

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import test from "node:test";
+import resumeHint, { resetResumeHintState } from "../extensions/resume-hint.ts";
+import { RESUME_HANDOFF_ENV, parseResumeHandoff } from "../lib/gentle-shell-resume-hint.ts";
+
+const ID = "01a0e0a0-6d7b-7314-89c1-537d47bbf4f3";
+
+// A private dir shaped like the launcher's (<tmpdir>/gentle-shell-resume-XXXXXX).
+const handoffDir = () => mkdtempSync(join(tmpdir(), "gentle-shell-resume-"));
+
+type Handler = (event: { reason: string }, ctx: unknown) => void;
+
+function loadExtension(env: NodeJS.ProcessEnv): Handler[] {
+	const shutdown: Handler[] = [];
+	const pi = { on: (name: string, handler: Handler) => { if (name === "session_shutdown") shutdown.push(handler); } };
+	resumeHint(pi as never, env);
+	return shutdown;
+}
+
+// The session cwd defaults to the launch directory (pi never changes it).
+function fakeContext(dir: string, mode = "tui", cwd = process.cwd()) {
+	const sessionFile = join(dir, "session.jsonl");
+	writeFileSync(sessionFile, "{}\n");
+	return {
+		mode,
+		sessionManager: {
+			getSessionId: () => ID,
+			getSessionDir: () => dir,
+			getSessionFile: () => sessionFile,
+			getCwd: () => cwd,
+		},
+	};
+}
+
+test("extension is inert without the launcher handoff env", () => {
+	assert.equal(loadExtension({}).length, 0);
+});
+
+test("extension claims the env var so child processes cannot inherit it", () => {
+	const env: NodeJS.ProcessEnv = { [RESUME_HANDOFF_ENV]: join(tmpdir(), "gentle-shell-resume-unused", "handoff.json") };
+	loadExtension(env);
+	resetResumeHintState();
+	assert.equal(env[RESUME_HANDOFF_ENV], undefined);
+});
+
+test("extension keeps the claimed handoff across /reload", () => {
+	const dir = handoffDir();
+	try {
+		const handoffPath = join(dir, "handoff.json");
+		const env: NodeJS.ProcessEnv = { [RESUME_HANDOFF_ENV]: handoffPath };
+		loadExtension(env);
+		// A reload re-runs the factory with the env var already claimed.
+		const [onShutdown] = loadExtension(env);
+		assert.ok(onShutdown);
+		onShutdown({ reason: "quit" }, fakeContext(dir));
+		assert.equal(parseResumeHandoff(readFileSync(handoffPath, "utf8"))?.sessionId, ID);
+	} finally {
+		resetResumeHintState();
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test("extension writes the handoff only for an interactive quit", () => {
+	const dir = handoffDir();
+	try {
+		const handoffPath = join(dir, "handoff.json");
+		const [onShutdown] = loadExtension({ [RESUME_HANDOFF_ENV]: handoffPath });
+		for (const reason of ["reload", "new", "resume", "fork"]) onShutdown({ reason }, fakeContext(dir));
+		for (const mode of ["rpc", "print", "json"]) onShutdown({ reason: "quit" }, fakeContext(dir, mode));
+		assert.throws(() => readFileSync(handoffPath, "utf8"));
+		onShutdown({ reason: "quit" }, fakeContext(dir));
+		assert.deepEqual(parseResumeHandoff(readFileSync(handoffPath, "utf8")), { sessionId: ID, sessionDir: dir });
+	} finally {
+		resetResumeHintState();
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test("extension ignores a handoff path that is not the launcher's private file", () => {
+	const dir = handoffDir();
+	try {
+		const target = join(dir, "not-a-handoff.json");
+		const env: NodeJS.ProcessEnv = { [RESUME_HANDOFF_ENV]: target };
+		assert.equal(loadExtension(env).length, 0);
+		assert.equal(env[RESUME_HANDOFF_ENV], undefined);
+	} finally {
+		resetResumeHintState();
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test("extension never overwrites an existing file or follows a planted symlink", { skip: process.platform === "win32" && "creating symlinks needs privileges on Windows" }, () => {
+	const dir = handoffDir();
+	try {
+		const victim = join(dir, "victim.txt");
+		writeFileSync(victim, "keep");
+		const handoffPath = join(dir, "handoff.json");
+		symlinkSync(victim, handoffPath);
+		const [onShutdown] = loadExtension({ [RESUME_HANDOFF_ENV]: handoffPath });
+		onShutdown({ reason: "quit" }, fakeContext(dir));
+		assert.equal(readFileSync(victim, "utf8"), "keep");
+	} finally {
+		resetResumeHintState();
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test("extension hands off the session file for a session from another project", () => {
+	const dir = handoffDir();
+	try {
+		const handoffPath = join(dir, "handoff.json");
+		const [onShutdown] = loadExtension({ [RESUME_HANDOFF_ENV]: handoffPath });
+		onShutdown({ reason: "quit" }, fakeContext(dir, "tui", resolve("/home/u/other-project")));
+		assert.deepEqual(parseResumeHandoff(readFileSync(handoffPath, "utf8")), { sessionId: ID, sessionFile: join(dir, "session.jsonl") });
+	} finally {
+		resetResumeHintState();
+		rmSync(dir, { recursive: true, force: true });
+	}
+});

package/tests/review-agent-end-preflight.test.ts

@@ -1,12 +1,12 @@
 import assert from "node:assert/strict";
 import childProcess from "node:child_process";
 import { syncBuiltinESMExports } from "node:module";
-import { realpathSync } from "node:fs";
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir, mkdtemp, rename, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import test from "node:test";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import test, { after, before } from "node:test";
+import type { ExtensionAPI, ExtensionContext, ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { NATIVE_REVIEW_ERROR_CODE, NativeReviewCliError, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import type { ReviewStatusV3 } from "../lib/review-integration-v2.ts";
@@ -29,8 +29,41 @@ type AnyHandler = (event: unknown, ctx: ExtensionContext) => unknown;
 type RegisteredTool = Parameters<ExtensionAPI["registerTool"]>[0];
 type SentMessage = { message: Record<string, unknown>; options: Record<string, unknown> };
 
+let fixtureCwd: string;
+let fixtureRoot: string | undefined;
+const fixtureEnvironment: NodeJS.ProcessEnv = {};
+const previousEnvironment = new Map<string, string | undefined>();
+before(async () => {
+	const root = await mkdtemp(join(tmpdir(), "gentle-pi-preflight-"));
+	fixtureRoot = root;
+	fixtureCwd = join(root, "project");
+	const home = join(root, "home");
+	for (const directory of [fixtureCwd, home, join(fixtureCwd, "src"), join(fixtureCwd, "tests")]) await mkdir(directory);
+	await writeFile(join(fixtureCwd, "src/example.ts"), "export const value = 1;");
+	childProcess.execFileSync("git", ["init", "--quiet", fixtureCwd]);
+	fixtureCwd = realpathSync(fixtureCwd);
+	Object.assign(fixtureEnvironment, {
+		HOME: home, USERPROFILE: home,
+		GENTLE_PI_CONFIG_HOME: join(home, "config"),
+		GENTLE_PI_AGENT_HOME: join(home, "agents"),
+		PI_CODING_AGENT_DIR: join(home, "pi"),
+		XDG_CONFIG_HOME: join(home, "xdg"),
+	});
+	for (const [key, value] of Object.entries(fixtureEnvironment)) {
+		previousEnvironment.set(key, process.env[key]);
+		process.env[key] = value;
+	}
+});
+after(async () => {
+	for (const [key, value] of previousEnvironment) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+	if (fixtureRoot !== undefined) await rm(fixtureRoot, { recursive: true, force: true });
+});
+
 type CustomEntry = { type: string; customType: string; data: unknown };
-function harness(nativeReviewCli: NativeReviewCli | null, entries: CustomEntry[] = []): {
+function harness(nativeReviewCli: NativeReviewCli | null, entries: CustomEntry[] = [], processEnv?: NodeJS.ProcessEnv): {
 	handlers: Map<string, AnyHandler>;
 	sent: SentMessage[];
 	tools: Map<string, RegisteredTool>;
@@ -53,11 +86,16 @@ function harness(nativeReviewCli: NativeReviewCli | null, entries: CustomEntry[]
 			sent.push({ message, options });
 		},
 	} as unknown as ExtensionAPI;
-	createGentleAiExtension({ nativeReviewCli })(pi);
+	createGentleAiExtension({
+		nativeReviewCli,
+		processEnv: { ...fixtureEnvironment, GENTLE_PI_AGENTS_CHILD: "0", ...processEnv, GENTLE_AI_TELEMETRY: "0" },
+		resolveTelemetryTriggerBinary: () => join(fixtureCwd, "never-executed"),
+		telemetryTriggerSpawn: () => assert.fail("Preflight fixtures must not spawn telemetry"),
+	})(pi);
 	return { handlers, sent, tools };
 }
 
-function ctx(sessionId: string, hasUI = true, cwd = process.cwd()): ExtensionContext {
+function ctx(sessionId: string, hasUI = true, cwd = fixtureCwd): ExtensionContext {
 	return {
 		cwd,
 		hasUI,
@@ -66,7 +104,17 @@ function ctx(sessionId: string, hasUI = true, cwd = process.cwd()): ExtensionCon
 	} as unknown as ExtensionContext;
 }
 
-async function withSessionStartEnv<T>(callback: (cwd: string) => Promise<T>): Promise<T> {
+function toolContext(context: ExtensionContext): ExtensionToolContext {
+	return {
+		...context,
+		tools: [],
+		async executeTool() {
+			assert.fail("Review preflight must not execute nested tools");
+		},
+	};
+}
+
+async function withSessionStartEnv<T>(callback: (cwd: string) => Promise<T>, initializeGit = true): Promise<T> {
 	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
 	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
 	process.env.GENTLE_PI_AGENT_HOME = await mkdtemp(join(tmpdir(), "gentle-pi-session-baseline-agent-home-"));
@@ -76,7 +124,7 @@ async function withSessionStartEnv<T>(callback: (cwd: string) => Promise<T>): Pr
 	process.env.GENTLE_PI_CONFIG_HOME = await mkdtemp(join(tmpdir(), "gentle-pi-session-baseline-config-home-"));
 	try {
 		const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-session-baseline-cwd-"));
-		childProcess.execFileSync("git", ["init", "--quiet", cwd]);
+		if (initializeGit) childProcess.execFileSync("git", ["init", "--quiet", cwd]);
 		await mkdir(join(cwd, "src"));
 		await writeFile(join(cwd, "src/example.ts"), "export const value = 1;");
 		return await callback(cwd);
@@ -127,7 +175,7 @@ const agentEndEvent = { type: "agent_end", messages: [] };
 let mutationCall = 0;
 async function directWrite(handlers: Map<string, AnyHandler>, session: ExtensionContext): Promise<void> {
 	await handlers.get("tool_result")!({ type: "tool_result", toolName: "write", toolCallId: `own-${++mutationCall}`,
-		input: { path: session.cwd === process.cwd() || session.cwd === realpathSync(process.cwd()) ? "tests/review-agent-end-preflight.test.ts" : "src/example.ts" },
+		input: { path: "src/example.ts" },
 		content: [], isError: false }, session);
 }
 
@@ -138,7 +186,7 @@ for (const scenario of ["same", "changed", "sibling-root", "nested-root", "faile
 	test(`agent_end after approved acknowledgement: ${scenario}`, async (t) => {
 		const changedTarget = scenario === "changed";
 		const unsuccessful = scenario === "failed" || scenario === "unknown";
-		const cwd = realpathSync(process.cwd());
+		const cwd = fixtureCwd;
 		const siblingRoot = realpathSync(tmpdir());
 		if (scenario === "sibling-root") {
 			// Model a sibling worktree sharing the real common directory without
@@ -210,7 +258,7 @@ for (const scenario of ["same", "changed", "sibling-root", "nested-root", "faile
 		const review = tools.get("gentle_review");
 		assert.ok(review);
 		await directWrite(handlers, session);
-		const result = await review.execute("post-ack", { operation: "acknowledge-approved", lineageId }, undefined, undefined, session);
+		const result = await review.execute("post-ack", { operation: "acknowledge-approved", lineageId }, undefined, undefined, toolContext(session));
 		if (unsuccessful) {
 			assert.equal(result.details.outcome, scenario === "failed" ? "native-operation-failed" : "native-mutation-status-reconciled");
 			assert.equal(result.details.mutation_outcome, scenario === "failed" ? "none" : "unknown");
@@ -242,6 +290,22 @@ for (const scenario of ["same", "changed", "sibling-root", "nested-root", "faile
 	});
 }
 
+test("passive session events outside Git with RDD off never invoke native STATUS or initialize Git", async () => {
+	await withSessionStartEnv(async (cwd) => {
+		const calls: string[] = [];
+		const native = {
+			reviewMode: async () => { calls.push("reviewMode"); return onMode("off")!({} as never); },
+			targetStatus: async () => { calls.push("targetStatus"); return executeStartStatus("outside-git"); },
+		} as unknown as NativeReviewCli;
+		const { handlers } = harness(native);
+		const session = ctx("outside-git", true, cwd);
+		await handlers.get("session_start")!({ type: "session_start" }, session);
+		await handlers.get("agent_end")!(agentEndEvent, session);
+		assert.deepEqual(calls, [], "passive non-Git events need no native entry");
+		assert.equal(existsSync(join(cwd, ".git")), false, "passive events must not initialize Git");
+	}, false);
+});
+
 test("agent_end performs no STATUS call and sends nothing when RDD is off", async () => {
 	const statusRequests: unknown[] = [];
 	const native = {
@@ -383,6 +447,25 @@ test("gentle-ai-worker agent_end never queries native review", async () => {
 	assert.deepEqual(sent, []);
 });
 
+test("agent_end sends nothing and performs no STATUS call when GENTLE_PI_AGENTS_CHILD is 1", async () => {
+	const statusRequests: unknown[] = [];
+	const native = {
+		reviewMode: onMode("on"),
+		targetStatus: async (request: unknown) => {
+			statusRequests.push(request);
+			throw new Error("targetStatus must not be called in a child session");
+		},
+	} as unknown as NativeReviewCli;
+	const { handlers, sent } = harness(native, [], { GENTLE_PI_AGENTS_CHILD: "1" });
+	const agentEnd = handlers.get("agent_end");
+	assert.equal(typeof agentEnd, "function");
+	const session = ctx("agent-end-child");
+	await directWrite(handlers, session);
+	await agentEnd!(agentEndEvent, session);
+	assert.deepEqual(statusRequests, []);
+	assert.deepEqual(sent, []);
+});
+
 test("agent_end resets the subagent depth when a fresh primary loop starts", async () => {
 	const targetIdentity = `sha256:${"1".repeat(64)}`;
 	const native = {
@@ -520,6 +603,87 @@ for (const toolName of ["read", "bash", "subagent_run", "edit", "write"]) {
 	});
 }
 
+for (const mode of ["on", "off", "unknown", "missing", "malformed", "incompatible", "throws"] as const) {
+	test(`non-Git successful source write, never startup, prepares only with validated RDD on: ${mode}`, async () => {
+		await withSessionStartEnv(async (cwd) => {
+			const requests: unknown[] = [];
+			const native = {
+				reviewMode: mode === "missing" ? undefined : async () => {
+					if (mode === "throws") throw new Error("unavailable");
+					if (mode === "incompatible") throw new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.VERSION_INCOMPATIBLE, "review/mode", false, false, "incompatible");
+					if (mode === "malformed") return { status: { effective: "on", source: "unrecognized" } };
+					return { operation: "status", scope: "clone", status: { global: "", cloneLocal: "", effective: mode, source: "global" } };
+				},
+				targetStatus: async (request: unknown) => {
+					requests.push(request);
+					// The fake native owns bootstrap, not the extension.
+					childProcess.execFileSync("git", ["init", "--quiet", cwd]);
+					return executeStartStatus(`sha256:${"8".repeat(64)}`);
+				},
+			} as unknown as NativeReviewCli;
+			const { handlers, sent } = harness(native);
+			const session = ctx(`non-git-${mode}`, true, cwd);
+			await handlers.get("session_start")!({}, session);
+			assert.equal(requests.length, 0, "passive startup cannot bootstrap");
+			assert.equal(existsSync(join(cwd, ".git")), false);
+			await handlers.get("agent_end")!(agentEndEvent, session);
+			assert.equal(requests.length, 0, "conversation cannot bootstrap");
+			await directWrite(handlers, session);
+			assert.equal(requests.length, mode === "on" ? 1 : 0);
+			assert.equal(existsSync(join(cwd, ".git")), mode === "on");
+			assert.deepEqual(sent, [], "preparation alone does not remind");
+		}, false);
+	});
+}
+
+for (const path of ["odd/tasks/feature.md", "README.md", ".pi/settings.json", "memory.md", "secrets/app.ts", "../foreign.ts"]) {
+	test(`bookkeeping or unsafe write cannot prepare: ${path}`, async () => {
+		await withSessionStartEnv(async (cwd) => {
+			let calls = 0;
+			const h = harness({ reviewMode: onMode("on"), targetStatus: async () => { calls++; return stopStatus("unused"); } } as unknown as NativeReviewCli);
+			const session = ctx("non-source", false, cwd);
+			await h.handlers.get("session_start")!({}, session);
+			await h.handlers.get("tool_result")!({ toolName: "write", toolCallId: "bookkeeping", input: { path }, isError: false }, session);
+			assert.equal(calls, 0);
+			assert.equal(existsSync(join(cwd, ".git")), false);
+		}, false);
+	});
+}
+
+for (const initiallyGit of [true, false]) {
+	test(`source preparation never reinitializes established metadata after loss: initially Git=${initiallyGit}`, async () => {
+		await withSessionStartEnv(async cwd => {
+			let calls = 0;
+			const h = harness({ reviewMode: onMode("on"), targetStatus: async () => {
+				calls++; childProcess.execFileSync("git", ["init", "--quiet", cwd]); return stopStatus("prepared");
+			} } as unknown as NativeReviewCli);
+			const session = ctx("established-source", false, cwd);
+			await h.handlers.get("session_start")!({}, session);
+			if (!initiallyGit) { await directWrite(h.handlers, session); assert.equal(calls, 1); }
+			await rename(join(cwd, ".git"), join(cwd, "saved-git"));
+			calls = 0;
+			await directWrite(h.handlers, session);
+			assert.equal(calls, 0, "no native bootstrap STATUS after previously established Git disappears");
+			assert.equal(existsSync(join(cwd, ".git")), false, "lost metadata remains lost, not reinitialized");
+		}, initiallyGit);
+	});
+}
+
+test("headless successful source write prepares after binding without a reminder", async () => {
+	await withSessionStartEnv(async cwd => {
+		let calls = 0;
+		const h = harness({ reviewMode: onMode("on"), targetStatus: async () => {
+			calls++; childProcess.execFileSync("git", ["init", "--quiet", cwd]); return stopStatus("prepared");
+		} } as unknown as NativeReviewCli);
+		const session = ctx("headless-source", false, cwd);
+		await h.handlers.get("session_start")!({}, session);
+		await directWrite(h.handlers, session);
+		assert.equal(calls, 1);
+		assert.equal(existsSync(join(cwd, ".git")), true);
+		assert.deepEqual(h.sent, []);
+	}, false);
+});
+
 test("session_start negotiates the current target identity when RDD is on", async () => {
 	const targetIdentity = `sha256:${"2".repeat(64)}`;
 	const statusRequests: Array<{ agent?: string }> = [];

package/tests/review-candidate-owner-retry.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { withWindowsSystemProbeRetry } from "../lib/review-candidate-view-owner.ts";
+import { resolveWindowsSystemProbeTimeoutMs, withWindowsSystemProbeRetry } from "../lib/review-candidate-view-owner.ts";
 
 function failingProbe(code: string, attempts: { count: number }): () => string {
 	return () => {
@@ -61,3 +61,24 @@ test("windows system probe does not retry when the first attempt succeeds", () =
 	assert.equal(value, "S-1-5-18");
 	assert.equal(attempts.count, 1);
 });
+
+test("windows system probes default to a cold-runner-safe bounded timeout", () => {
+	assert.equal(resolveWindowsSystemProbeTimeoutMs({}), 15_000);
+});
+
+test("windows system probe timeout honors a bounded environment override", () => {
+	const env = (value: string) => ({ GENTLE_PI_CANDIDATE_WINDOWS_PROBE_TIMEOUT_MS: value });
+	assert.equal(resolveWindowsSystemProbeTimeoutMs(env("30000")), 30_000);
+	assert.equal(resolveWindowsSystemProbeTimeoutMs(env("120000")), 120_000);
+	for (const invalid of ["0", "-1", "abc", "1.5", "120001", "", "015000"]) {
+		assert.equal(resolveWindowsSystemProbeTimeoutMs(env(invalid)), 15_000, invalid);
+	}
+});
+
+test("every windows system probe uses the configurable timeout", async () => {
+	const { readFileSync } = await import("node:fs");
+	const source = readFileSync(new URL("../lib/review-candidate-view-owner.ts", import.meta.url), "utf8");
+	const probes = source.match(/windowsSystemExecutable\([^)]*\), \[[^\]]*\], \{[^}]*\}/g) ?? [];
+	assert.equal(probes.length, 5);
+	for (const probe of probes) assert.match(probe, /timeout: resolveWindowsSystemProbeTimeoutMs\(\)/);
+});