gentle-pi 2.6.1 → 2.6.2

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

@@ -19,6 +19,7 @@ const JD_SKILL = "skills/judgment-day/SKILL.md";
 const JD_PROMPTS = "skills/judgment-day/references/prompts-and-formats.md";
 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 RELEASE_SKILL = "skills/release/SKILL.md";
@@ -132,7 +133,8 @@ test("canonical contract defines compact risk, causal admission, correction, CAS
 		/untrusted repository content.*malformed inputs.*stale authority.*path drift.*external callers/i,
 		...JUDGMENT_DAY_DISCOVERY_PATTERNS,
 	]);
-	assert.match(read(README), /Review outcomes and receipt state are informational; commit, push, pull-request, and release delivery follow ordinary repository policy\./);
+	assert.match(read(TECHNICAL_REFERENCE), /Review outcomes and receipt state are informational; commit, push, pull-request, and release delivery follow ordinary repository policy\./);
+	assert.match(read(README), /\]\(docs\/readme-reference\.md(?:#[^)]+)?\)/);
 	assert.doesNotMatch(read(README), /one one-shot authorization for the exact command/i);
 	assert.doesNotMatch(read(README), /review-publication-gate/i);
 });
@@ -365,14 +367,14 @@ test("Judgment Day fix routing has one canonical shape and never falls back to g
 	assert.match(read(SDD_WORKFLOW), /\| default\s+\| balanced\s+\| SDD phase fallback; never a Judgment Day role\s+\|/);
 });
 
