gentle-pi 4.0.0 → 4.2.0

package/tests/review-risk-assessment.test.ts

@@ -29,6 +29,7 @@ import {
 	type NativeReviewOutcome,
 } from "../lib/review-risk-assessment.ts";
 import { consumeReviewMutation, pendingReviewMutation, recordReviewMutation } from "../lib/review-reminder-receipt.ts";
+import type { ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 
 // ---------------------------------------------------------------------------
 // gentle-pi#662: decoder for the native `gentle-ai review assess` envelope
@@ -188,9 +189,9 @@ test("decodeReviewAssessmentV1 rejects malformed consumed, review_due, and revie
 
 // gentle-pi#1175 (T2): the native schema fixes review_due by reason
 // (true for high_risk and slice_budget_reached, false for passive,
-// under_budget, and already_reviewed), and already_reviewed is reported
-// exactly when the candidate is consumed. A contradictory envelope can never
-// be trusted as closure evidence, so it fails decoding.
+// under_budget, and already_reviewed). Consumed candidates must report
+// already_reviewed, but an acknowledged predecessor plus a passive delta can
+// also produce that reason without consuming this exact candidate (#1954).
 interface ReviewDuePair {
 	reason: string;
 	due: boolean;
@@ -203,6 +204,7 @@ const CONSISTENT_REVIEW_DUE_PAIRS: readonly ReviewDuePair[] = [
 	{ reason: "passive", due: false, consumed: false },
 	{ reason: "under_budget", due: false, consumed: false },
 	{ reason: "already_reviewed", due: false, consumed: true },
+	{ reason: "already_reviewed", due: false, consumed: false },
 ];
 
 function consistentEnvelope(pair: ReviewDuePair): Record<string, unknown> {
@@ -237,14 +239,38 @@ test("decodeReviewAssessmentV1 rejects a review_due boolean that contradicts rev
 	}
 });
 
-test("decodeReviewAssessmentV1 rejects already_reviewed unless the candidate is consumed", () => {
-	for (const candidate of [{ kind: "current-changes", consumed: false }, { kind: "current-changes" }]) {
-		assert.throws(
-			() => decodeReviewAssessmentV1(newEnvelope({ candidate, review_due: false, review_due_reason: "already_reviewed", next_transition: undefined })),
-			TypeError,
-			`already_reviewed with ${JSON.stringify(candidate)} must be rejected`,
-		);
-	}
+function reviewedPredecessorEnvelope(): Record<string, unknown> {
+	// The executable range still has medium risk; only the delta after the
+	// acknowledged committed predecessor is a passive ODD note.
+	return validEnvelope({
+		risk: "medium",
+		reasons: [{ code: "executable_changes" }],
+		changed_paths: 3,
+		changed_lines: 24,
+		candidate: { kind: "current-changes", consumed: false },
+		review_due: false,
+		review_due_reason: "already_reviewed",
+	});
+}
+
+test("decodeReviewAssessmentV1 accepts an already-reviewed predecessor without consuming the medium-risk candidate (#1954)", () => {
+	const decoded = decodeReviewAssessmentV1(reviewedPredecessorEnvelope());
+	assert.equal(decoded.risk, "medium");
+	assert.deepEqual(decoded.reasons, [{ code: "executable_changes" }]);
+	assert.equal(decoded.changedPaths, 3);
+	assert.equal(decoded.changedLines, 24);
+	assert.equal(decoded.reviewDue, false);
+	assert.equal(decoded.reviewDueReason, "already_reviewed");
+	assert.equal(decoded.candidate.consumed, false);
+	assert.equal(Object.hasOwn(decoded, "nextTransition"), false);
+});
+
+test("decodeReviewAssessmentV1 rejects already_reviewed with missing consumed evidence", () => {
+	// Native v2 requires consumed; older envelopes omit the entire due pair.
+	assert.throws(
+		() => decodeReviewAssessmentV1(newEnvelope({ candidate: { kind: "current-changes" }, review_due: false, review_due_reason: "already_reviewed", next_transition: undefined })),
+		TypeError,
+	);
 });
 
 test("decodeReviewAssessmentV1 rejects a consumed candidate reported with any reason other than already_reviewed", () => {
@@ -311,24 +337,22 @@ const RDD_LINES: readonly RddLine[] = [RDD_LINE.ON, RDD_LINE.OFF, RDD_LINE.UNKNO
 const PROFILES: readonly WriterProfile[] = [WRITER_PROFILE.SMALL, WRITER_PROFILE.LARGE];
 const NON_CLOSED_OUTCOMES: readonly NativeReviewOutcome[] = [NATIVE_REVIEW_OUTCOME.DECLINED, NATIVE_REVIEW_OUTCOME.UNAVAILABLE, NATIVE_REVIEW_OUTCOME.UNKNOWN];
 
-test("verificationPlan: rdd on + closed, passive risk -> structural readback only regardless of writer profile", () => {
-	for (const writerProfile of PROFILES) {
-		const plan = verificationPlan({ rddLine: RDD_LINE.ON, risk: VERIFICATION_TIER.PASSIVE, writerProfile, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
-		assert.equal(plan.structuralReadbackOnly, true);
-		assert.equal(plan.writerSelfVerification, false);
-		assert.equal(plan.independentVerifier, false);
-	}
-});
-
-test("verificationPlan: rdd on + closed, medium/high/unassessable risk -> writer self-verification, no independent verifier", () => {
-	for (const risk of [VERIFICATION_TIER.MEDIUM, VERIFICATION_TIER.HIGH, VERIFICATION_TIER.UNASSESSABLE]) {
+// verify-always-rdd-high S1: the native review is an additional outside view
+// and never replaces verification, so a closed review under rdd on yields the
+// exact risk-gated plan rdd off yields, for every risk and writer profile.
+test("verificationPlan: rdd on + closed behaves exactly like rdd off for every risk/profile combination", () => {
+	for (const risk of RISKS) {
 		for (const writerProfile of PROFILES) {
-			const plan = verificationPlan({ rddLine: RDD_LINE.ON, risk, writerProfile, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
-			assert.equal(plan.writerSelfVerification, true, `rdd on+closed, risk ${risk}, profile ${writerProfile}`);
-			assert.equal(plan.structuralReadbackOnly, false);
-			assert.equal(plan.independentVerifier, false, `the closed native review is the independent check under rdd on for risk ${risk}`);
+			const off = verificationPlan({ rddLine: RDD_LINE.OFF, risk, writerProfile });
+			const closed = verificationPlan({ rddLine: RDD_LINE.ON, risk, writerProfile, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
+			assert.equal(closed.writerSelfVerification, off.writerSelfVerification, `closed, risk ${risk}, profile ${writerProfile}`);
+			assert.equal(closed.structuralReadbackOnly, off.structuralReadbackOnly, `closed, risk ${risk}, profile ${writerProfile}`);
+			assert.equal(closed.independentVerifier, off.independentVerifier, `closed, risk ${risk}, profile ${writerProfile}`);
 		}
 	}
+	const high = verificationPlan({ rddLine: RDD_LINE.ON, risk: VERIFICATION_TIER.HIGH, writerProfile: WRITER_PROFILE.LARGE, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
+	assert.equal(high.independentVerifier, true, "a closed review never removes the high-risk independent verifier");
+	assert.match(high.reason, /never replaces verification/);
 });
 
 // ---------------------------------------------------------------------------
@@ -365,9 +389,9 @@ test("verificationPlan: an omitted nativeReviewOutcome under rdd on defaults to
 	}
 });
 
-test("verificationPlan: on+closed+medium+large -> no verifier", () => {
-	const plan = verificationPlan({ rddLine: RDD_LINE.ON, risk: VERIFICATION_TIER.MEDIUM, writerProfile: WRITER_PROFILE.LARGE, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
-	assert.equal(plan.independentVerifier, false);
+test("verificationPlan: on+closed+medium+small -> verifier (the small-model bias still applies)", () => {
+	const plan = verificationPlan({ rddLine: RDD_LINE.ON, risk: VERIFICATION_TIER.MEDIUM, writerProfile: WRITER_PROFILE.SMALL, nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.CLOSED });
+	assert.equal(plan.independentVerifier, true);
 	assert.equal(plan.writerSelfVerification, true);
 });
 
@@ -712,7 +736,25 @@ function assessOnNativeCli(currentTargetIdentity: () => string): Partial<NativeR
 	return {
 		reviewMode: async () => ({ operation: "status", scope: "clone", status: { global: "on", cloneLocal: "", effective: "on", source: NATIVE_REVIEW_MODE_SOURCE.GLOBAL } }),
 		assess: async () => ({ schema: REVIEW_ASSESSMENT_SCHEMA, risk: "high", reasons: [], changedPaths: 1, changedLines: 5, candidate: { kind: "current-changes", baseRef: undefined } }),
-		targetStatus: (async () => ({ applicability: "current_target", targetIdentity: currentTargetIdentity() })) as NativeReviewCli["targetStatus"],
+		targetStatus: async (): Promise<ReviewStatusV3> => ({
+			contract: "gentle-ai.review-integration/v2", applicability: "current_target",
+			action: "stop", replayability: "manual_action_required", targetIdentity: currentTargetIdentity(),
+			projection: {
+				schema: "gentle-ai.review-integration.projection/v1",
+				kind: "current-changes", projection: "workspace", baseTree: "a".repeat(40),
+				initialReviewTree: "a".repeat(40), currentCandidateTree: "b".repeat(40),
+				pathsDigest: "c".repeat(64), paths: ["candidate.ts"], intendedUntracked: [],
+				intendedUntrackedProof: "d".repeat(64), initialSnapshotIdentity: "e".repeat(64),
+				currentSnapshotIdentity: currentTargetIdentity(),
+			},
+			repair: {
+				schema: "gentle-ai.review-authority-repair-assessment/v1", status: "unsupported",
+				counts: { lineages: 0, compactLineages: 0, legacyLineages: 0, events: 0, bytes: 0, eligibleCandidates: 0, unsupportedLineages: 0, conflicts: 0 },
+				supportedOperations: ["review/complete-fix", "review/validate-fix"],
+				authorizationSchema: "gentle-ai.review-repair-authorization/v1",
+			},
+			candidates: [], raw: {},
+		}),
 	};
 }
 
@@ -806,12 +848,46 @@ async function assessWith(cli: Partial<NativeReviewCli>, input?: Record<string,
 	return (await reviewControllerTool(cli).execute("closure", params, undefined, undefined, context)).details as AssessDetails;
 }
 
+test("gentle_review assess: already-reviewed predecessor remains medium and never proves exact-candidate closure (#1954)", async (t) => {
+	t.after(() => __testing.clearNativeReviewOutcomeMemoForTesting());
+	__testing.clearNativeReviewOutcomeMemoForTesting();
+	for (const input of [undefined, { nativeReviewOutcome: "closed" }]) {
+		const queue = queuedAdapter([{ stdout: JSON.stringify(reviewedPredecessorEnvelope()) }]);
+		const client = nativeClient(queue.adapter);
+		const cli = {
+			...closureCli({ risk: "medium", consumed: false }),
+			assess: client.assess.bind(client),
+		};
+		const details = await assessWith(cli, input) as AssessDetails & {
+			candidate: { consumed: boolean };
+			reviewDue: boolean;
+			reviewDueReason: string;
+		};
+		assert.equal(queue.calls.length, 1, "assessment must pass through the native CLI decoder");
+		assert.equal(details.risk, "medium", "supported predecessor evidence must not become unassessable");
+		assert.equal(details.candidate.consumed, false);
+		assert.equal(details.reviewDue, false);
+		assert.equal(details.reviewDueReason, "already_reviewed");
+		assert.equal(Object.hasOwn(details, "nextTransition"), false);
+		assert.equal(details.nativeReviewOutcome, "unknown", "already_reviewed is not exact-candidate consumption");
+		assert.equal(details.outcome_source, "unknown");
+		assert.deepEqual(details.plan, verificationPlan({
+			rddLine: RDD_LINE.ON,
+			risk: VERIFICATION_TIER.MEDIUM,
+			writerProfile: details.writerProfile as WriterProfile,
+			nativeReviewOutcome: NATIVE_REVIEW_OUTCOME.UNKNOWN,
+		}));
+		assert.equal(details.plan.writerSelfVerification, true);
+		assert.equal(details.plan.structuralReadbackOnly, false);
+	}
+});
+
 test("gentle_review assess: native consumed true derives closed for this candidate", async () => {
 	const details = await assessWith(closureCli({ consumed: true }));
 	assert.equal(details.nativeReviewOutcome, "closed");
 	assert.equal(details.outcome_source, "derived");
 	assert.equal(details.plan.writerSelfVerification, true);
-	assert.equal(details.plan.independentVerifier, false, "a natively closed candidate restores the RDD on-path");
+	assert.equal(details.plan.independentVerifier, true, "a natively closed candidate keeps the risk-tier verifier (verify-always-rdd-high S1)");
 });
 
 test("gentle_review assess: a caller-declared closed without native consumed evidence fails closed to unknown", async () => {
@@ -827,7 +903,7 @@ test("gentle_review assess: a caller-declared closed corroborated by native cons
 	const details = await assessWith(closureCli({ consumed: true }), { nativeReviewOutcome: "closed" });
 	assert.equal(details.nativeReviewOutcome, "closed");
 	assert.equal(details.outcome_source, "derived", "closure is attributed to the native evidence, not to the caller's claim");
-	assert.equal(details.plan.independentVerifier, false);
+	assert.equal(details.plan.independentVerifier, true, "closure never removes the risk-tier verifier");
 });
 
 test("gentle_review assess: explicit declined, unavailable, or unknown beats native consumed (only ever raises the bar)", async () => {
@@ -1154,7 +1230,7 @@ test("native assess: a non-zero exit (an older binary reporting an unknown comma
 	const textOnStdout = queuedAdapter([{ stdout: "unknown command \"assess\" for \"gentle-ai review\"", exitCode: 1 }]);
 	await assert.rejects(
 		() => nativeClient(textOnStdout.adapter).assess!({ cwd: process.cwd() }),
-		(error: unknown) => error instanceof NativeReviewCliError && [NATIVE_REVIEW_ERROR_CODE.MALFORMED_JSON, NATIVE_REVIEW_ERROR_CODE.NON_ZERO].includes(error.code),
+		(error: unknown) => error instanceof NativeReviewCliError && (error.code === NATIVE_REVIEW_ERROR_CODE.MALFORMED_JSON || error.code === NATIVE_REVIEW_ERROR_CODE.NON_ZERO),
 	);
 });
 

package/tests/review-session-standing-permission-controller.test.ts

@@ -42,7 +42,7 @@ function nonPiV3Consent() {
 }
 
 function consentCustom(select: (title: string, options: string[]) => Promise<string | undefined>) {
-	return async (factory: (...args: never[]) => unknown) => {
+	return async (factory: (...args: unknown[]) => unknown) => {
 		let result: unknown;
 		const component = factory(
 			{ terminal: { rows: 24 }, requestRender() {} },
@@ -241,15 +241,14 @@ function piConsent() {
 	const decoded = consent();
 	return {
 		...decoded,
-		choices: decoded.choices.map((choice) => ({
-			...choice,
-			invocation: choice.invocation.replace(" --consent ", " --agent pi --consent "),
-		})) as typeof decoded.choices,
+		choices: [
+			{ ...decoded.choices[0], invocation: decoded.choices[0].invocation.replace(" --consent ", " --agent pi --consent ") },
+			{ ...decoded.choices[1], invocation: decoded.choices[1].invocation.replace(" --consent ", " --agent pi --consent ") },
+		] as const,
 	};
 }
 
 function controllerHarness(cwd: string, processEnv: NodeJS.ProcessEnv = {}, options: {
-	now?: () => number;
 	answerConsentError?: Error & { mutationOutcome?: "none" | "unknown" };
 	startAction?: "created" | "resumed" | "replayed" | "closed" | "blocked-scope-action";
 	childStandingReviewPermissionClient?: ChildStandingReviewPermissionClient;
@@ -284,7 +283,7 @@ function controllerHarness(cwd: string, processEnv: NodeJS.ProcessEnv = {}, opti
 			return { kind: "started", start: { lineageId: `lineage-${answers.length}`, state: action === "blocked-scope-action" ? "unreviewed" : "approved", riskLevel: "high", selectedLenses: [], changedFiles: 1, changedLines: 2, correctionBudget: 0, action, lensesRequired: false, riskReasons: [] } };
 		},
 	} as unknown as NativeReviewCli;
-	createGentleAiExtension({ nativeReviewCli: native, candidateViews: new CandidateViewRegistry(), processEnv, now: options.now, childStandingReviewPermissionClient: options.childStandingReviewPermissionClient })({
+	createGentleAiExtension({ nativeReviewCli: native, candidateViews: new CandidateViewRegistry(), processEnv, childStandingReviewPermissionClient: options.childStandingReviewPermissionClient })({
 		on(name: string, handler: RegisteredEvent) { events.set(name, handler); },
 		registerCommand(name: string, definition: RegisteredCommand) { commands.set(name, definition); },
 		registerTool(definition: RegisteredTool & { name: string }) { tools.set(definition.name, definition); },
@@ -471,10 +470,11 @@ test("blocked-scope-action never persists host permission", async (t) => {
 	assert.deepEqual(runtime.answers, ["granted", "declined"]);
 });
 
-test("a stale consent result with contextual native status never arms host permission", async (t) => {
+test("a late consent answer is accepted once and arms host permission without another prompt", async (t) => {
 	const cwd = reviewRepository(t);
 	let now = 0;
-	const runtime = controllerHarness(cwd, {}, { now: () => now });
+	t.mock.method(Date, "now", () => now);
+	const runtime = controllerHarness(cwd);
 	const manager = {};
 	let prompts = 0;
 	const ctx = interactiveContext(cwd, manager, async (_title, options) => {
@@ -486,14 +486,13 @@ test("a stale consent result with contextual native status never arms host permi
 		return options[1];
 	});
 	const start = { operation: "start", input: JSON.stringify({ mode: "ordinary" }) };
-	const stale = (await runtime.controller.execute("expired-host-choice", start, undefined, undefined, ctx)).details;
-	assert.equal(stale.outcome, "consent-binding-stale");
-	assert.equal(stale.native_invocation_attempted, false);
-	assert.equal(typeof stale.result, "object", "native STATUS is contextual evidence, not a successful START result");
+	const accepted = (await runtime.controller.execute("late-host-choice", start, undefined, undefined, ctx)).details;
+	assert.notEqual(accepted.outcome, "consent-binding-stale");
+	assert.deepEqual(runtime.answers, ["granted"]);
 	writeFileSync(join(cwd, "app.ts"), "export const value = 3;\n");
-	await runtime.controller.execute("after-stale", start, undefined, undefined, ctx);
-	assert.equal(prompts, 2, "the next fresh consent envelope must still prompt after a stale contextual result");
-	assert.deepEqual(runtime.answers, ["declined"]);
+	await runtime.controller.execute("after-late-answer", start, undefined, undefined, ctx);
+	assert.equal(prompts, 1, "a late session grant must not cause a second prompt");
+	assert.deepEqual(runtime.answers, ["granted", "granted"]);
 });
 
 test("a failed consent invocation never arms host permission", async (t) => {
@@ -624,7 +623,7 @@ test("a package-owned child replays its exact pending ordinary grant from a sibl
 	const parentToChild = new PassThrough();
 	const broker = new ParentStandingReviewPermissionBroker(
 		{ readable: childToParent, writable: parentToChild },
-		(repositoryIdentity) => repositoryIdentity === parentIdentity.repositoryIdentity && parentManager.getSessionId() === "parent-session" && hasReviewSessionPermission(parentIdentity),
+		(repositoryIdentity) => repositoryIdentity === parentIdentity.repositoryIdentity && parentIdentity.sessionManager.getSessionId() === "parent-session" && hasReviewSessionPermission(parentIdentity),
 	);
 	const childPermission = new ChildStandingReviewPermissionClient(
 		{ readable: parentToChild, writable: childToParent },

package/tests/review-session-standing-permission-ipc.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { PassThrough, Writable } from "node:stream";
+import { Duplex, PassThrough, Writable } from "node:stream";
 import test from "node:test";
 import { AGENT_MODE, type AgentDefinition } from "../lib/agents-config.ts";
 import { AgentRunner, type ChildLike, type TaskRequest } from "../lib/agents-runner.ts";
@@ -111,6 +111,7 @@ async function productionChild(requests: number, authorize: () => boolean, optio
 		stdio: options.withoutChannel ? ["ignore", "pipe", "pipe"] : ["ignore", "pipe", "pipe", options.stdioMode ?? productionFd3StdioMode],
 	});
 	const pipe = child.stdio[3];
+	assert.ok(pipe === null || pipe === undefined || pipe instanceof Duplex, "fd3 must be a bidirectional channel");
 	const trace = options.diagnosticTrace;
 	const onParentData = () => { if (trace !== undefined) trace.parentRawDataChunkCount += 1; };
 	if (trace !== undefined && pipe !== null && pipe !== undefined) pipe.on("data", onParentData);
@@ -120,9 +121,9 @@ async function productionChild(requests: number, authorize: () => boolean, optio
 			trace.parentAuthorizationCallbackCount += 1;
 			return authorize();
 		};
-	const broker = pipe === null || pipe === undefined
-		? undefined
-		: new ParentStandingReviewPermissionBroker({ readable: pipe, writable: pipe }, parentAuthorize, options);
+	const broker = pipe instanceof Duplex
+		? new ParentStandingReviewPermissionBroker({ readable: pipe, writable: pipe }, parentAuthorize, options)
+		: undefined;
 	if (options.closeChannel && pipe !== null && pipe !== undefined) {
 		broker?.close();
 		pipe.destroy();
@@ -323,7 +324,7 @@ test("fresh Jiti moduleCache:false reloads share fd3 structurally and reject sta
 		stdio: ["ignore", "pipe", "pipe", productionFd3StdioMode],
 	});
 	const pipe = child.stdio[3];
-	assert.ok(pipe);
+	assert.ok(pipe instanceof Duplex, "fd3 must be a bidirectional channel");
 	const broker = new ParentStandingReviewPermissionBroker({ readable: pipe, writable: pipe }, () => true);
 	let stdout = "";
 	let stderr = "";

package/tests/review-test-fixtures.ts

@@ -7,6 +7,7 @@ import {
 	type ReviewMode,
 } from "../lib/review-snapshot.ts";
 import { existsSync, renameSync } from "node:fs";
+import { correctionBudget, REVIEW_RISK_TIER } from "../lib/review-risk.ts";
 import type { ReviewLockPlatformAdapterV1 } from "../lib/review-lock.ts";
 import {
 	REVIEW_EVENT,
@@ -45,6 +46,7 @@ export function testSnapshot(options: TestSnapshotOptions): SnapshotV1 {
 	const lenses = options.lenses ?? [];
 	const initialTree = options.initialTree ?? options.completeTree;
 	const selected = lenses[0];
+	const changedLines = route === REVIEW_ROUTE.FULL_4R ? 401 : route === REVIEW_ROUTE.TRIVIAL ? 1 : 10;
 	return {
 		schema: "gentle-ai.review-snapshot/v1",
 		mode: options.mode ?? REVIEW_MODE.ORDINARY,
@@ -57,9 +59,13 @@ export function testSnapshot(options: TestSnapshotOptions): SnapshotV1 {
 				: { kind: REVIEW_PROJECTION.INTENDED_COMMIT, tree: initialTree },
 		initial_review_tree: initialTree,
 		genesis_paths: options.genesisPaths ?? ["app.ts", "src/auth.ts", "src/retry.ts", "src/review.ts"],
+		intended_untracked: [],
+		risk_tier: route === REVIEW_ROUTE.FULL_4R ? REVIEW_RISK_TIER.HIGH : route === REVIEW_ROUTE.TRIVIAL ? REVIEW_RISK_TIER.LOW : REVIEW_RISK_TIER.MEDIUM,
+		original_changed_lines: changedLines,
+		correction_budget: correctionBudget(changedLines),
 		diff_evidence: {
 			event: REVIEW_EVENT.ORDINARY_START,
-			changedLines: route === REVIEW_ROUTE.FULL_4R ? 401 : route === REVIEW_ROUTE.TRIVIAL ? 1 : 10,
+			changedLines,
 			triviality:
 				route === REVIEW_ROUTE.TRIVIAL
 					? TRIVIALITY.PROVEN

package/tests/review-transaction.test.ts

@@ -33,6 +33,7 @@ import {
 	createFrozenLedger,
 	createReceiptEnvelope,
 	createReviewState,
+	validateReviewGraphReplayV1,
 	evaluateGateTarget,
 	type CanonicalFrozenRowV1,
 	type ReceiptBodyV1,
@@ -41,8 +42,12 @@ import {
 import { REVIEW_LENS, REVIEW_ROUTE } from "../lib/review-triggers.ts";
 import {
 	ordinaryValidatorRequest,
+	recordOrdinaryDiscovery,
+	resolveOrdinaryEvidence,
+	recordOrdinaryFinalVerification,
 	recordOrdinaryValidation,
 } from "../lib/review-policy-ordinary.ts";
+import { createReviewEventV1 } from "../lib/review-graph-schema.ts";
 import { qualifiedReviewLockPlatform, testSnapshot } from "./review-test-fixtures.ts";
 
 const TREE = {
@@ -393,7 +398,19 @@ test("ordinary follow-ups are ID-sorted action-free validation evidence and do n
 	assert.equal(recorded.phase, REVIEW_PHASE.FINAL_VERIFICATION);
 	assert.equal(recorded.counters.validator_runs, fixed.counters.validator_runs + 1);
 	assert.equal(recorded.current_candidate_tree, fixed.current_candidate_tree);
-	assert.equal(recorded.follow_ups, undefined);
+	assert.equal(Object.hasOwn(recorded, "follow_ups"), false);
+});
+
+test("graph replay rejects a persisted non-boolean final verification instead of approving truthy input", () => {
+	const ready = resolveOrdinaryEvidence(recordOrdinaryDiscovery(state(), { rows: [] }), { deterministicResults: [] });
+	const approved = recordOrdinaryFinalVerification(ready, { passed: true });
+	const genesis = createReviewEventV1({ lineage_id: ready.lineage_id, sequence: 0, predecessor_event_id: null, kind: "lineage-created", reducer_transition: "start", reducer_input: ready, payload: { state: ready }, reduced_state_hash: canonicalHash(ready) });
+	for (const passed of ["false", "true", 0, 1, null]) {
+		const next = createReviewEventV1({ lineage_id: ready.lineage_id, sequence: 1, predecessor_event_id: genesis.event_id, kind: "operation-completed", reducer_transition: REVIEW_TRANSITION.ORDINARY_FINAL_VERIFICATION, reducer_input: { passed }, payload: { state: approved }, reduced_state_hash: canonicalHash(approved) });
+		assert.throws(() => validateReviewGraphReplayV1([genesis, next]), /reducer input.*passed/i);
+	}
+	const valid = createReviewEventV1({ lineage_id: ready.lineage_id, sequence: 1, predecessor_event_id: genesis.event_id, kind: "operation-completed", reducer_transition: REVIEW_TRANSITION.ORDINARY_FINAL_VERIFICATION, reducer_input: { passed: true }, payload: { state: approved }, reduced_state_hash: canonicalHash(approved) });
+	assert.deepEqual(validateReviewGraphReplayV1([genesis, valid]), approved);
 });
 
 test("new ordinary lineages fail closed when immutable genesis paths are absent", () => {

package/tests/run-test-suite.test.ts

@@ -1,16 +1,14 @@
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
 import { DEFAULT_STAGES, runTestSuite } from "../scripts/run-test-suite.mjs";
 
-// `pnpm test` chains its three stages; #1285 requires that a stage-1 failure
-// never suppresses the later stages. These tests cover the runner's
-// orchestration contract with fake stage implementations, so no real test
-// process is spawned.
+// #1285 requires that a stage-1 failure never suppresses later stages.
+// Orchestration tests use fake stages; CLI tests exercise real child processes.
 
 function fakeRunStage(codes) {
 	let index = 0;
@@ -113,6 +111,86 @@ test("direct invocation still runs stages when reached through a file symlink",
 	assert.match(result.stdout ?? "", /all stages passed/);
 });
 
+function probeStageEnvironment(t: test.TestContext, env: NodeJS.ProcessEnv) {
+	const stagesPath = writeStagesFile(t, []);
+	const probePath = join(dirname(stagesPath), "probe.mjs");
+	writeFileSync(probePath, `
+import { existsSync, readdirSync } from "node:fs";
+const home = process.env.GENTLE_PI_CONFIG_HOME;
+console.log("ENV_PROBE=" + JSON.stringify({
+  git: Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith("GIT_"))),
+  agents: Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith("GENTLE_PI_AGENTS_"))),
+  home,
+  files: home && existsSync(home) ? readdirSync(home) : null,
+  sentinel: process.env.TEST_ENV_SENTINEL,
+}));
+`);
+	writeFileSync(stagesPath, JSON.stringify([
+		{ name: "unit-tests", command: `node "${probePath}"` },
+		{ name: "provider-contract", command: `node "${probePath}"` },
+	]));
+	const result = spawnSync(process.execPath, [runnerPath, stagesPath], {
+		encoding: "utf8", env: { ...process.env, ...env, TEST_ENV_SENTINEL: "preserved" },
+	});
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(result.stderr, "");
+	assert.match(result.stdout, /PASS  unit-tests/);
+	assert.match(result.stdout, /PASS  provider-contract/);
+	const probes = result.stdout.split(/\r?\n/).filter((line) => line.startsWith("ENV_PROBE="))
+		.map((line) => JSON.parse(line.slice("ENV_PROBE=".length)));
+	assert.equal(probes.length, 2);
+	for (const probe of probes) assert.equal(probe.sentinel, "preserved");
+	return probes;
+}
+
+test("unit stage strips inherited Git configuration without changing later stages", (t) => {
+	const env = {
+		GIT_CONFIG_COUNT: "2",
+		GIT_CONFIG_KEY_0: "credential.interactive", GIT_CONFIG_VALUE_0: "false",
+		GIT_CONFIG_KEY_1: "credential.guiPrompt", GIT_CONFIG_VALUE_1: "false",
+		GIT_DIR: "inherited-repository", GIT_AUTHOR_NAME: "inherited-author",
+	};
+	const [unit, provider] = probeStageEnvironment(t, env);
+	assert.deepEqual(unit.git, {});
+	for (const [key, value] of Object.entries(env)) assert.equal(provider.git[key], value);
+});
+
+test("unit stage strips inherited subagent context without changing later stages", (t) => {
+	const env = { GENTLE_PI_AGENTS_CHILD: "1", GENTLE_PI_AGENTS_OWNED_IPC: "1" };
+	const [unit, provider] = probeStageEnvironment(t, env);
+	assert.deepEqual(unit.agents, {});
+	for (const [key, value] of Object.entries(env)) assert.equal(provider.agents[key], value);
+});
+
+test("unit stage accepts an uncreated inherited config home without creating it", (t) => {
+	const dir = mkdtempSync(join(tmpdir(), "gentle-pi-caller-config-"));
+	t.after(() => rmSync(dir, { recursive: true, force: true }));
+	const home = join(dir, "not-created");
+	assert.equal(existsSync(home), false);
+	const [unit, provider] = probeStageEnvironment(t, { GENTLE_PI_CONFIG_HOME: home });
+	assert.notEqual(unit.home, home);
+	assert.deepEqual(unit.files, []);
+	assert.equal(existsSync(unit.home), false);
+	assert.equal(provider.home, home);
+	assert.equal(provider.files, null);
+	assert.equal(existsSync(home), false);
+});
+
+test("unit stage uses an empty temporary config home and removes it after exit", (t) => {
+	const home = mkdtempSync(join(tmpdir(), "gentle-pi-caller-config-"));
+	t.after(() => rmSync(home, { recursive: true, force: true }));
+	const configPath = join(home, "runtime-guardrails.json");
+	const config = JSON.stringify({ autonomousMode: true, guardedCommands: { gitPush: "allow", gitRebase: "allow", gitBranchDeleteForce: "allow" } });
+	writeFileSync(configPath, config);
+	const [unit, provider] = probeStageEnvironment(t, { GENTLE_PI_CONFIG_HOME: home });
+	assert.notEqual(unit.home, home);
+	assert.deepEqual(unit.files, []);
+	assert.equal(existsSync(unit.home), false);
+	assert.equal(provider.home, home);
+	assert.deepEqual(provider.files, ["runtime-guardrails.json"]);
+	assert.equal(readFileSync(configPath, "utf8"), config);
+});
+
 test("direct invocation rejects a malformed stages file with a non-zero exit", (t) => {
 	const dir = mkdtempSync(join(tmpdir(), "gentle-pi-run-test-suite-"));
 	t.after(() => rmSync(dir, { recursive: true, force: true }));

package/tests/runtime-harness.mjs

@@ -390,7 +390,24 @@ async function run() {
 	assert.ok(flags.has("no-skill-registry"), "missing no-skill-registry flag");
 	assert.ok(hooks.has("session_start"), "missing session_start hook");
 	assert.ok(hooks.has("session_shutdown"), "missing session_shutdown hook");
-	assert.equal(hooks.has("input"), false, "retired SDD slash input must not be intercepted");
+	assert.ok(hooks.has("input"), "missing live input provenance hook");
+	for (const text of [
+		"/sdd-init", "/sdd-continue", "/sdd-status", "/gentle-sdd-init",
+		"/gentle-sdd-continue", "/gentle-sdd-status", "/gentle:install-sdd",
+		"/gentle:sdd-preflight", "/gentle-ai:install-sdd", "/gentle-ai:sdd-preflight",
+		"/gentle-ai:sdd-status", "/gentle-ai:sdd-continue",
+		"Inspect this project without changing files.", "/ordinary-unregistered-command",
+	]) {
+		const event = { text, source: "interactive", images: [] };
+		const before = structuredClone(event);
+		const emittedBefore = emittedEvents.length;
+		for (const handler of hooks.get("input")) {
+			assert.deepEqual(await handler(event, createCtx(ROOT)), { action: "continue" },
+				`input must pass through without slash interception: ${text}`);
+		}
+		assert.deepEqual(event, before, "input text and attachments must remain unchanged");
+		assert.equal(emittedEvents.length, emittedBefore, "input must not dispatch slash logic");
+	}
 	assert.ok(hooks.has("before_agent_start"), "missing before_agent_start hook");
 	assert.ok(hooks.has("tool_call"), "missing tool_call hook");
 	for (const toolName of ["read", "grep", "find", "ls", "edit", "write"]) {
@@ -450,7 +467,8 @@ async function run() {
 	// rules) moved verbatim to assets/orchestrator-delegation.md; the
 	// always-on combined prompt now only carries a pointer to it. Union read
 	// so these assertions are repointed, not weakened.
-	const delegationDetail = await readFile(join(ROOT, "assets", "orchestrator-delegation.md"), "utf8");
+	const { DELEGATION_MODULES } = await import("./support/orchestrator-modules.ts");
+	const delegationDetail = (await Promise.all(DELEGATION_MODULES.map((file) => readFile(join(ROOT, "assets", file), "utf8")))).join("\n\n");
 
 	const promptCwd = await tempWorkspace();
 	try {
@@ -1018,8 +1036,8 @@ async function run() {
 		assert.equal(existsSync(installedExplorePath), true);
 		assert.deepEqual(
 			readAgentDefinition(await readFile(installedExplorePath, "utf8")),
-			{ name: "gentle-ai-explore", tools: ["read", "grep", "find", "codegraph"] },
-			"isolated package installation must activate only the explorer inspection tools",
+			{ name: "gentle-ai-explore", tools: ["read", "grep", "find", "codegraph", "web_enable", "web_search", "source_check", "fetch_content", "get_search_content"] },
+			"isolated package installation must declare the explorer's local and direct web scope",
 		);
 		const installedRiskSource = await readFile(
 			join(globalAgentHome, "agents", "review-risk.md"),
@@ -1316,15 +1334,15 @@ async function run() {
 		);
 		await writeFile(globalModelsPath, JSON.stringify({ "sdd-apply": {} }, null, 2));
 		await hooks.get("session_start")[0]({ reason: "startup" }, legacyCtx);
-		const explicitInheritClearsAgent = await readFile(
+		const savedInheritPreservesAgent = await readFile(
 			join(legacyModelsCwd, ".pi", "agents", "sdd-apply.md"),
 			"utf8",
 		);
-		assert.doesNotMatch(explicitInheritClearsAgent, /model:/);
-		const explicitInheritClearsProfiles = JSON.parse(
+		assert.match(savedInheritPreservesAgent, /model: global\/provider-model/);
+		const savedInheritPreservesProfiles = JSON.parse(
 			await readFile(join(legacyModelsCwd, ".pi", "subagents.json"), "utf8"),
 		);
-		assert.equal(explicitInheritClearsProfiles.model_profiles, undefined);
+		assert.equal(savedInheritPreservesProfiles.model_profiles["sdd-apply"].model, "global/provider-model");
 	} finally {
 		await rm(legacyModelsCwd, { recursive: true, force: true });
 		await rm(globalModelsPath, { force: true });
@@ -1346,10 +1364,12 @@ async function run() {
 		);
 		await writeFile(globalModelsPath, JSON.stringify({ worker: {} }, null, 2));
 		await hooks.get("session_start")[0]({ reason: "startup" }, createCtx(staleSettingsOnlyCwd, true));
-		const staleOnlyClearedProfiles = JSON.parse(
+		const staleOnlyPreservedProfiles = JSON.parse(
 			await readFile(globalSubagentsPath, "utf8"),
 		);
-		assert.equal(staleOnlyClearedProfiles.model_profiles, undefined);
+		assert.deepEqual(staleOnlyPreservedProfiles.model_profiles, {
+			worker: { model: "stale/model", effort: "high" },
+		});
 	} finally {
 		await rm(staleSettingsOnlyCwd, { recursive: true, force: true });
 		await rm(globalModelsPath, { force: true });
@@ -1565,22 +1585,29 @@ async function run() {
 		assert.match(preservedProjectSubagentWorker, /thinking: medium/);
 		await writeFile(globalModelsPath, JSON.stringify({ worker: {} }, null, 2));
 		await hooks.get("session_start")[0]({ reason: "startup" }, createCtx(modelsCwd, true));
-		const clearedProfiles = JSON.parse(
+		// gentle-ai#4946: startup/reload never treats persisted inherit as
+		// deletion approval, including for previously materialized routing.
+		// Explicit panel saves and confirmed profile replacement still clear.
+		const preservedClearProfiles = JSON.parse(
 			await readFile(join(modelsCwd, ".pi", "subagents.json"), "utf8"),
 		);
-		assert.equal(clearedProfiles.model_profiles, undefined);
+		assert.equal(
+			preservedClearProfiles.model_profiles.worker.model,
+			"existing/model",
+		);
+		assert.equal(preservedClearProfiles.model_profiles.worker.effort, "high");
 		const unchangedProjectWorker = await readFile(
 			join(modelsCwd, ".pi", "agents", "worker.md"),
 			"utf8",
 		);
 		assert.match(unchangedProjectWorker, /model: existing\/project-worker/);
 		assert.match(unchangedProjectWorker, /thinking: high/);
-		const clearedProjectSubagentWorker = await readFile(
+		const preservedClearProjectSubagentWorker = await readFile(
 			join(modelsCwd, ".pi", "subagents", "worker.md"),
 			"utf8",
 		);
-		assert.doesNotMatch(clearedProjectSubagentWorker, /model:/);
-		assert.doesNotMatch(clearedProjectSubagentWorker, /thinking:/);
+		assert.match(preservedClearProjectSubagentWorker, /model: existing\/project-subagent-worker/);
+		assert.match(preservedClearProjectSubagentWorker, /thinking: medium/);
 
 		await writeFile(
 			globalModelsPath,