gentle-pi 2.1.2 → 2.3.0

package/tests/sdd-agent-tools.test.ts

@@ -5,7 +5,6 @@ import test from "node:test";
 
 const repoRoot = process.cwd();
 const assetsAgentsDir = join(repoRoot, "assets", "agents");
-const REVIEW_REFUTER_TOOLS = ["read", "grep", "find"];
 const GENERIC_ROLE_TOOLS: Record<string, string[]> = {
 	"gentle-ai-explore.md": ["read", "grep", "find", "codegraph"],
 	"gentle-ai-worker.md": ["read", "grep", "find", "edit", "write", "bash", "mem_save"],
@@ -61,18 +60,19 @@ function assertGenericRoleBody(fileName: string, source: string): void {
 }
 
 const requiredToolsByAgent: Record<string, string[]> = {
-	"sdd-apply.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-archive.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-design.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-explore.md": ["read", "grep", "glob", "edit", "write", "mem_save"],
-	"sdd-init.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-onboard.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-proposal.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-spec.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-status.md": ["read", "grep", "glob", "bash", "mem_search", "mem_get_observation"],
-	"sdd-sync.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-tasks.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-verify.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-apply.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-archive.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-design.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-explore.md": ["read", "grep", "find", "edit", "write", "mem_save"],
+	"sdd-init.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-onboard.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-proposal.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-research.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-spec.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-status.md": ["read", "grep", "find", "bash", "mem_search", "mem_get_observation"],
+	"sdd-sync.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-tasks.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-verify.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
 };
 
 test("SDD package agents declare role-appropriate tools as YAML arrays", () => {
@@ -123,25 +123,46 @@ test("generic non-SDD agents declare exact role tool allowlists", () => {
 	}
 });
 
-test("review-refuter exposes only complete-list inspection tools", () => {
-	const path = join(assetsAgentsDir, "review-refuter.md");
-	assert.ok(existsSync(path), "review-refuter.md must exist");
-	const entries = readTools(path);
-	assert.equal(entries[0], '"*": false', "review-refuter must lead with the deny-all rule");
-	assert.deepEqual(entries.slice(1), REVIEW_REFUTER_TOOLS);
+test("sdd-verify phase text carries the verify-result envelope and validate-before-persist rule", () => {
+	// gentle-pi#535 row 5: the phase must produce a natively admissible report
+	// on its first persistence attempt without hunting the format elsewhere.
+	const envelopeFields = [
+		"schema: gentle-ai.verify-result/v1",
+		"evidence_revision: sha256:",
+		"verdict:",
+		"blockers:",
+		"critical_findings:",
+		"requirements:",
+		"scenarios:",
+		"test_command:",
+		"test_exit_code:",
+		"test_output_hash: sha256:",
+		"build_command:",
+		"build_exit_code:",
+		"build_output_hash: sha256:",
+	];
+
+	const agentSource = readFileSync(join(assetsAgentsDir, "sdd-verify.md"), "utf8");
+	assert.match(agentSource, /```yaml\nschema: gentle-ai\.verify-result\/v1\n/);
+	for (const field of envelopeFields) {
+		assert.ok(agentSource.includes(field), `sdd-verify.md envelope must carry \`${field}\``);
+	}
+	assert.match(agentSource, /first non-empty content/);
+	assert.match(
+		agentSource,
+		/gentle-ai sdd-verify-validate --input <path\|-> --requirements <n> --scenarios <n>/,
+	);
+
+	const chainSource = readFileSync(join(repoRoot, "assets", "chains", "sdd-verify.chain.md"), "utf8");
+	assert.match(chainSource, /gentle-ai\.verify-result\/v1/);
+	assert.match(chainSource, /sdd-verify-validate/);
+});
 
-	const frontmatter = readFrontmatter(path);
-	assert.match(frontmatter, /^name:\s*review-refuter$/m);
-	for (const forbidden of [
-		"bash",
-		"edit",
-		"write",
-		"task",
-		"subagent",
-		"subagent_run",
-		"mem_save",
-		"mem_update",
-	]) {
-		assert.doesNotMatch(frontmatter, new RegExp(`^  - ${forbidden}$`, "m"));
+test("the retired Pi adversarial role agents are not packaged", () => {
+	// gentle-pi#311 P5: the refuter and targeted validator verdicts execute
+	// through Go-owned pi processes via provider-rendered self-contained
+	// vectors; no Pi agent definition may reintroduce a Pi-authored verdict.
+	for (const retired of ["review-refuter.md", "review-validator.md"]) {
+		assert.ok(!existsSync(join(assetsAgentsDir, retired)), `${retired} must stay deleted`);
 	}
 });

package/tests/sdd-preflight.test.ts

@@ -13,7 +13,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import {
+	collectSddPreflightPreferences,
+	DEFAULT_SDD_PREFLIGHT,
 	installSddAssets,
+	isSddPreflightTrigger,
 	readSddPreflightFromDisk,
 	sddPreflightDiskPath,
 	writeSddPreflightToDisk,
@@ -27,12 +30,44 @@ async function workspace(): Promise<string> {
 const SAMPLE_PREFS: SddPreflightPreferences = {
 	executionMode: "auto",
 	artifactStore: "engram",
-	chainedPrStrategy: "auto-forecast",
+	chainedPrStrategy: "auto-chain",
 	reviewBudgetLines: 400,
 	engramAvailable: true,
 	prompted: true,
 };
 
+function preflightContext(cwd: string, hasUI: boolean, calls: string[] = [], answers: Record<string, string> = {}) {
+	return { cwd, hasUI, ui: { select: async (title: string) => (calls.push(`select:${title}`), answers[title]), input: async (title: string) => (calls.push(`input:${title}`), answers[title]), notify: () => {} } } as Parameters<typeof collectSddPreflightPreferences>[0];
+}
+function writeRawPreflight(cwd: string, chainedPrStrategy: string, prompted = true): string {
+	const path = sddPreflightDiskPath(cwd); mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true }); writeFileSync(path, JSON.stringify({ executionMode: "auto", artifactStore: "openspec", chainedPrStrategy, reviewBudgetLines: 400, engramAvailable: false, prompted })); return path;
+}
+test("production callers distinguish automatic defaults from explicit preflight prompts", () => {
+	const root = join(import.meta.dirname, ".."), gentleAi = readFileSync(join(root, "extensions", "gentle-ai.ts"), "utf8"), sddInit = readFileSync(join(root, "extensions", "sdd-init.ts"), "utf8");
+	assert.match(gentleAi, /function runSddPreflight\(\s*ctx: ExtensionContext,\s*promptFields: readonly SddPreflightField\[\] = \[\]\s*\)/s); assert.match(gentleAi, /if \(isSddAgent && !getSddPreflightPreferences\(ctx\)\) \{\s*await runSddPreflight\(ctx\);/s); assert.match(gentleAi, /applyModelConfig: async \(\) => applySavedModelConfig\(ctx\)\s*\},\s*\{\s*promptFields\s*\}\s*\);/s); assert.match(gentleAi, /handler: async \(_args, ctx\) => \{\s*await runSddPreflight\(ctx, SDD_PREFLIGHT_FIELDS\);/s); assert.match(sddInit, /applyModelConfig: \(\) => applySavedModelConfig\(ctx\)\s*\},\s*\{\s*promptFields: \[\]\s*\}\s*\);/s);
+});
+test("capability-constrained artifact selector elision", async () => {
+	const calls: string[] = [], prefs = await collectSddPreflightPreferences(preflightContext(await workspace(), true, calls), false, { promptFields: ["artifactStore"] });
+	assert.deepEqual(prefs, DEFAULT_SDD_PREFLIGHT); assert.deepEqual(calls, []);
+});
+test("headless/UI canonical-domain parity", async () => {
+	const calls: string[] = [], ui = await collectSddPreflightPreferences(preflightContext(await workspace(), true, calls), false), headless = await collectSddPreflightPreferences(preflightContext(await workspace(), false), false);
+	assert.deepEqual(ui, DEFAULT_SDD_PREFLIGHT); assert.deepEqual(headless, ui); assert.deepEqual(calls, []);
+});
+test("explicit UI selections override defaults when a field is genuinely unresolved", async () => {
+	const calls: string[] = [], prefs = await collectSddPreflightPreferences(preflightContext(await workspace(), true, calls, { "SDD execution mode": "interactive", "SDD artifact store": "engram", "SDD delivery strategy": "auto-chain", "SDD review budget lines": "700" }), true, { persisted: DEFAULT_SDD_PREFLIGHT, promptFields: ["executionMode", "artifactStore", "chainedPrStrategy", "reviewBudgetLines"] });
+	assert.deepEqual({ executionMode: prefs.executionMode, artifactStore: prefs.artifactStore, chainedPrStrategy: prefs.chainedPrStrategy, reviewBudgetLines: prefs.reviewBudgetLines }, { executionMode: "interactive", artifactStore: "engram", chainedPrStrategy: "auto-chain", reviewBudgetLines: 700 }); assert.equal(prefs.prompted, true); assert.equal(calls.length, 4);
+});
+test("legacy persisted strategies normalize to canonical values", async () => {
+	const mappings = { "auto-forecast": "ask-on-risk", "ask-always": "ask-on-risk", "single-pr-default": "single-pr", "force-chained": "auto-chain" } as const;
+	for (const [legacy, canonical] of Object.entries(mappings)) { const cwd = await workspace(); writeRawPreflight(cwd, legacy); assert.equal(readSddPreflightFromDisk(cwd)?.chainedPrStrategy, canonical); }
+});
+test("exception-ok requires narrow delivery-gate provenance", async () => {
+	for (const prompted of [false, true]) { const cwd = await workspace(); writeRawPreflight(cwd, "exception-ok", prompted); assert.equal(readSddPreflightFromDisk(cwd)?.chainedPrStrategy, "ask-on-risk"); }
+	const accepted = await collectSddPreflightPreferences(preflightContext(await workspace(), false), false, { persisted: { ...DEFAULT_SDD_PREFLIGHT, chainedPrStrategy: "exception-ok" }, acceptSizeException: true }); assert.equal(accepted.chainedPrStrategy, "exception-ok"); assert.equal(accepted.sizeExceptionAccepted, true);
+	const durable = await workspace(); writeSddPreflightToDisk(durable, accepted); assert.equal(readSddPreflightFromDisk(durable)?.chainedPrStrategy, "ask-on-risk");
+});
+
 test("sddPreflightDiskPath returns project-local .pi/gentle-ai/sdd-preflight.json", async () => {
 	const cwd = await workspace();
 	const path = sddPreflightDiskPath(cwd);
@@ -62,18 +97,11 @@ test("readSddPreflightFromDisk returns persisted prefs after write", async () =>
 	assert.deepEqual(loaded, SAMPLE_PREFS);
 });
 
-test("persisted store survives a simulated cache miss (write then cold read)", async () => {
-	const cwd = await workspace();
-
-	// Simulate ensureSddPreflight writing to disk
-	writeSddPreflightToDisk(cwd, SAMPLE_PREFS);
-
-	// Simulate a fresh process where in-memory Map is empty — only disk store exists
-	const loaded = readSddPreflightFromDisk(cwd);
-	assert.ok(loaded !== undefined);
-	assert.equal(loaded.artifactStore, "engram");
-	assert.equal(loaded.executionMode, "auto");
-	assert.equal(loaded.prompted, true);
+test("persisted preferences are reused with zero prompts", async () => {
+	const cwd = await workspace(); writeSddPreflightToDisk(cwd, SAMPLE_PREFS);
+	const loaded = readSddPreflightFromDisk(cwd); assert.ok(loaded);
+	const calls: string[] = [], reused = await collectSddPreflightPreferences(preflightContext(cwd, true, calls), loaded!.engramAvailable, { persisted: loaded });
+	assert.deepEqual(reused, loaded); assert.deepEqual(calls, []);
 });
 
 test("readSddPreflightFromDisk returns undefined for corrupt JSON", async () => {
@@ -95,7 +123,7 @@ test("readSddPreflightFromDisk returns undefined for JSON with invalid fields",
 	assert.equal(readSddPreflightFromDisk(cwd), undefined);
 });
 
-test("readSddPreflightFromDisk normalizes unknown chainedPrStrategy to auto-forecast", async () => {
+test("readSddPreflightFromDisk normalizes unknown chainedPrStrategy to ask-on-risk", async () => {
 	const cwd = await workspace();
 	const path = sddPreflightDiskPath(cwd);
 	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
@@ -110,7 +138,7 @@ test("readSddPreflightFromDisk normalizes unknown chainedPrStrategy to auto-fore
 
 	const loaded = readSddPreflightFromDisk(cwd);
 	assert.ok(loaded !== undefined);
-	assert.equal(loaded.chainedPrStrategy, "auto-forecast");
+	assert.equal(loaded.chainedPrStrategy, "ask-on-risk");
 });
 
 test("writeSddPreflightToDisk is non-fatal when directory is not writable (no throw)", async () => {
@@ -224,3 +252,41 @@ test("forced asset refresh migrates only untouched v0.14 package contracts and p
 		rmSync(temporaryAgentHome, { recursive: true, force: true });
 	}
 });
+
+// gentle-ai calls the dual-store mode "hybrid"; this repo called the same
+// operator-facing choice "both". Two names for one concept is how a caller ends
+// up mapping between them by hand. gentle-ai owns the contract, so "hybrid" is
+// canonical here too — but "both" is already persisted in operator preflight
+// files on disk, so it must keep loading rather than fall back to the default.
+test("a persisted legacy 'both' artifact store loads as hybrid", async () => {
+	const cwd = await mkdtemp(join(tmpdir(), "sdd-preflight-legacy-"));
+	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
+	writeFileSync(
+		sddPreflightDiskPath(cwd),
+		JSON.stringify({ executionMode: "auto", artifactStore: "hybrid", chainedPrStrategy: "ask-on-risk", reviewBudgetLines: 400, engramAvailable: true, prompted: true }),
+	);
+
+	const loaded = readSddPreflightFromDisk(cwd, true);
+	assert.equal(loaded?.artifactStore, "hybrid", "legacy 'both' must normalize to the canonical name, not be discarded");
+});
+
+test("a persisted canonical 'hybrid' artifact store loads unchanged", async () => {
+	const cwd = await mkdtemp(join(tmpdir(), "sdd-preflight-hybrid-"));
+	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
+	writeFileSync(
+		sddPreflightDiskPath(cwd),
+		JSON.stringify({ executionMode: "auto", artifactStore: "hybrid", chainedPrStrategy: "ask-on-risk", reviewBudgetLines: 400, engramAvailable: true, prompted: true }),
+	);
+
+	const loaded = readSddPreflightFromDisk(cwd, true);
+	assert.equal(loaded?.artifactStore, "hybrid");
+});
+
+test("slash SDD preflight trigger accepts the gentle-sdd command prefix", () => {
+	for (const text of ["/gentle-sdd-init", "/gentle-sdd-continue", "/gentle-sdd-status fix-rose --json", "/sdd", "/sdd:plan", "/sdd-plan this change"]) {
+		assert.equal(isSddPreflightTrigger(text), true, text);
+	}
+	for (const text of ["/gentle-sddx", "/gentle:sdd-preflight", "/gentle-status", "gentle-sdd-init"]) {
+		assert.equal(isSddPreflightTrigger(text), false, text);
+	}
+});