gentle-pi 2.2.0 → 2.4.0

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

@@ -67,6 +67,7 @@ const requiredToolsByAgent: Record<string, string[]> = {
 	"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"],
@@ -122,6 +123,41 @@ test("generic non-SDD agents declare exact role tool allowlists", () => {
 	}
 });
 
+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/);
+});
+
 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

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);
+	}
+});

package/tests/sdd-status.test.ts

@@ -92,69 +92,24 @@ test("resolveSddStatus selects the only active change and counts task progress",
 	assert.match(status.instructions?.apply.join("\n") ?? "", /persisted task checkboxes/);
 });
 
-test("resolveSddStatus keeps planning-only changes read-only and blocks only an expected invalid review authority", async () => {
+test("resolveSddStatus routes completed implementation through archive without RDD authority", async () => {
 	const cwd = await workspace();
 	const root = seedChange(cwd);
 	write(join(root, "tasks.md"), "# Tasks\n\n- [x] 1.1 Done\n");
 	write(join(root, "verify-report.md"), "# Verify\n\nPASS\n");
 	write(join(root, "sync-report.md"), "# Sync\n\nPASS\n");
-	let resolverCalls = 0;
-	const planning = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: {
-			expected: false,
-			resolve: () => {
-				resolverCalls += 1;
-				return { activeAuthorityId: "must-not-run" };
-			},
-		},
-	});
-	assert.equal(resolverCalls, 0);
-	assert.equal(planning.blockedReasons.some((reason) => reason.startsWith("resolve-review:")), false);
-
-	const invalid = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: {
-			expected: true,
-			resolve: () => {
-				throw new Error("stale compact successor");
-			},
-		},
-	});
-	assert.equal(invalid.applyState, "blocked");
-	assert.equal(invalid.dependencies.archive, "blocked");
-	assert.equal(invalid.nextRecommended, "resolve-review");
-	assert.match(invalid.blockedReasons.join("\n"), /^resolve-review: stale compact successor/m);
 
-	const valid = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: {
-			expected: true,
-			resolve: () => ({ activeAuthorityId: "validated-compact-authority" }),
-		},
-	});
-	assert.equal(valid.applyState, "all_done");
-	assert.equal(valid.dependencies.archive, "ready");
-	assert.equal(valid.blockedReasons.some((reason) => reason.startsWith("resolve-review:")), false);
-});
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
 
-test("resolveSddStatus blocks an expected missing native bound readiness without inferring approval", async () => {
-	const cwd = await workspace();
-	seedChange(cwd);
-	const status = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		nativeReviewReadiness: { expected: true, ready: false, reason: "binding is missing" },
-	});
-	assert.equal(status.applyState, "blocked");
-	assert.equal(status.nextRecommended, "resolve-review");
-	assert.deepEqual(status.blockedReasons, ["resolve-review: binding is missing"]);
+	assert.equal(status.applyState, "all_done");
+	assert.equal(status.dependencies.verify, "all_done");
+	assert.equal(status.dependencies.sync, "all_done");
+	assert.equal(status.dependencies.archive, "ready");
+	assert.equal(status.nextRecommended, "sdd-archive");
+	assert.equal(status.blockedReasons.some((reason) => reason.startsWith("resolve-review:")), false);
 });
 