-test("orchestrator, injected skill, and README defer RDD lifecycle ownership to Gentle AI", () => {
+test("orchestrator, injected skill, and technical reference defer RDD lifecycle ownership to Gentle AI", () => {
 	const boundary = "This package injects the mirrored provider-bundle review execution contract into this session's system prompt at start; Gentle AI writes nothing into the Pi system prompt, and this package owns everything else here. Absent that mirrored contract, this package invents no lifecycle instructions.";
 	const orchestrator = union(ORCHESTRATOR);
 	assert.ok(orchestrator.includes(boundary), "orchestrator must carry the sole static ownership boundary");
 
 	for (const [label, content] of [
 		[GENTLE_SKILL, read(GENTLE_SKILL)],
-		[README, read(README)],
+		[TECHNICAL_REFERENCE, read(TECHNICAL_REFERENCE)],
 	] as const) {
 		assertMatches(label, content, [
 			/Gentle AI dynamically supplies runtime-specific RDD instructions/i,
@@ -388,8 +390,8 @@ test("orchestrator, injected skill, and README defer RDD lifecycle ownership to
 	}
 });
 
-test("README documents the dynamic runtime authority boundary without an old package route", () => {
-	const content = read(README);
+test("technical reference documents the dynamic runtime authority boundary without an old package route", () => {
+	const content = read(TECHNICAL_REFERENCE);
 	assert.match(content, /Gentle AI dynamically supplies runtime-specific RDD instructions/i);
 	assert.match(content, /does not define an RDD lifecycle/i);
 	assert.doesNotMatch(content, /New ordinary review uses compact `gentle_review` `start -> finalize -> validate`\./);

package/tests/sdd-managed-runtime-settlement.test.ts

@@ -185,9 +185,11 @@ test("history pruning retains admitted unsettled and uncertain task payloads", a
 	const dir = await mkdtemp(join(tmpdir(), "remediation-history-")); t.after(() => rm(dir, { recursive: true, force: true }));
 	await saveTask(dir, { id: "retained", agent: "sdd-remediate", status: "failed", createdAt: 1, sddRemediation: { token: "opaque", settlementUncertain: true, settle: { requestId: "exact" } } } as unknown as TaskRecord, emptyThread());
 	for (const state of ["blocked", "complete"] as const) await saveTask(dir, { id: state, agent: "sdd-remediate", status: "failed", createdAt: 2, sddRemediation: { acquireResult: { state } } } as unknown as TaskRecord, emptyThread());
+	await saveTask(dir, { id: "settled-blocked", agent: "sdd-remediate", status: "failed", createdAt: 3, sddRemediation: { settlement: { state: "blocked", reason: "maintainer_decision" } } } as unknown as TaskRecord, emptyThread());
 	await pruneHistory(dir, 0);
 	const stored = await loadHistory(dir);
 	assert.equal(stored.length, 1); assert.equal(stored[0].task.sddRemediation.settle.requestId, "exact");
+	assert.ok(!stored.some(entry => entry.task.id === "settled-blocked"), "a known blocked settlement is prunable like any terminal task");
 });
 
 
@@ -214,6 +216,41 @@ test("native refusal or uncertain settlement is not a completed managed correcti
 	assert.equal(task.status, "failed");
 	assert.match(task.error, /settlement/);
 });
+test("a received blocked settlement names the block; a lost settlement reply retains unresolved history", async () => {
+	const known = await admissionFixture({ sddAttemptSettle: async () => ({ state: "blocked", reason: "maintainer_decision" }) });
+	known.task.status = "completed";
+	await known.admitted.finalizeRemediation(known.task, { spawned: true, exited: true, cleanupConfirmed: true });
+	assert.equal(known.task.status, "failed");
+	assert.match(known.task.error, /blocked\(maintainer_decision\)/);
+	assert.doesNotMatch(known.task.error, /unresolved/);
+	assert.equal(remediationUnresolved(known.task), false);
+
+	const unspecified = await admissionFixture({ sddAttemptSettle: async () => ({ state: "blocked" }) });
+	unspecified.task.status = "completed";
+	await unspecified.admitted.finalizeRemediation(unspecified.task, { spawned: true, exited: true, cleanupConfirmed: true });
+	assert.equal(unspecified.task.status, "failed");
+	assert.match(unspecified.task.error, /blocked\(unspecified\)/, "a settlement without a reason is distinguishable from one whose reason is literally blocked");
+	assert.doesNotMatch(unspecified.task.error, /unresolved/);
+
+	let attempts = 0;
+	const uncertain = await admissionFixture({ sddAttemptSettle: async () => { attempts++; throw new Error("lost reply"); } });
+	uncertain.task.status = "completed";
+	await uncertain.admitted.finalizeRemediation(uncertain.task, { spawned: true, exited: true, cleanupConfirmed: true });
+	assert.equal(attempts, 2);
+	assert.equal(uncertain.task.status, "failed");
+	assert.match(uncertain.task.error, /unresolved/);
+	assert.equal(remediationUnresolved(uncertain.task), true);
+});
+test("remediationUnresolved treats a received settlement as terminal, regardless of state, unless uncertain", () => {
+	// A terminal acquire result keeps the final branch false, so the token and
+	// actor-claim assertions below discriminate on those fields alone.
+	const base = { acquire: {}, acquireResult: { state: "complete" } } as unknown as TaskRecord["sddRemediation"];
+	assert.equal(remediationUnresolved({ sddRemediation: { ...base } } as unknown as TaskRecord), false);
+	assert.equal(remediationUnresolved({ sddRemediation: { ...base, settlement: { state: "blocked", reason: "maintainer_decision" } } } as unknown as TaskRecord), false);
+	assert.equal(remediationUnresolved({ sddRemediation: { ...base, settlement: { state: "blocked", reason: "maintainer_decision" }, settlementUncertain: true } } as unknown as TaskRecord), true);
+	assert.equal(remediationUnresolved({ sddRemediation: { ...base, actorClaimed: true } } as unknown as TaskRecord), true);
+	assert.equal(remediationUnresolved({ sddRemediation: { ...base, token: "retained" } } as unknown as TaskRecord), true);
+});
 
 
 test("remediation actor preserves separately authorized memory artifact tools", async () => {

package/tests/sdd-selection-transport.test.ts

@@ -218,6 +218,63 @@ test("selected native v2 failures fail closed without consulting the local resol
 	);
 });
 
+function nativeStartup(
+	serialized: unknown,
+	cwd: string,
+	agentName: string,
+	native: { sddStatus: (request: unknown) => Promise<unknown> },
+) {
+	return (__testing as unknown as {
+		resolveSelectedNativeSddChangeStartup(
+			serialized: unknown, cwd: string, agentName: string,
+			native: { sddStatus?: (request: unknown) => Promise<unknown> },
+		): Promise<{ selection: { changeName: string; workspaceRoot: string; phase: string }; status: NativeSddStatusV2 }>;
+	}).resolveSelectedNativeSddChangeStartup(serialized, cwd, agentName, native);
+}
+
+function verifyRefreshAuthority(root: string, blockedReasons: readonly string[]) {
+	return {
+		schemaName: "gentle-ai.sdd-status", schemaVersion: 2, changeName: "alpha", artifactStore: "openspec",
+		planningHome: { mode: "repo-local", path: join(root, "openspec") }, changeRoot: join(root, "openspec/changes/alpha"),
+		actionContext: { mode: "repo-local", workspaceRoot: root, allowedEditRoots: [root] },
+		dependencies: { proposal: "all_done", specs: "all_done", design: "all_done", tasks: "all_done", apply: "all_done", verify: "ready", archive: "blocked" },
+		phaseInstructions: { apply: ["done"], verify: ["rerun SDD verification"], remediate: ["failed evidence"], archive: ["blocked"] },
+		blockedReasons: [...blockedReasons], nextRecommended: "verify",
+	};
+}
+
+test("a native verify evidence-refresh route starts under its own blocker while every other phase stays closed", async (t) => {
+	const root = workspace(t);
+	const refreshReason = "failed verification evidence is incomplete; rerun SDD verification";
+	const authority = verifyRefreshAuthority(root, [refreshReason]);
+	const startup = await nativeStartup(
+		JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "verify" }),
+		root,
+		"sdd-verify",
+		{ sddStatus: async () => authority },
+	);
+	assert.deepEqual(startup.selection, { changeName: "alpha", workspaceRoot: root, phase: "verify" });
+	assert.equal(startup.status, authority, "the validated native status is injected whole, blockers included");
+	assert.deepEqual(startup.status.blockedReasons, [refreshReason], "the blocking reason is preserved for reporting");
+
+	for (const phase of ["apply", "archive"] as const) {
+		const gated = {
+			...verifyRefreshAuthority(root, [refreshReason]),
+			nextRecommended: phase,
+			dependencies: { ...authority.dependencies, [phase]: "ready", verify: "all_done" },
+		};
+		await assert.rejects(
+			() => nativeStartup(
+				JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase }),
+				root,
+				`sdd-${phase}`,
+				{ sddStatus: async () => gated },
+			),
+			/native status blocks phase/i,
+		);
+	}
+});
+
 test("a throwing SDD selection flag reader fails closed without resolving an unselected status", (t) => {
 	const root = workspace(t);
 	assert.equal(__testing.readSddChangeFlag({ getFlag: () => false } as never), undefined);

package/tests/skill-collision-prefixes.test.ts

@@ -33,8 +33,8 @@ for (const [dir, expectedName] of Object.entries(PREFIXED_NAMES)) {
 	});
 }
 
-test("README documents legacy skill-name compatibility aliases", () => {
-	const readme = readFileSync(join(repoRoot, "README.md"), "utf8");
+test("technical reference documents legacy skill-name compatibility aliases", () => {
+	const readme = readFileSync(join(repoRoot, "docs", "readme-reference.md"), "utf8");
 	for (const [legacyName, prefixedName] of [
 		["branch-pr", "gentle-ai-branch-pr"],
 		["judgment-day", "gentle-ai-judgment-day"],