gentle-pi 4.2.0 → 4.3.0

package/tests/review-controller-native-routing.test.ts

@@ -6,13 +6,24 @@ import fsp from "node:fs/promises";
 import os, { tmpdir } from "node:os";
 import { syncBuiltinESMExports } from "node:module";
 import { dirname, join, resolve, sep } from "node:path";
-import test from "node:test";
+import test, { after, before } from "node:test";
+import { setWindowsAclAuthorityForTesting } from "../lib/review-candidate-view-owner.ts";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { __testing, createGentleAiExtension, PendingReviewConsentRegistry } from "../extensions/gentle-ai.ts";
 import { CandidateViewError, CandidateViewRegistry } from "../lib/review-candidate-view.ts";
 import { NATIVE_REVIEW_ERROR_CODE, NativeReviewCliError, NativeReviewConsentRequiredError, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import { decodeReviewLastEventClosureV1, decodeReviewConsentV3, decodeReviewStatusV3, type ReviewCollectInputV3, type ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 
+// Coordination tests use fixture authority; real Windows ACL coverage lives
+// in review-candidate-view.test.ts, in a separate test process.
+let fixtureAclChecks = 0;
+before(() => {
+	if (process.platform === "win32") {
+		setWindowsAclAuthorityForTesting(() => { fixtureAclChecks++; });
+	}
+});
+after(() => setWindowsAclAuthorityForTesting());
+
 const SHA = `sha256:${"a".repeat(64)}`;
 const TREE = "b".repeat(40);
 
@@ -1076,7 +1087,9 @@ function reviewContext(cwd: string): ExtensionContext {
 
 function startStatus(cwd: string, baseRef?: string, intendedUntracked: readonly string[] = []): ReviewStatusV3 {
 	const candidateViews = new CandidateViewRegistry();
+	const checksBefore = fixtureAclChecks;
 	const view = candidateViews.create({ contributorRoot: cwd, intendedUntracked, ...(baseRef === undefined ? {} : { baseRef, committedOnly: true }) });
+	if (process.platform === "win32") assert.ok(fixtureAclChecks > checksBefore, "coordination candidates must use the fixture ACL authority");
 	try {
 		return {
 			contract: "gentle-ai.review-integration/v2",

package/tests/review-controller.test.ts

@@ -406,7 +406,7 @@ test("shipped controller fails closed while static prompts defer RDD lifecycle o
 	const core = readFileSync("assets/orchestrator.md", "utf8");
 	assert.match(core, new RegExp(boundary.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
 
-	for (const path of ["assets/orchestrator-delegation.md", "skills/gentle-ai/SKILL.md"]) {
+	for (const path of ["assets/orchestrator-delegation.md", "assets/orchestrator-delegation-reference.md", "skills/gentle-ai/SKILL.md"]) {
 		const contract = readFileSync(path, "utf8");
 		assert.doesNotMatch(contract, /INSPECT before START|start -> finalize -> validate|next_transition|review\.capture-result/is, path);
 	}

package/tests/review-host-relay-routing.test.ts

@@ -10,9 +10,9 @@ import { localProfilePinPath, repoProfileDeclarationPath, writeProfilePinSync }
 import { createProfile, emptyProfilesFile, profilesFilePath, writeProfilesFileSync } from "../lib/agent-profiles.ts";
 import type { AgentModelConfig } from "../lib/model-routing-authority.ts";
 import { GENTLE_AI_DEV_BINARY_ENV, resolveGentleAiDevBinaryOverride } from "../lib/gentle-ai-binary.ts";
-import type { NativeReviewCli, NativeReviewUnachievableLensCaptureArtifact, NativeReviewUnachievableLensCaptureRequest } from "../lib/native-review-cli.ts";
+import { NativeReviewIntegrationError, type NativeReviewCli, type NativeReviewUnachievableLensCaptureArtifact, type NativeReviewUnachievableLensCaptureRequest } from "../lib/native-review-cli.ts";
 import { REVIEW_HOST_RELAY_FAILURE, REVIEW_HOST_RELAY_PI_TIMEOUT_ENV, REVIEW_HOST_RELAY_PI_TIMEOUT_MAX_MS, REVIEW_HOST_RELAY_SUBMISSION_MISSING_MESSAGE, REVIEW_HOST_RELAY_UNAVAILABLE_MESSAGE, ReviewHostRelayError, type ReviewHostRelayRequest } from "../lib/review-host-relay.ts";
-import { decodeReviewNextTransitionV3, decodeReviewStatusV3, type ReviewArtifactSubjectV2, type ReviewCaptureSubmissionV1, type ReviewCollectInputV3, type ReviewStatusV3 } from "../lib/review-integration-v2.ts";
+import { decodeReviewFailureV2, decodeReviewNextTransitionV3, decodeReviewStatusV3, type ReviewArtifactSubjectV2, type ReviewCaptureSubmissionV1, type ReviewCollectInputV3, type ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 import type { InProcessReviewerRegistry } from "../lib/inprocess-reviewer.ts";
 
 // One-slot capture routing: the host relay runs only when the selected
@@ -444,6 +444,63 @@ async function runCaptureGroup(cwd: string, harness: RoutingHarness, lineageId:
 
 function prepared(request: ReviewHostRelayRequest) { return { request, promptByteLength: 64, resultByteLength: 32 }; }
 
+for (const failAt of [0, 1, 2]) {
+	for (const typed of [true, false]) {
+		test(`grouped STATUS failure preserves ${typed ? "decoded diagnostics" : "untyped behavior"} at call ${failAt + 1}`, async (t) => {
+			t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
+			const cwd = repository(t), lineageId = "relay-group-status-failure", inputs = groupInputs(lineageId);
+			const failure = decodeReviewFailureV2({
+				schema: "gentle-ai.review-integration.failure/v2", contract: "gentle-ai.review-integration/v2",
+				operation: "review.status", phase: "native_running", code: "native_operation_timeout",
+				message: "The negotiated review operation exceeded its aggregate time budget.",
+				mutation_outcome: "not_started", authority_applicability: "current_target", retry_safe: false,
+				replayability: "manual_action_required", required_inputs: [], next_action: "explicit-maintainer-action",
+				cause: "STATUS budget exhausted", context: { binding_revision: { expected: SHA, current: PHASE_REVISION } },
+			});
+			const error = typed ? new NativeReviewIntegrationError(failure) : Object.assign(new Error(failure.message), {
+				failureEnvelope: { raw: { secret: "must not be projected" } }, stdout: "private stdout", stderr: "private stderr",
+			});
+			const harness = nativeHarness([]);
+			let calls = 0, preparations = 0, submissions = 0;
+			harness.native.targetStatus = async () => {
+				const index = calls++;
+				if (index === failAt) throw error;
+				return finalizeStatus(lineageId, index === 0 ? inputs : inputs.slice(index - 1));
+			};
+			__testing.setReviewHostRelayGroupRunnersForTesting(async (requests) => {
+				preparations += 1;
+				return requests.map(prepared);
+			}, async (result) => {
+				submissions += 1;
+				return { promptByteLength: result.promptByteLength, resultByteLength: result.resultByteLength, submission: "{}" };
+			});
+			const result = await runCaptureGroup(cwd, harness, lineageId, inputs);
+			assert.equal(result.outcome, "native-status-failed");
+			assert.equal(result.status, "blocked");
+			assert.equal(result.reason, failure.message);
+			assert.equal(calls, failAt + 1, "no STATUS retry");
+			assert.equal(preparations, failAt === 0 ? 0 : 1);
+			assert.equal(submissions, Math.max(0, failAt - 1), "no submission after STATUS failure");
+			assert.equal(result.mutation_performed, submissions > 0);
+			assert.equal(result.mutation_outcome, submissions > 0 ? "partial" : "none");
+			if (failAt > 0) {
+				const progress = result.host_relay as { reviewers: unknown[] };
+				assert.equal(progress.reviewers.length, submissions);
+			}
+			if (typed) {
+				assert.deepEqual(result.native_failure, failure.raw);
+				assert.equal(result.replayability, failure.replayability);
+				assert.equal(result.next_action, failure.nextAction);
+			} else {
+				assert.equal(result.native_failure, undefined);
+				assert.equal(result.replayability, undefined);
+				assert.equal(result.next_action, undefined);
+				assert.doesNotMatch(JSON.stringify(result), /must not be projected|private stdout|private stderr/);
+			}
+		});
+	}
+}
+
 test("grouped capture forecasts once, reaches a four-reviewer barrier, and reconciles unclosed submissions", async (t) => {
 	t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
 	const cwd = repository(t), lineageId = "relay-group", inputs = groupInputs(lineageId), lenses = inputs.map((input) => input.arguments.find((argument) => argument.name === "lens")!.value);

package/tests/review-loadout-rdd-off-sdk.test.ts

@@ -0,0 +1,237 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import type { AssistantMessage, JsonObject, Tool, ToolCall } from "@earendil-works/pi-ai";
+import type { NativeReviewCli } from "../lib/native-review-cli.ts";
+
+// gentle-pi S11 T1: with receipt-driven development off, the orchestrator only
+// ever calls gentle_review ASSESS, so the parent request carries a short ASSESS
+// guideline and leaves the capture, capture-group, and scope declarations out.
+// With RDD on, the request is exactly what the registered tools declare. Both
+// paths run through a real Pi SDK session and inspect the provider request.
+
+const HIDDEN_WHEN_OFF = ["gentle_review_capture", "gentle_review_capture_group", "gentle_review_scope"] as const;
+
+interface RecordedRequest { systemPrompt: string; tools: Tool[] }
+interface SessionRun {
+	requests: RecordedRequest[];
+	registered: Map<string, { description: string; promptGuidelines?: readonly string[] }>;
+	assessResults: Array<{ isError: boolean; details: unknown }>;
+	errors: string[];
+}
+
+type RddMode = "on" | "off" | "throws";
+
+function nativeCli(mode: () => RddMode): NativeReviewCli {
+	return {
+		reviewMode: async () => {
+			const effective = mode();
+			if (effective === "throws") throw new Error("native review mode is unavailable");
+			return { operation: "status", scope: "clone", status: { global: effective, cloneLocal: "", effective, source: "global" } };
+		},
+		assess: async () => ({
+			schema: "gentle-ai.review-assessment/v1",
+			risk: "medium",
+			reasons: [],
+			changedPaths: 1,
+			changedLines: 3,
+			candidate: { kind: "current-changes", baseRef: undefined },
+		}),
+	} as unknown as NativeReviewCli;
+}
+
+async function runSession(
+	root: string,
+	label: string,
+	bindings: Record<string, string>,
+	mode: () => RddMode,
+	beforeSecondPrompt: () => void = () => {},
+): Promise<SessionRun> {
+	const sdk = await import("@earendil-works/pi-coding-agent");
+	const ai = await import("@earendil-works/pi-ai");
+	const { createGentleAiExtension } = await import("../extensions/gentle-ai.ts");
+	const cwd = join(root, `repo-${label}`);
+	mkdirSync(cwd);
+	const gitEnv = { PATH: process.env.PATH, HOME: root, GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: join(root, "gitconfig") };
+	writeFileSync(gitEnv.GIT_CONFIG_GLOBAL, "");
+	execFileSync("git", ["init", "--initial-branch=fixture"], { cwd, env: gitEnv, stdio: "ignore" });
+	execFileSync("git", ["-c", "user.name=SDK Fixture", "-c", "user.email=fixture@example.invalid", "commit", "--allow-empty", "-m", "fixture"], { cwd, env: gitEnv, stdio: "ignore" });
+	const run: SessionRun = { requests: [], registered: new Map(), assessResults: [], errors: [] };
+	let next: { name: string; arguments: JsonObject } | undefined;
+	let calls = 0;
+	const model = { id: "driver", name: "Local driver", provider: "loadout-fixture", api: "loadout-fixture", baseUrl: "http://invalid.local", reasoning: false, input: ["text"], contextWindow: 1_000_000, maxTokens: 1024, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } } as const;
+	const manager = sdk.SessionManager.inMemory(cwd);
+	const settings = sdk.SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false }, cacheWarming: "off", packages: [] });
+	const runtime = await sdk.ModelRuntime.create({ credentials: new ai.InMemoryCredentialStore(), modelsPath: null, modelsStorePath: join(root, `models-${label}.json`), refreshOnCreate: false, allowModelNetwork: false });
+	const loader = new sdk.DefaultResourceLoader({
+		cwd, agentDir: bindings.PI_CODING_AGENT_DIR, settingsManager: settings,
+		noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+		extensionFactories: [(pi) => {
+			const registerTool = pi.registerTool.bind(pi);
+			pi.registerTool = ((definition: { name: string; description: string; promptGuidelines?: readonly string[] }) => {
+				run.registered.set(definition.name, definition);
+				return registerTool(definition as never);
+			}) as typeof pi.registerTool;
+			createGentleAiExtension({
+				nativeReviewCli: nativeCli(mode),
+				candidateViews: null,
+				processEnv: { ...bindings, GENTLE_AI_TELEMETRY: "0" },
+				resolveTelemetryTriggerBinary: () => { throw new Error("fixture"); },
+			})(pi);
+			pi.on("tool_result", (event) => {
+				if (event.toolName === "gentle_review") run.assessResults.push({ isError: event.isError, details: event.details });
+			});
+			pi.registerProvider("loadout-fixture", {
+				api: "loadout-fixture", apiKey: "fixture-only", baseUrl: "http://invalid.local",
+				models: [{ id: model.id, name: model.name, reasoning: false, input: ["text"], cost: model.cost, contextWindow: model.contextWindow, maxTokens: model.maxTokens }],
+				streamSimple(_model, context) {
+					run.requests.push({ systemPrompt: ai.getCurrentSystemPrompt(context.messages), tools: ai.getCurrentTools(context.messages) });
+					const stream = ai.createAssistantMessageEventStream();
+					const request = next;
+					next = undefined;
+					calls += 1;
+					const message: AssistantMessage = { role: "assistant", api: model.api, provider: model.provider, model: model.id, content: [], stopReason: "pending" as never, timestamp: Date.now(), usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } };
+					queueMicrotask(() => {
+						stream.push({ type: "start", partial: message });
+						if (request) {
+							const toolCall: ToolCall = { type: "toolCall", id: `call-${calls}`, ...request };
+							message.content.push(toolCall);
+							stream.push({ type: "toolcall_start", contentIndex: 0, partial: message });
+							stream.push({ type: "toolcall_delta", contentIndex: 0, delta: JSON.stringify(request.arguments), partial: message });
+							stream.push({ type: "toolcall_end", contentIndex: 0, toolCall, partial: message });
+						}
+						message.stopReason = request ? "toolUse" : "stop";
+						stream.push({ type: "done", reason: message.stopReason, message });
+						stream.end();
+					});
+					return stream;
+				},
+			});
+		}],
+	});
+	await loader.reload();
+	assert.deepEqual(loader.getExtensions().errors, []);
+	const { session } = await sdk.createAgentSession({
+		cwd, agentDir: bindings.PI_CODING_AGENT_DIR, modelRuntime: runtime, model: model as never, thinkingLevel: "off", resourceLoader: loader,
+		tools: ["read", "gentle_review", ...HIDDEN_WHEN_OFF], sessionManager: manager, settingsManager: settings,
+	});
+	try {
+		await session.bindExtensions({ mode: "json", onError: (error) => run.errors.push(error.error) });
+		next = { name: "gentle_review", arguments: { operation: "assess" } };
+		await session.prompt("Assess the current change.", { source: "interactive" });
+		beforeSecondPrompt();
+		await session.prompt("Report the plan.", { source: "interactive" });
+	} finally {
+		await session.abort();
+		session.dispose();
+	}
+	return run;
+}
+
+const LEAN_GUIDELINE = /gentle_review only for \{"operation":"assess"\}/;
+
+function fixture(t: { after: (fn: () => void) => void }): { root: string; bindings: Record<string, string> } {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), "gentle-review-loadout-")));
+	const profile = join(root, "profile");
+	mkdirSync(profile);
+	const bindings = {
+		PI_CODING_AGENT_DIR: profile, PI_CODING_AGENT_SESSION_DIR: join(root, "sessions"),
+		GENTLE_PI_AGENT_HOME: profile, GENTLE_PI_CONFIG_HOME: join(root, "config"),
+	};
+	const previous = Object.fromEntries(Object.keys(bindings).map((key) => [key, process.env[key]]));
+	Object.assign(process.env, bindings);
+	t.after(() => {
+		for (const [key, value] of Object.entries(previous)) {
+			if (value === undefined) delete process.env[key];
+			else process.env[key] = value;
+		}
+		rmSync(root, { recursive: true, force: true });
+	});
+	return { root, bindings };
+}
+
+function registeredGuidelines(run: SessionRun): string[] {
+	const guidelines = ["gentle_review", ...HIDDEN_WHEN_OFF].flatMap((name) => run.registered.get(name)?.promptGuidelines ?? []);
+	assert.ok(guidelines.length > 0);
+	return guidelines;
+}
+
+function assertLeanRequest(request: RecordedRequest, run: SessionRun): void {
+	assert.match(request.systemPrompt, /Receipt-driven development: off /);
+	assert.match(request.systemPrompt, LEAN_GUIDELINE);
+	for (const guideline of registeredGuidelines(run)) assert.equal(request.systemPrompt.includes(guideline), false, `RDD off must leave out: ${guideline.slice(0, 80)}`);
+	const names = request.tools.map((tool) => tool.name);
+	assert.ok(names.includes("gentle_review"));
+	for (const hidden of HIDDEN_WHEN_OFF) assert.equal(names.includes(hidden), false, `${hidden} is not declared while RDD is off`);
+	assert.doesNotMatch(request.tools.find((tool) => tool.name === "gentle_review")!.description, /gentle_review_capture/);
+}
+
+function assertRegisteredRequest(request: RecordedRequest, run: SessionRun): void {
+	for (const guideline of registeredGuidelines(run)) assert.ok(request.systemPrompt.includes(guideline), `the registered loadout keeps: ${guideline.slice(0, 80)}`);
+	assert.doesNotMatch(request.systemPrompt, LEAN_GUIDELINE);
+	for (const name of ["gentle_review", ...HIDDEN_WHEN_OFF]) {
+		const declared = request.tools.find((tool) => tool.name === name);
+		assert.ok(declared, `${name} is declared`);
+		assert.equal(declared.description, run.registered.get(name)?.description);
+	}
+}
+
+test("RDD off: the parent request carries only the lean ASSESS loadout; RDD on: the registered review loadout", { timeout: 30_000 }, async (t) => {
+	const { root, bindings } = fixture(t);
+	const off = await runSession(root, "off", bindings, () => "off");
+	const on = await runSession(root, "on", bindings, () => "on");
+	assert.deepEqual(off.errors, []);
+	assert.deepEqual(on.errors, []);
+	assert.equal(off.requests.length >= 3, true, "assess turn, tool result turn, follow-up turn");
+
+	for (const request of off.requests) assertLeanRequest(request, off);
+	// The prefix is stable across turns of the same session.
+	assert.equal(new Set(off.requests.map((request) => request.systemPrompt)).size, 1);
+	assert.equal(new Set(off.requests.map((request) => JSON.stringify(request.tools))).size, 1);
+	// ASSESS stays callable and returns its plan.
+	assert.equal(off.assessResults.length, 1);
+	assert.equal(off.assessResults[0].isError, false);
+	assert.equal((off.assessResults[0].details as { schema?: string }).schema, "gentle-pi.review-assessment-plan/v1");
+
+	for (const request of on.requests) {
+		assert.match(request.systemPrompt, /Receipt-driven development: on /);
+		assertRegisteredRequest(request, on);
+	}
+	assert.equal(on.assessResults.length, 1);
+	assert.equal(on.assessResults[0].isError, false);
+
+	const bytes = (request: RecordedRequest) => ({
+		systemPrompt: Buffer.byteLength(request.systemPrompt),
+		tools: Buffer.byteLength(JSON.stringify(request.tools)),
+	});
+	t.diagnostic(`RDD off request bytes: ${JSON.stringify(bytes(off.requests[0]))}`);
+	t.diagnostic(`RDD on request bytes: ${JSON.stringify(bytes(on.requests[0]))}`);
+});
+
+test("an unknown RDD line keeps the registered loadout; turning RDD on mid-session restores it at the next run", { timeout: 30_000 }, async (t) => {
+	const { root, bindings } = fixture(t);
+	const { __testing } = await import("../extensions/gentle-ai.ts");
+	__testing.clearRddStatusMemoForTesting();
+	t.after(() => __testing.clearRddStatusMemoForTesting());
+
+	const unknown = await runSession(root, "unknown", bindings, () => "throws");
+	assert.deepEqual(unknown.errors, []);
+	for (const request of unknown.requests) {
+		assert.match(request.systemPrompt, /Receipt-driven development: unknown/);
+		assertRegisteredRequest(request, unknown);
+	}
+
+	let mode: RddMode = "off";
+	const flipped = await runSession(root, "flip", bindings, () => mode, () => {
+		mode = "on";
+		__testing.clearRddStatusMemoForTesting();
+	});
+	assert.deepEqual(flipped.errors, []);
+	const last = flipped.requests.at(-1)!;
+	for (const request of flipped.requests.slice(0, -1)) assertLeanRequest(request, flipped);
+	assert.match(last.systemPrompt, /Receipt-driven development: on /);
+	assertRegisteredRequest(last, flipped);
+});

package/tests/review-owner-identity.test.ts

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import test from "node:test";
+import { createCandidateOwner, prepareCandidateOwnerParent } from "../lib/review-candidate-view-owner.ts";
+
+function fixture(t: test.TestContext) {
+	fs.mkdirSync(resolve("tmp"), { recursive: true });
+	const base = fs.realpathSync(fs.mkdtempSync(join(resolve("tmp"), "owner-identity-")));
+	const commonDir = join(base, "common");
+	const parent = join(commonDir, "gentle-ai", "candidate-views");
+	fs.mkdirSync(parent, { recursive: true });
+	const boundary = [commonDir, dirname(parent), parent];
+	let user = "S-1-5-21-1-2-3-1001";
+	let identityFailure = "";
+	let replacedMarker = false;
+	const probes = { user: 0, administrator: 0, owner: [] as string[], dacl: [] as string[], enforce: [] as string[] };
+	const native = fs.realpathSync.native;
+	t.mock.method(fs.realpathSync, "native", (path: string) =>
+		path.startsWith("\\\\?\\GLOBALROOT\\SystemRoot\\System32") ? path : native(path));
+	t.mock.method(childProcess, "execFileSync", (command: string, args: string[], options: any) => {
+		const name = command.split(/[\\/]/).at(-1);
+		if (name === "whoami.exe") {
+			probes.user++;
+			return identityFailure === "user" ? "unavailable" : user;
+		}
+		if (name === "icacls.exe") {
+			probes.dacl.push(args[0]);
+			const directory = fs.lstatSync(args[0]).isDirectory();
+			const flags = directory ? "OICI" : "ID";
+			const dacl = `D:${directory ? "P" : ""}(A;${flags};FA;;;${user})(A;${flags};FA;;;SY)(A;${flags};FA;;;BA)`;
+			fs.writeFileSync(join(options.cwd, args[2]), dacl, "utf16le");
+			return "";
+		}
+		if (name === "powershell.exe") {
+			const script = Buffer.from(args.at(-1)!, "base64").toString("utf16le");
+			if (script.includes("RawSecurityDescriptor")) {
+				probes.administrator++;
+				return identityFailure === "administrator" ? "unavailable" : "S-1-5-21-1-2-3-500";
+			}
+			if (script.includes("SetAccessControl")) {
+				probes.enforce.push(options.env.GENTLE_PI_CANDIDATE_ACL_PATH);
+				return "";
+			}
+			const path = options.env.GENTLE_PI_CANDIDATE_OWNER_PATH;
+			probes.owner.push(path);
+			return replacedMarker && path.endsWith(".owner.json") ? "S-1-5-21-9-8-7-1002" : user;
+		}
+		throw new Error(`Unexpected subprocess: ${name}`);
+	});
+	syncBuiltinESMExports();
+	t.after(() => {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		fs.rmSync(base, { recursive: true, force: true });
+	});
+	return { commonDir, parent, boundary, probes,
+		changeUser: () => { user = "S-1-5-21-4-5-6-1002"; },
+		failIdentity: (kind: string) => { identityFailure = kind; },
+		replaceMarker: () => { replacedMarker = true; } };
+}
+
+test("Windows creation reuses identity only within one operation and preserves every filesystem probe", (t) => {
+	const f = fixture(t);
+	for (let operation = 1; operation <= 2; operation++) {
+		if (operation === 2) f.changeUser();
+		const root = join(f.parent, randomUUID());
+		const owner = createCandidateOwner(f.commonDir, root, "win32");
+		const marker = `${root}.owner.json`;
+		assert.equal(owner.root, root);
+		assert.deepEqual(JSON.parse(fs.readFileSync(marker, "utf8")), owner);
+		assert.equal(fs.existsSync(root), false);
+		assert.equal(f.probes.user, operation, "one fresh user SID per creation");
+		assert.equal(f.probes.administrator, operation, "one fresh administrator SID per creation");
+		assert.deepEqual(f.probes.owner.slice((operation - 1) * 4), [...f.boundary, marker]);
+		assert.deepEqual(f.probes.dacl.slice((operation - 1) * 4), [...f.boundary, marker]);
+		assert.deepEqual(f.probes.enforce, []);
+	}
+});
+
+test("Windows preparation retains fresh pre-write and post-write owner/DACL checks", (t) => {
+	const f = fixture(t);
+	assert.equal(prepareCandidateOwnerParent(f.commonDir, "win32"), f.parent);
+	assert.equal(f.probes.user, 1);
+	assert.equal(f.probes.administrator, 1);
+	assert.deepEqual(f.probes.owner, [...f.boundary, ...f.boundary.flatMap(path => [path, path])]);
+	assert.deepEqual(f.probes.dacl, f.boundary);
+	assert.deepEqual(f.probes.enforce, f.boundary);
+});
+
+for (const kind of ["user", "administrator"]) test(`Windows creation fails closed on fresh ${kind} identity failure`, (t) => {
+	const f = fixture(t);
+	const first = createCandidateOwner(f.commonDir, join(f.parent, randomUUID()), "win32");
+	const marker = `${first.root}.owner.json`;
+	const before = fs.readFileSync(marker, "utf8");
+	const stored = fs.readdirSync(f.parent);
+	f.failIdentity(kind);
+	const root = join(f.parent, randomUUID());
+	assert.throws(() => createCandidateOwner(f.commonDir, root, "win32"), /SID is unavailable/);
+	assert.equal(fs.existsSync(root), false);
+	assert.equal(fs.existsSync(`${root}.owner.json`), false);
+	assert.equal(fs.readFileSync(marker, "utf8"), before);
+	assert.deepEqual(fs.readdirSync(f.parent), stored);
+	assert.equal(f.probes.owner.length, 4);
+	assert.equal(f.probes.dacl.length, 4);
+});
+
+test("Windows creation rollback rechecks a replaced marker owner before removal", (t) => {
+	const f = fixture(t);
+	const write = fs.writeFileSync;
+	const root = join(f.parent, randomUUID());
+	const marker = `${root}.owner.json`;
+	t.mock.method(fs, "writeFileSync", (...args: any[]) => {
+		if (typeof args[0] === "number") {
+			f.replaceMarker();
+			throw new Error("fixture write failure");
+		}
+		return (write as any)(...args);
+	});
+	syncBuiltinESMExports();
+	assert.throws(() => createCandidateOwner(f.commonDir, root, "win32"), /fixture write failure/);
+	assert.equal(f.probes.user, 1);
+	assert.equal(f.probes.administrator, 1);
+	assert.deepEqual(f.probes.owner, [...f.boundary, marker, marker]);
+	assert.deepEqual(f.probes.dacl, [...f.boundary, marker]);
+	assert.equal(fs.existsSync(marker), true, "unproven marker survives rollback");
+	assert.equal(fs.readFileSync(marker, "utf8"), "");
+	assert.equal(fs.existsSync(root), false);
+});