gentle-pi 3.7.0 → 4.0.0

package/tests/review-integration-v2-forward.test.ts

@@ -17,6 +17,7 @@ import {
 	decodeReviewStartV4,
 	decodeReviewStatusV3,
 } from "../lib/review-integration-v2.ts";
+import { NativeReviewCliV216, type ExecFileAdapter } from "../lib/native-review-cli.ts";
 
 const DEV_FIXTURES = join(process.cwd(), "tests", "fixtures", "devbinary");
 const V2_FIXTURES = join(process.cwd(), "contracts", "review-integration", "v2", "fixtures");
@@ -556,6 +557,205 @@ test("status/v6 decodes and enforces the intended-untracked selection submission
 	}
 });
 
+function queuedTargetStatusAdapter(): { adapter: ExecFileAdapter; calls: string[][] } {
+	const calls: string[][] = [];
+	return {
+		calls,
+		adapter: async (request) => {
+			calls.push([...request.arguments]);
+			return { stdout: JSON.stringify(currentStatusFixture("status-v5.captured.json")), stderr: "", exitCode: 0, signal: null, timedOut: false, outputLimitExceeded: false };
+		},
+	};
+}
+
+function targetStatusClient(adapter: ExecFileAdapter): NativeReviewCliV216 {
+	return new NativeReviewCliV216(adapter, "/package/.gentle-ai/gentle-ai", 30_000, 1024 * 1024);
+}
+
+const SUBMITTED_PROVIDER_TOKENS = ["--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", "--intended-untracked-selection={{value}}"];
+
+test("targetStatus appends the forwarded base-ref/committed-only pair after intended-untracked submission tokens", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo",
+		baseRef: "deadbeef",
+		committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "deadbeef", "--committed-only",
+	]);
+});
+
+test("targetStatus leaves the intended-untracked submission argv unchanged when no baseRef is forwarded", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+	]);
+});
+
+test("targetStatus rejects a forwarded baseRef that conflicts with a base-ref the submission already carries", async () => {
+	const queue = queuedTargetStatusAdapter();
+	const tokensWithBaseRef = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref=cafebabe"];
+	await assert.rejects(
+		() => targetStatusClient(queue.adapter).targetStatus({
+			cwd: "/repo", baseRef: "deadbeef", committedOnly: true,
+			intendedUntrackedSelection: { argumentTokens: tokensWithBaseRef, value: '{"selection":true}' },
+		}),
+		TypeError,
+	);
+	assert.equal(queue.calls.length, 0);
+
+	// Same value on both sides is not a conflict, but the submission still lacks
+	// --committed-only: T3 appends it so the selector stays complete.
+	const sameValueQueue = queuedTargetStatusAdapter();
+	await targetStatusClient(sameValueQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBaseRef, value: '{"selection":true}' },
+	});
+	assert.deepEqual(sameValueQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref=cafebabe",
+		"--committed-only",
+	]);
+});
+
+test("targetStatus appends --committed-only when the submission's same base-ref is missing it, and skips it when already present", async () => {
+	const missingQueue = queuedTargetStatusAdapter();
+	const tokensWithBaseRefOnly = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref", "cafebabe"];
+	await targetStatusClient(missingQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBaseRefOnly, value: '{"selection":true}' },
+	});
+	assert.deepEqual(missingQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "cafebabe",
+		"--committed-only",
+	]);
+
+	const presentQueue = queuedTargetStatusAdapter();
+	const tokensWithBoth = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref=cafebabe", "--committed-only=true"];
+	await targetStatusClient(presentQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBoth, value: '{"selection":true}' },
+	});
+	assert.deepEqual(presentQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref=cafebabe", "--committed-only=true",
+	]);
+
+	const committedOnlyQueue = queuedTargetStatusAdapter();
+	const tokensWithCommittedOnly = [...SUBMITTED_PROVIDER_TOKENS, "--committed-only"];
+	await targetStatusClient(committedOnlyQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithCommittedOnly, value: '{"selection":true}' },
+	});
+	assert.deepEqual(committedOnlyQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--committed-only",
+		"--base-ref", "cafebabe",
+	]);
+});
+
+test("targetStatus forwards --lineage on the submitted branch, skips a matching value, and rejects a conflicting one", async () => {
+	const forwardedQueue = queuedTargetStatusAdapter();
+	await targetStatusClient(forwardedQueue.adapter).targetStatus({
+		cwd: "/repo", lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(forwardedQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--lineage", "review-abc123",
+	]);
+
+	const sameValueQueue = queuedTargetStatusAdapter();
+	const tokensWithLineage = [...SUBMITTED_PROVIDER_TOKENS, "--lineage=review-abc123"];
+	await targetStatusClient(sameValueQueue.adapter).targetStatus({
+		cwd: "/repo", lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: tokensWithLineage, value: '{"selection":true}' },
+	});
+	assert.deepEqual(sameValueQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--lineage=review-abc123",
+	]);
+
+	const conflictQueue = queuedTargetStatusAdapter();
+	await assert.rejects(
+		() => targetStatusClient(conflictQueue.adapter).targetStatus({
+			cwd: "/repo", lineageId: "review-other",
+			intendedUntrackedSelection: { argumentTokens: tokensWithLineage, value: '{"selection":true}' },
+		}),
+		TypeError,
+	);
+	assert.equal(conflictQueue.calls.length, 0);
+});
+
+test("targetStatus forwards base-ref and lineage together on the submitted branch, base-ref first", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "deadbeef", committedOnly: true, lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "deadbeef", "--committed-only",
+		"--lineage", "review-abc123",
+	]);
+});
+
+test("targetStatus rejects a dangling or empty --base-ref/--lineage in the submitted tokens", async () => {
+	for (const tokens of [
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref="],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage="],
+	]) {
+		const queue = queuedTargetStatusAdapter();
+		await assert.rejects(
+			() => targetStatusClient(queue.adapter).targetStatus({
+				cwd: "/repo",
+				intendedUntrackedSelection: { argumentTokens: tokens, value: '{"selection":true}' },
+			}),
+			TypeError,
+			JSON.stringify(tokens),
+		);
+		assert.equal(queue.calls.length, 0, JSON.stringify(tokens));
+	}
+});
+
+test("targetStatus rejects ambiguous or malformed provider selectors before executing STATUS", async () => {
+	for (const tokens of [
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=false"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=garbage"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=true", "--committed-only=true"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only", "--committed-only=true"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref=deadbeef", "--base-ref", "deadbeef"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage=review-a", "--lineage", "review-a"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref", "--lineage=review-a"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage", "--base-ref=deadbeef"],
+	]) {
+		const queue = queuedTargetStatusAdapter();
+		await assert.rejects(() => targetStatusClient(queue.adapter).targetStatus({
+			cwd: "/repo", intendedUntrackedSelection: { argumentTokens: tokens, value: '{"selection":true}' },
+		}), TypeError, JSON.stringify(tokens));
+		assert.equal(queue.calls.length, 0, JSON.stringify(tokens));
+	}
+});
+
 test("START/v4 accepts only its reviewing status continuation and preserves v3 strictness", () => {
 	for (const action of ["created", "replayed"] as const) {
 		const start = reviewingStartV4(action);

package/tests/review-ledger-contract.test.ts

@@ -21,16 +21,7 @@ const GENTLE_SKILL = "skills/gentle-ai/SKILL.md";
 const README = "README.md";
 const TECHNICAL_REFERENCE = "docs/readme-reference.md";
 const CHAIN = "assets/chains/4r-review.chain.md";
-const SDD_WORKFLOW = "assets/sdd-orchestrator-workflow.md";
 const WORKER = "assets/agents/gentle-ai-worker.md";
-const CANONICAL_LIFECYCLE_SPECS = [
-	"openspec/specs/review-orchestration/spec.md",
-	"openspec/specs/review-transaction/spec.md",
-] as const;
-const HISTORICAL_LIFECYCLE_SPECS = [
-	"openspec/changes/complete-native-review-lifecycle/specs/review-orchestration/spec.md",
-	"openspec/changes/complete-native-review-lifecycle/specs/review-transaction/spec.md",
-] as const;
 
 function read(path: string): string {
 	return readFileSync(join(ROOT, path), "utf8");
@@ -85,7 +76,6 @@ const JUDGMENT_DAY_SEMANTIC_SURFACES = [
 	...JUDGES,
 	FIX_AGENT,
 	"assets/orchestrator-delegation.md",
-	SDD_WORKFLOW,
 ] as const;
 
 const JUDGMENT_DAY_REJUDGMENT_PATTERNS = [
@@ -240,25 +230,14 @@ test("ordinary lens prompts contain the literal compact-v2 native result envelop
 	}
 });
 
-test("canonical ordinary review specs preserve the negotiated one-correction contract", () => {
-	for (const path of CANONICAL_LIFECYCLE_SPECS) {
-		const content = read(path);
-		assert.match(content, /one correction transaction/i, path);
-		assert.match(content, /original.*budget|budget.*original/i, path);
-		assert.match(content, /never reruns initial lenses|without rerunning initial (?:lenses|review)/i, path);
-		assert.match(content, /correction_required/, path);
-		assert.match(content, /failure escalates|failed.*escalates|MUST escalate/i, path);
-		assert.match(content, /forecast/i, path);
-		assert.doesNotMatch(content, /up to three failed targeted attempts|third failed attempt/i, path);
-	}
-});
-
-test("historical lifecycle change specs preserve their completed one-attempt design context", () => {
-	for (const path of HISTORICAL_LIFECYCLE_SPECS) {
-		const content = read(path);
-		assert.match(content, /at most one correction|one correction batch|After the one correction|GIVEN one exact ordinary correction|one validator and one final verification/i, path);
-		assert.doesNotMatch(content, /up to three failed targeted attempts/i, path);
-	}
+test("retained provider review contract preserves bounded correction without declaring approval", () => {
+	const content = read(CANONICAL);
+	assert.match(content, /one correction transaction/i);
+	assert.match(content, /original budget/i);
+	assert.match(content, /`correction_required`/);
+	assert.doesNotMatch(content, /up to three failed targeted attempts|third failed attempt/i);
+	assert.match(content, /`reviewing`, `correction_required`, `validating`, `approved`, and `escalated`/);
+	assert.match(content, /Only severe `introduced`, `behavior-activated`, or `worsened` findings with valid proof can enter `correction_ids`/);
 });
 
 test("risk lens distinguishes trusted orchestration from concrete boundary bypasses", () => {
@@ -355,15 +334,13 @@ test("Judgment Day fix routing has one canonical shape and never falls back to g
 		[JD_SKILL, read(JD_SKILL)],
 		[JD_PROMPTS, fencedBlock(JD_PROMPTS, "## Fix Agent Prompt")],
 		["assets/orchestrator-delegation.md", read("assets/orchestrator-delegation.md")],
-		[SDD_WORKFLOW, read(SDD_WORKFLOW)],
 	] as const) {
 		assert.ok(content.includes(canonicalShape), `${path} must carry the canonical Judgment Day fix shape`);
 		assert.match(content, /requires no graph-v1 or native review lineage/i);
 	}
-	const routing = `${read("assets/orchestrator-delegation.md")}\n${read(SDD_WORKFLOW)}`;
+	const routing = read("assets/orchestrator-delegation.md");
 	assert.match(routing, /Judgment Day phase roles are never generic fallbacks\./);
 	assert.match(routing, /If the generic writer chain is unavailable, use the documented native generic fallback or stop\./);
-	assert.match(read(SDD_WORKFLOW), /\| default\s+\| balanced\s+\| SDD phase fallback; never a Judgment Day role\s+\|/);
 });
 
 test("orchestrator, injected skill, and technical reference defer RDD lifecycle ownership to Gentle AI", () => {
@@ -399,13 +376,12 @@ test("technical reference documents the dynamic runtime authority boundary witho
 });
 
 test("managed contracts retain no fresh lifecycle review directive", () => {
-	const managed = union([...ORCHESTRATOR, SDD_WORKFLOW, WORKER, GENTLE_SKILL, README]);
+	const managed = union([...ORCHESTRATOR, WORKER, GENTLE_SKILL, README]);
 	for (const obsolete of [
 		"A fresh review still follows delegated implementation.",
 		"run a fresh-context review lens unless",
 		"Run a fresh review before pushing a code release",
 	]) assert.ok(!managed.includes(obsolete), `managed contracts retain ${obsolete}`);
-	assert.match(read(SDD_WORKFLOW), /SDD phase validation does not start ordinary review or Judgment Day/);
 });
 
 test("static 4R chain runs each selected lens once and owns no orchestration", () => {

package/tests/review-reminder-receipt.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { consumeReviewMutation, pendingReviewMutation, recordReviewMutation, REVIEW_REMINDER_RECEIPT } from "../lib/review-reminder-receipt.ts";
+import { consumeReviewMutation, pendingReviewMutation, pendingReviewMutationProfiles, recordReviewMutation, REVIEW_REMINDER_RECEIPT } from "../lib/review-reminder-receipt.ts";
 
 function fixture() {
 	let sessionId = "parent";
@@ -60,3 +60,49 @@ test("malformed, unknown-version, and unmatched consumption entries do not estab
 	consumeReviewMutation(f.host, f.session, "/repo", "unknown", "acknowledged", "target");
 	assert.equal(pendingReviewMutation(f.session, "/repo"), captured);
 });
+
+// gentle-pi#1175 (T2): mutation receipts optionally carry the writer profile
+// the runtime resolved, so ASSESS never has to trust a model re-declaration.
+test("mutation receipts validate with or without runtime writer profile fields, never with empty ones", () => {
+	const f = fixture();
+	recordReviewMutation(f.host, f.session, "/repo", { source: "direct", toolName: "write", toolCallId: "plain" });
+	recordReviewMutation(f.host, f.session, "/repo", { source: "direct", toolName: "edit", toolCallId: "profiled", writerModelId: "anthropic/claude-sonnet-5", writerEffort: "high" });
+	recordReviewMutation(f.host, f.session, "/repo", { source: "subagent", taskId: "task-1", toolName: "write", toolCallId: "model-only", writerModelId: "openai/gpt-5-mini" });
+	assert.equal(f.entries.length, 3);
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), [
+		{},
+		{ writerModelId: "anthropic/claude-sonnet-5", writerEffort: "high" },
+		{ writerModelId: "openai/gpt-5-mini" },
+	]);
+	const good = f.entries[1];
+	const data = good.data as Record<string, unknown>;
+	f.entries.length = 0;
+	for (const patch of [{ writerModelId: "" }, { writerEffort: " " }, { writerModelId: 1 }, { writerEffort: null }, { writerModel: "x" }]) {
+		f.entries.push({ ...good, data: { ...data, ...patch } });
+	}
+	assert.equal(pendingReviewMutation(f.session, "/repo"), undefined, "a present-but-empty or malformed profile field invalidates the receipt");
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), []);
+});
+
+test("recording drops unknown or blank profile fields instead of dropping the mutation evidence", () => {
+	const f = fixture();
+	recordReviewMutation(f.host, f.session, "/repo", { source: "direct", toolName: "write", toolCallId: "a", writerModelId: "", writerEffort: undefined });
+	assert.equal(f.entries.length, 1);
+	assert.deepEqual(Object.keys(f.entries[0].data as object).sort(), ["id", "kind", "root", "sessionId", "source", "toolCallId", "toolName"]);
+	assert.ok(pendingReviewMutation(f.session, "/repo"));
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), [{}]);
+});
+
+test("pending writer profiles follow the same consumption watermark as pendingReviewMutation", () => {
+	const f = fixture();
+	recordReviewMutation(f.host, f.session, "/repo", { source: "direct", toolName: "write", toolCallId: "a", writerModelId: "gpt-5-mini" });
+	const captured = pendingReviewMutation(f.session, "/repo");
+	recordReviewMutation(f.host, f.session, "/repo", { source: "direct", toolName: "write", toolCallId: "b", writerModelId: "claude-sonnet-5", writerEffort: "high" });
+	consumeReviewMutation(f.host, f.session, "/repo", captured, "acknowledged", "target");
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), [{ writerModelId: "claude-sonnet-5", writerEffort: "high" }]);
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/sibling"), []);
+	consumeReviewMutation(f.host, f.session, "/repo", pendingReviewMutation(f.session, "/repo"), "nudged", "target");
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), []);
+	f.switchSession("other");
+	assert.deepEqual(pendingReviewMutationProfiles(f.session, "/repo"), []);
+});