-test("resolveSddStatus routes completed implementation to parent lifecycle and separates parent actions", async () => {
+test("resolveSddStatus ignores legacy parent review actions after implementation", async () => {
 	const cwd = await workspace();
 	const root = seedChange(cwd);
 	write(
@@ -174,8 +129,8 @@ test("resolveSddStatus routes completed implementation to parent lifecycle and s
 	assert.deepEqual(status.taskArtifactErrors, []);
 	assert.equal(status.applyState, "all_done");
 	assert.equal(status.dependencies.apply, "all_done");
-	assert.equal(status.nextRecommended, "parent-lifecycle");
-	assert.match(status.instructions?.apply.join("\n") ?? "", /Deferred parent lifecycle actions/);
+	assert.equal(status.dependencies.verify, "ready");
+	assert.equal(status.nextRecommended, "sdd-verify");
 });
 
 test("resolveSddStatus treats malformed ownership as unresolved implementation work", async () => {
@@ -197,7 +152,7 @@ test("resolveSddStatus treats malformed ownership as unresolved implementation w
 	assert.match(status.blockedReasons.join("\n"), /task ownership marker/i);
 });
 
-test("resolveSddStatus routes completed legacy implementation to parent lifecycle", async () => {
+test("resolveSddStatus routes completed legacy implementation directly to verify", async () => {
 	const cwd = await workspace();
 	const root = seedChange(cwd);
 	write(join(root, "tasks.md"), "# Tasks\n\n- [x] 1.1 Build foundation\n");
@@ -206,7 +161,8 @@ test("resolveSddStatus routes completed legacy implementation to parent lifecycl
 
 	assert.equal(status.applyState, "all_done");
 	assert.equal(status.dependencies.apply, "all_done");
-	assert.equal(status.nextRecommended, "parent-lifecycle");
+	assert.equal(status.dependencies.verify, "ready");
+	assert.equal(status.nextRecommended, "sdd-verify");
 });
 
 test("resolveSddStatus blocks sync when verify report is not clearly passing", async () => {
@@ -215,11 +171,7 @@ test("resolveSddStatus blocks sync when verify report is not clearly passing", a
 	write(join(root, "apply-progress.md"), "# Apply\n\nSome work completed.\n");
 	write(join(root, "verify-report.md"), "# Verify\n\nTODO: tests not run yet\n");
 
-	const status = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: { expected: true, resolve: () => ({ activeAuthorityId: "approved" }) },
-	});
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
 
 	assert.equal(status.dependencies.verify, "ready");
 	assert.equal(status.dependencies.sync, "blocked");
@@ -233,11 +185,7 @@ test("resolveSddStatus rejects negated pass and sync-complete phrases", async ()
 	write(join(root, "verify-report.md"), "# Verify\n\nStatus: not passed\n");
 	write(join(root, "sync-report.md"), "# Sync\n\nSync complete: no\n");
 
-	const status = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: { expected: true, resolve: () => ({ activeAuthorityId: "approved" }) },
-	});
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
 
 	assert.equal(status.dependencies.verify, "ready");
 	assert.equal(status.dependencies.sync, "blocked");
@@ -334,11 +282,7 @@ test("resolveSddStatus blocks stale sync report when current verify is not passi
 	write(join(root, "verify-report.md"), "# Verify\n\nStatus: not passed\n");
 	write(join(root, "sync-report.md"), "# Sync\n\nPASS\n");
 
-	const status = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: { expected: true, resolve: () => ({ activeAuthorityId: "approved" }) },
-	});
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
 
 	assert.equal(status.dependencies.verify, "ready");
 	assert.equal(status.dependencies.sync, "blocked");
@@ -381,11 +325,7 @@ test("resolveSddStatus marks archive ready only after clean verify, sync, and co
 	write(join(root, "verify-report.md"), "# Verify\n\nPASS\n");
 	write(join(root, "sync-report.md"), "# Sync\n\nPASS\n");
 
-	const status = resolveSddStatus({
-		cwd,
-		changeName: "add-auth",
-		reviewAuthority: { expected: true, resolve: () => ({ activeAuthorityId: "approved" }) },
-	});
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
 
 	assert.equal(status.dependencies.archive, "ready");
 	assert.equal(status.nextRecommended, "sdd-archive");
@@ -428,13 +368,13 @@ test("resolveSddStatus with artifactStore none returns non-authoritative status
 	assert.equal(status.nextRecommended, "resolve-via-engram");
 });
 
-test("resolveSddStatus with artifactStore both uses disk scan and reflects store", async () => {
+test("resolveSddStatus with artifactStore hybrid uses disk scan and reflects store", async () => {
 	const cwd = await workspace();
 	seedChange(cwd);
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "add-auth" });
 
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.equal(status.changeName, "add-auth");
 	assert.notEqual(status.nextRecommended, "resolve-via-engram");
 });
@@ -484,13 +424,13 @@ test("parseSddStatusCommandArgs extracts change and json flag", () => {
 	});
 });
 
-test("resolveSddStatus with artifactStore both and NO openspec dir returns non-authoritative status", async () => {
+test("resolveSddStatus with artifactStore hybrid and NO openspec dir returns non-authoritative status", async () => {
 	const cwd = await workspace();
-	// No openspec directory — both store without disk backing is non-authoritative
+	// No openspec directory — the hybrid store without disk backing is non-authoritative
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "my-change" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "my-change" });
 
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.equal(status.changeName, "my-change");
 	assert.deepEqual(status.blockedReasons, []);
 	assert.equal(status.nextRecommended, "resolve-via-engram");
@@ -499,13 +439,13 @@ test("resolveSddStatus with artifactStore both and NO openspec dir returns non-a
 	assert.equal(status.dependencies.archive, "not_applicable");
 });
 
-test("resolveSddStatus with artifactStore both and existing openspec dir runs authoritative disk scan", async () => {
+test("resolveSddStatus with artifactStore hybrid and existing openspec dir runs authoritative disk scan", async () => {
 	const cwd = await workspace();
 	seedChange(cwd);
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "add-auth" });
 
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.equal(status.changeName, "add-auth");
 	assert.notEqual(status.nextRecommended, "resolve-via-engram");
 	assert.equal(status.artifacts.proposal, "done");
@@ -526,13 +466,13 @@ test("isNonAuthoritativeStatus reads typed isNonAuthoritative field and matches
 	assert.equal(isNonAuthoritativeStatus(none), true);
 	assert.equal(none.nextRecommended, "resolve-via-engram");
 
-	const bothWithoutOpenspec = resolveSddStatus({ cwd, artifactStore: "both", changeName: "x" });
+	const bothWithoutOpenspec = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "x" });
 	assert.equal(bothWithoutOpenspec.isNonAuthoritative, true);
 	assert.equal(isNonAuthoritativeStatus(bothWithoutOpenspec), true);
 	assert.equal(bothWithoutOpenspec.nextRecommended, "resolve-via-engram");
 
 	seedChange(cwd);
-	const bothWithOpenspec = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	const bothWithOpenspec = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "add-auth" });
 	assert.equal(bothWithOpenspec.isNonAuthoritative, false);
 	assert.equal(isNonAuthoritativeStatus(bothWithOpenspec), false);
 	assert.notEqual(bothWithOpenspec.nextRecommended, "resolve-via-engram");
@@ -551,12 +491,12 @@ test("isNonAuthoritative boolean field is set correctly across all store/disk co
 	assert.equal(none.isNonAuthoritative, true);
 
 	// both without openspec/ → non-authoritative
-	const bothWithout = resolveSddStatus({ cwd, artifactStore: "both", changeName: "x" });
+	const bothWithout = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "x" });
 	assert.equal(bothWithout.isNonAuthoritative, true);
 
 	// both WITH openspec/ and seeded change → authoritative
 	seedChange(cwd);
-	const bothWith = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	const bothWith = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "add-auth" });
 	assert.equal(bothWith.isNonAuthoritative, false);
 
 	// openspec (default disk scan, seeded) → authoritative
@@ -565,30 +505,30 @@ test("isNonAuthoritative boolean field is set correctly across all store/disk co
 });
 
 // Fix 4 item 1 — both + openspec/ dir present + change NOT on disk → non-authoritative
-test("resolveSddStatus with artifactStore both, openspec dir present but change not on disk returns non-authoritative", async () => {
+test("resolveSddStatus with artifactStore hybrid, openspec dir present but change not on disk returns non-authoritative", async () => {
 	const cwd = await workspace();
 	// Create an openspec/changes dir with a different change — not the requested one
 	mkdirSync(join(cwd, "openspec", "changes", "other-change"), { recursive: true });
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "missing-change" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "missing-change" });
 
 	assert.equal(status.isNonAuthoritative, true);
 	assert.equal(status.nextRecommended, "resolve-via-engram");
 	assert.deepEqual(status.blockedReasons, []);
 	assert.equal(status.applyState, "not_applicable");
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	// Must NOT be treated as blocked
 	assert.notEqual(status.applyState, "blocked");
 });
 
 // Fix 4 item 2 — strengthen existing both-with-openspec-and-seeded-change test
-test("resolveSddStatus with artifactStore both, openspec dir present and change on disk is authoritative", async () => {
+test("resolveSddStatus with artifactStore hybrid, openspec dir present and change on disk is authoritative", async () => {
 	const cwd = await workspace();
 	seedChange(cwd);
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "add-auth" });
 
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.equal(status.changeName, "add-auth");
 	// Must be authoritative
 	assert.equal(isNonAuthoritativeStatus(status), false);
@@ -618,7 +558,7 @@ test("renderSddDispatcherMarkdown for both-without-openspec does NOT render Read
 	const cwd = await workspace();
 	// No openspec directory — both store is non-authoritative
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "fix-x" });
 	const markdown = renderSddDispatcherMarkdown(status);
 
 	assert.doesNotMatch(markdown, /### Ready/);
@@ -628,7 +568,7 @@ test("renderSddDispatcherMarkdown for both-without-openspec does NOT render Read
 test("renderNativeSddPhasePrompt for both-without-openspec emits non-authoritative line", async () => {
 	const cwd = await workspace();
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "fix-x" });
 	const prompt = renderNativeSddPhasePrompt(status, "apply");
 
 	assert.match(prompt, /non-authoritative/);
@@ -646,17 +586,17 @@ test("renderPhaseInstructions for not_applicable applyState emits neutral line",
 });
 
 // Fix 4 item 1 — both + openspec/ + ZERO changes + no changeName → non-authoritative
-test("resolveSddStatus both + openspec/ dir + zero active changes + no changeName returns non-authoritative", async () => {
+test("resolveSddStatus hybrid + openspec/ dir + zero active changes + no changeName returns non-authoritative", async () => {
 	const cwd = await workspace();
 	// openspec/ dir exists but holds no active changes (only the changes/ subdir)
 	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid" });
 
 	assert.equal(status.isNonAuthoritative, true);
 	assert.equal(status.nextRecommended, "resolve-via-engram");
 	assert.deepEqual(status.blockedReasons, []);
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.equal(status.applyState, "not_applicable");
 	assert.equal(status.dependencies.apply, "not_applicable");
 	assert.equal(status.dependencies.archive, "not_applicable");
@@ -665,12 +605,12 @@ test("resolveSddStatus both + openspec/ dir + zero active changes + no changeNam
 });
 
 // Fix 4 item 2 — both + openspec/ + MULTIPLE changes + no changeName → authoritative select-change
-test("resolveSddStatus both + openspec/ dir + multiple active changes + no changeName stays authoritative", async () => {
+test("resolveSddStatus hybrid + openspec/ dir + multiple active changes + no changeName stays authoritative", async () => {
 	const cwd = await workspace();
 	mkdirSync(join(cwd, "openspec", "changes", "alpha"), { recursive: true });
 	mkdirSync(join(cwd, "openspec", "changes", "beta"), { recursive: true });
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid" });
 
 	// Authoritative ambiguous-selection behavior must be preserved
 	assert.equal(status.isNonAuthoritative, false);
@@ -679,16 +619,16 @@ test("resolveSddStatus both + openspec/ dir + multiple active changes + no chang
 });
 
 // Fix 4 item 3 — both + openspec/ + ONE resolvable change → authoritative
-test("resolveSddStatus both + openspec/ dir + exactly one active change is authoritative", async () => {
+test("resolveSddStatus hybrid + openspec/ dir + exactly one active change is authoritative", async () => {
 	const cwd = await workspace();
 	seedChange(cwd);
 
 	// No changeName supplied — should auto-select the single change
-	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid" });
 
 	assert.equal(status.isNonAuthoritative, false);
 	assert.equal(status.changeName, "add-auth");
-	assert.equal(status.artifactStore, "both");
+	assert.equal(status.artifactStore, "hybrid");
 	assert.notEqual(status.applyState, "not_applicable");
 	assert.notEqual(status.nextRecommended, "resolve-via-engram");
 	assert.equal(status.artifacts.proposal, "done");
@@ -719,14 +659,73 @@ test("resolveSddStatus openspec + named change missing still blocks", async () =
 	assert.notEqual(status.nextRecommended, "resolve-via-engram");
 });
 
+// Issue #535 — post-archive status exposes explicit completion and the archived artifact location
+test("resolveSddStatus projects archived terminal state when the change lives in the archive", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+	write(
+		join(cwd, "openspec", "changes", "archive", "2026-01-02-add-auth", "proposal.md"),
+		"# Proposal\n",
+	);
+
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
+
+	assert.equal(status.changeName, "add-auth");
+	assert.equal(status.nextRecommended, "archived");
+	assert.deepEqual(status.archived, {
+		path: join("openspec", "changes", "archive", "2026-01-02-add-auth"),
+	});
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.dependencies.archive, "all_done");
+	assert.doesNotMatch(status.nextRecommended, /sdd-new|Start an SDD change|not found/i);
+});
+
+test("resolveSddStatus archived projection prefers the newest archive date", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "archive", "2026-01-01-add-auth"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "archive", "2026-03-04-add-auth"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, changeName: "add-auth" });
+
+	assert.equal(status.nextRecommended, "archived");
+	assert.deepEqual(status.archived, {
+		path: join("openspec", "changes", "archive", "2026-03-04-add-auth"),
+	});
+});
+
+test("resolveSddStatus still blocks a change that never existed and has no archive entry", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "archive", "2026-01-01-unrelated"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, changeName: "ghost" });
+
+	assert.equal(status.archived, undefined);
+	assert.match(status.blockedReasons.join("\n"), /Active change not found/);
+	assert.notEqual(status.nextRecommended, "archived");
+});
+
+test("resolveSddStatus archive matching requires the exact change-name suffix", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "archive", "2026-01-01-foo-bar-baz"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, changeName: "foo-bar" });
+
+	assert.equal(status.archived, undefined);
+	assert.match(status.blockedReasons.join("\n"), /Active change not found/);
+	assert.notEqual(status.nextRecommended, "archived");
+});
+
 // Fix 4 render test — non-authoritative both status → dispatcher shows "both" not "Engram or none"
 test("renderSddDispatcherMarkdown for non-authoritative both status shows artifact store 'both'", async () => {
 	const cwd = await workspace();
 
-	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const status = resolveSddStatus({ cwd, artifactStore: "hybrid", changeName: "fix-x" });
 	const markdown = renderSddDispatcherMarkdown(status);
 
-	assert.match(markdown, /artifact store: both/);
+	assert.match(markdown, /artifact store: hybrid/);
 	assert.doesNotMatch(markdown, /Engram or none/);
 	assert.match(markdown, /resolve via Engram/i);
 });

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

@@ -14,21 +14,18 @@ function readSkillName(dir: string): string | undefined {
 const PREFIXED_NAMES: Record<string, string> = {
 	"branch-pr": "gentle-ai-branch-pr",
 	"chained-pr": "gentle-ai-chained-pr",
+	"cognitive-doc-design": "gentle-ai-cognitive-doc-design",
+	"comment-writer": "gentle-ai-comment-writer",
 	"issue-creation": "gentle-ai-issue-creation",
 	"judgment-day": "gentle-ai-judgment-day",
 	"rdd-defect-workflow": "gentle-ai-rdd-defect-workflow",
 	"skill-creator": "gentle-ai-skill-creator",
 	"skill-improver": "gentle-ai-skill-improver",
+	"skill-registry": "gentle-ai-skill-registry",
+	"work-unit-commits": "gentle-ai-work-unit-commits",
 };
 
-const UNPREFIXED_DIRS = [
-	"skill-registry",
-	"release",
-	"work-unit-commits",
-	"gentle-ai",
-	"comment-writer",
-	"cognitive-doc-design",
-];
+const UNPREFIXED_DIRS = ["gentle-ai", "release"];
 
 for (const [dir, expectedName] of Object.entries(PREFIXED_NAMES)) {
 	test(`skills/${dir}/SKILL.md frontmatter name is prefixed`, () => {