gentle-pi 2.1.2 → 2.3.0

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,20 +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`, () => {

package/tests/skill-registry.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, statSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -267,3 +267,52 @@ test("orchestrator documents path injection protocol", () => {
 	assert.match(source, /paths-injected/);
 	assert.doesNotMatch(source, /Use matching compact rules based on code context and task intent/);
 });
+
+test("non-forced regeneration invalidates cache when skill bytes change but path, size, and mtime are restored", async () => {
+	const cwd = join(tmpdir(), `gentle-pi-fingerprint-${Date.now()}`);
+	const skillPath = join(cwd, "skills", "alpha", "SKILL.md");
+	mkdirSync(dirname(skillPath), { recursive: true });
+
+	const contentV1 =
+		'---\nname: alpha\ndescription: "Trigger: alpha skill. Variant one. Body A."\n---\n\n## Rules\n\n- Rule A.\n';
+	const contentV2 =
+		'---\nname: alpha\ndescription: "Trigger: alpha skill. Variant two. Body B."\n---\n\n## Rules\n\n- Rule B.\n';
+	assert.equal(
+		Buffer.byteLength(contentV1),
+		Buffer.byteLength(contentV2),
+		"test fixtures must have identical byte length",
+	);
+
+	const fixedMtimeSeconds = 1_000_000_000;
+	writeFileSync(skillPath, contentV1);
+	utimesSync(skillPath, fixedMtimeSeconds, fixedMtimeSeconds);
+	const beforeStat = statSync(skillPath);
+	const beforeMtimeMs = beforeStat.mtimeMs;
+	const beforeSize = beforeStat.size;
+
+	const first = await __testing.regenerateRegistry(cwd, false);
+	assert.equal(first.regenerated, true, "initial non-forced regeneration writes the registry");
+	assert.equal(first.reason, "fingerprint-changed");
+
+	const registryPath = join(cwd, ".atl", "skill-registry.md");
+	const firstRegistry = readFileSync(registryPath, "utf8");
+	assert.match(firstRegistry, /Variant one\. Body A\./);
+
+	writeFileSync(skillPath, contentV2);
+	utimesSync(skillPath, fixedMtimeSeconds, fixedMtimeSeconds);
+	const midStat = statSync(skillPath);
+	assert.equal(midStat.size, beforeSize, "byte size must be unchanged after rewrite");
+	assert.equal(midStat.mtimeMs, beforeMtimeMs, "mtime must be restored exactly");
+
+	const second = await __testing.regenerateRegistry(cwd, false);
+	assert.equal(
+		second.regenerated,
+		true,
+		"non-forced regeneration must invalidate cache when content bytes changed",
+	);
+	assert.equal(second.reason, "fingerprint-changed");
+
+	const secondRegistry = readFileSync(registryPath, "utf8");
+	assert.match(secondRegistry, /Variant two\. Body B\./);
+	assert.doesNotMatch(secondRegistry, /Variant one\. Body A\./);
+});

package/tests/verify-package-files.test.ts

@@ -4,9 +4,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import {
+	gentleAiVersionPinMismatches,
 	reconcileContractsOnDisk,
 	reconcileGeneratedRuntimeSources,
 } from "../scripts/verify-package-files.mjs";
+import { INSTALLER_VERSION, RELEASE_BASE_URL, GENTLE_AI_WINDOWS_SOURCE_TAG } from "../scripts/gentle-ai-installer.mjs";
+import { GENTLE_AI_VERSION } from "../lib/gentle-ai-binary.ts";
 
 function makeFixtureRoot(): string {
 	return mkdtempSync(join(tmpdir(), "gentle-pi-verify-package-files-"));
@@ -49,6 +52,22 @@ test("contracts/ walk fails on a contractHashes entry that is missing from disk"
 	}
 });
 
+test("contracts/ walk excludes the provider contract mirror subtree, whose bytes are pinned by its own lock", () => {
+	const fixtureRoot = makeFixtureRoot();
+	try {
+		mkdirSync(join(fixtureRoot, "contracts/review-provider-contract-mirror/v1.1.0/bundle"), { recursive: true });
+		writeFileSync(join(fixtureRoot, "contracts/review-provider-contract-mirror/provider-contract.lock.json"), "{}\n");
+		writeFileSync(join(fixtureRoot, "contracts/review-provider-contract-mirror/v1.1.0/bundle/README.md"), "mirror\n");
+
+		const { unlistedOnDisk, listedButMissing } = reconcileContractsOnDisk(fixtureRoot, {});
+
+		assert.deepEqual(unlistedOnDisk, []);
+		assert.deepEqual(listedButMissing, []);
+	} finally {
+		rmSync(fixtureRoot, { recursive: true, force: true });
+	}
+});
+
 test("sources <-> runtime/*.mjs walk fails when a generated runtime file is absent from the generator's sources array", () => {
 	const fixtureRoot = makeFixtureRoot();
 	try {
@@ -91,6 +110,49 @@ test("sources <-> runtime/*.mjs walk fails when a sources entry is absent from r
 	}
 });
 
+// Regression test for the documented incident in scripts/install-gentle-ai.mjs:
+// the installer once reported installing v2.1.11 while writing v2.2.0 to disk
+// because two hardcoded version copies had drifted apart. The textual
+// `.includes(...)` grep this replaces could not have caught this, because it
+// only verifies a string appears in a file, not that two values agree.
+test("Gentle AI version pin mismatch is reported with a specific message when a derived location disagrees with the authoritative constant", () => {
+	const mismatches = gentleAiVersionPinMismatches({
+		installerVersion: "2.2.3",
+		releaseBaseUrl: "https://github.com/Gentleman-Programming/gentle-ai/releases/download/v2.2.3/",
+		windowsSourceTag: "v2.2.3",
+		libGentleAiVersion: "2.2.0",
+	});
+
+	assert.deepEqual(mismatches, [
+		'lib/gentle-ai-binary.ts GENTLE_AI_VERSION ("2.2.0") does not match the authoritative scripts/gentle-ai-installer.mjs INSTALLER_VERSION ("2.2.3")',
+	]);
+});
+
+test("Gentle AI version pin mismatch also flags a drifted release URL and a drifted Windows source tag", () => {
+	const mismatches = gentleAiVersionPinMismatches({
+		installerVersion: "2.2.3",
+		releaseBaseUrl: "https://github.com/Gentleman-Programming/gentle-ai/releases/download/v2.2.0/",
+		windowsSourceTag: "v2.1.11",
+		libGentleAiVersion: "2.2.3",
+	});
+
+	assert.deepEqual(mismatches, [
+		'RELEASE_BASE_URL ("https://github.com/Gentleman-Programming/gentle-ai/releases/download/v2.2.0/") does not pin the authoritative v2.2.3',
+		'GENTLE_AI_WINDOWS_SOURCE_TAG ("v2.1.11") does not match the authoritative v2.2.3',
+	]);
+});
+
+test("Gentle AI version pin agrees across the installer version, the release URL, the Windows source tag, and lib/gentle-ai-binary.ts", () => {
+	const mismatches = gentleAiVersionPinMismatches({
+		installerVersion: INSTALLER_VERSION,
+		releaseBaseUrl: RELEASE_BASE_URL,
+		windowsSourceTag: GENTLE_AI_WINDOWS_SOURCE_TAG,
+		libGentleAiVersion: GENTLE_AI_VERSION,
+	});
+
+	assert.deepEqual(mismatches, []);
+});
+
 test("both walks report no drift when sources, runtime/*.mjs, requiredPaths, and contractHashes fully agree", () => {
 	const fixtureRoot = makeFixtureRoot();
 	try {