gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -1,8 +1,9 @@
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { createTestContext } from './test-helpers.ts';
 import { invalidateAllCaches } from '../cache.ts';
 
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
@@ -11,7 +12,6 @@ import { invalidateAllCaches } from '../cache.ts';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, "..", "prompts");
 
-const { assertEq, assertTrue, report } = createTestContext();
 /**
  * Load a prompt template from the worktree prompts directory
  * and apply variable substitution (mirrors loadPrompt logic).
@@ -59,11 +59,9 @@ function cleanup(base: string): void {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
+describe("complete-milestone", () => {
 
-  // ─── Prompt Template Loading ───────────────────────────────────────────
-  console.log("\n=== complete-milestone prompt template exists ===");
-  {
+  test("prompt template exists and loads", () => {
     let result: string;
     let threw = false;
     try {
@@ -77,16 +75,13 @@ async function main(): Promise<void> {
     } catch (err) {
       threw = true;
       result = "";
-      console.error(`  ERROR: loadPrompt threw: ${err}`);
     }
 
-    assertTrue(!threw, "loadPrompt does not throw for complete-milestone");
-    assertTrue(typeof result === "string" && result.length > 0, "loadPrompt returns a non-empty string");
-  }
+    assert.ok(!threw, "loadPrompt does not throw for complete-milestone");
+    assert.ok(typeof result === "string" && result.length > 0, "loadPrompt returns a non-empty string");
+  });
 
-  // ─── Variable Substitution ─────────────────────────────────────────────
-  console.log("\n=== prompt variable substitution ===");
-  {
+  test("prompt variable substitution", () => {
     const prompt = loadPromptFromWorktree("complete-milestone", {
       workingDirectory: "/tmp/test-project",
       milestoneId: "M001",
@@ -95,19 +90,17 @@ async function main(): Promise<void> {
       inlinedContext: "--- inlined slice summaries and context ---",
     });
 
-    assertTrue(prompt.includes("M001"), "prompt contains milestoneId 'M001'");
-    assertTrue(prompt.includes("Integration Feature"), "prompt contains milestoneTitle");
-    assertTrue(prompt.includes(".gsd/milestones/M001/M001-ROADMAP.md"), "prompt contains roadmapPath");
-    assertTrue(prompt.includes("--- inlined slice summaries and context ---"), "prompt contains inlinedContext");
-    assertTrue(!prompt.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
-    assertTrue(!prompt.includes("{{milestoneTitle}}"), "no un-substituted {{milestoneTitle}}");
-    assertTrue(!prompt.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
-    assertTrue(!prompt.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
-  }
-
-  // ─── Prompt Content Integrity ──────────────────────────────────────────
-  console.log("\n=== prompt content integrity ===");
-  {
+    assert.ok(prompt.includes("M001"), "prompt contains milestoneId 'M001'");
+    assert.ok(prompt.includes("Integration Feature"), "prompt contains milestoneTitle");
+    assert.ok(prompt.includes(".gsd/milestones/M001/M001-ROADMAP.md"), "prompt contains roadmapPath");
+    assert.ok(prompt.includes("--- inlined slice summaries and context ---"), "prompt contains inlinedContext");
+    assert.ok(!prompt.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
+    assert.ok(!prompt.includes("{{milestoneTitle}}"), "no un-substituted {{milestoneTitle}}");
+    assert.ok(!prompt.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
+    assert.ok(!prompt.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
+  });
+
+  test("prompt content integrity", () => {
     const prompt = loadPromptFromWorktree("complete-milestone", {
       workingDirectory: "/tmp/test-project",
       milestoneId: "M002",
@@ -116,18 +109,109 @@ async function main(): Promise<void> {
       inlinedContext: "context",
     });
 
-    assertTrue(prompt.includes("Complete Milestone"), "prompt contains 'Complete Milestone' heading");
-    assertTrue(prompt.includes("success criter") || prompt.includes("success criteria"), "prompt mentions success criteria verification");
-    assertTrue(prompt.includes("milestone-summary") || prompt.includes("milestoneSummary"), "prompt references milestone summary artifact");
-    assertTrue(prompt.includes("Milestone M002 complete"), "prompt contains completion sentinel for M002");
-  }
+    assert.ok(prompt.includes("Complete Milestone"), "prompt contains 'Complete Milestone' heading");
+    assert.ok(prompt.includes("success criter") || prompt.includes("success criteria"), "prompt mentions success criteria verification");
+    assert.ok(prompt.includes("milestone-summary") || prompt.includes("milestoneSummary"), "prompt references milestone summary artifact");
+    assert.ok(prompt.includes("Milestone M002 complete"), "prompt contains completion sentinel for M002");
+  });
+
+  test("prompt contains verification gate that blocks completion on failure", () => {
+    const prompt = loadPromptFromWorktree("complete-milestone", {
+      workingDirectory: "/tmp/test-project",
+      milestoneId: "M001",
+      milestoneTitle: "Gate Test",
+      roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+      inlinedContext: "context",
+    });
+
+    // Verification gate section must exist
+    assert.ok(
+      prompt.includes("Verification Gate"),
+      "prompt contains 'Verification Gate' section",
+    );
+
+    // Failure path must block gsd_complete_milestone
+    assert.ok(
+      prompt.includes("Do NOT call `gsd_complete_milestone`"),
+      "failure path explicitly blocks calling the completion tool",
+    );
+
+    // Failure path must have its own sentinel distinct from success
+    assert.ok(
+      prompt.includes("verification FAILED"),
+      "failure path outputs a FAILED sentinel",
+    );
+
+    // verificationPassed parameter must be referenced
+    assert.ok(
+      prompt.includes("verificationPassed"),
+      "prompt references verificationPassed parameter",
+    );
+  });
+
+  test("handleCompleteMilestone rejects when verificationPassed is false", async () => {
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    try {
+      const result = await handleCompleteMilestone({
+        milestoneId: "M001",
+        title: "Test Milestone",
+        oneLiner: "Test",
+        narrative: "Test narrative",
+        successCriteriaResults: "None met",
+        definitionOfDoneResults: "Incomplete",
+        requirementOutcomes: "None validated",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        verificationPassed: false,
+      }, base);
+
+      assert.ok("error" in result, "returns error when verificationPassed is false");
+      assert.ok(
+        (result as { error: string }).error.includes("verification did not pass"),
+        "error message mentions verification did not pass",
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
 
-  // ─── diagnoseExpectedArtifact behavior ─────────────────────────────────
-  // Since diagnoseExpectedArtifact is not exported from auto.ts, we test
-  // the same logic by reimplementing the switch case for complete-milestone
-  // and verifying against known path patterns.
-  console.log("\n=== diagnoseExpectedArtifact logic for complete-milestone ===");
-  {
+  test("handleCompleteMilestone rejects when verificationPassed is omitted", async () => {
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    try {
+      // Simulate omitted verificationPassed (undefined coerced via any)
+      const params: any = {
+        milestoneId: "M001",
+        title: "Test Milestone",
+        oneLiner: "Test",
+        narrative: "Test narrative",
+        successCriteriaResults: "Results",
+        definitionOfDoneResults: "Done results",
+        requirementOutcomes: "Outcomes",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        // verificationPassed intentionally omitted
+      };
+      const result = await handleCompleteMilestone(params, base);
+
+      assert.ok("error" in result, "returns error when verificationPassed is omitted");
+      assert.ok(
+        (result as { error: string }).error.includes("verification did not pass"),
+        "error message mentions verification did not pass",
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("diagnoseExpectedArtifact logic for complete-milestone", async () => {
     // Import the path helpers used by diagnoseExpectedArtifact
     const { relMilestoneFile } = await import("../paths.ts");
 
@@ -144,18 +228,16 @@ async function main(): Promise<void> {
       // This is the exact logic from diagnoseExpectedArtifact for "complete-milestone"
       const result = `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;
 
-      assertTrue(typeof result === "string", "diagnose returns a string");
-      assertTrue(result.includes("SUMMARY"), "diagnose result mentions SUMMARY");
-      assertTrue(result.includes("milestone"), "diagnose result mentions milestone");
-      assertTrue(result.includes("M001"), "diagnose result includes the milestone ID");
+      assert.ok(typeof result === "string", "diagnose returns a string");
+      assert.ok(result.includes("SUMMARY"), "diagnose result mentions SUMMARY");
+      assert.ok(result.includes("milestone"), "diagnose result mentions milestone");
+      assert.ok(result.includes("M001"), "diagnose result includes the milestone ID");
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── deriveState integration: completing-milestone dispatches correctly ─
-  console.log("\n=== deriveState completing-milestone integration ===");
-  {
+  test("deriveState completing-milestone integration", async () => {
     const { deriveState, isMilestoneComplete } = await import("../state.ts");
     const { invalidateAllCaches: invalidateAllCachesDynamic } = await import("../cache.ts");
     const { parseRoadmap } = await import("../parsers-legacy.ts");
@@ -180,30 +262,23 @@ async function main(): Promise<void> {
       const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
       const roadmapContent = await loadFile(roadmapPath);
       const roadmap = parseRoadmap(roadmapContent!);
-      assertTrue(isMilestoneComplete(roadmap), "isMilestoneComplete returns true when all slices are [x]");
+      assert.ok(isMilestoneComplete(roadmap), "isMilestoneComplete returns true when all slices are [x]");
 
       // Verify deriveState returns completing-milestone phase (with validation already done)
       writeMilestoneValidation(base, "M001");
       const state = await deriveState(base);
-      assertEq(state.phase, "completing-milestone", "deriveState returns completing-milestone when all slices done, no summary");
-      assertEq(state.activeMilestone?.id, "M001", "active milestone is M001");
-      assertEq(state.activeSlice, null, "no active slice in completing-milestone");
+      assert.strictEqual(state.phase, "completing-milestone", "deriveState returns completing-milestone when all slices done, no summary");
+      assert.strictEqual(state.activeMilestone?.id, "M001", "active milestone is M001");
+      assert.strictEqual(state.activeSlice, null, "no active slice in completing-milestone");
 
       // Now add the summary and verify it transitions to complete
       writeMilestoneSummary(base, "M001", "# M001 Summary\n\nDone.");
       invalidateAllCachesDynamic();
       const stateAfter = await deriveState(base);
-      assertEq(stateAfter.phase, "complete", "deriveState returns complete after summary exists");
-      assertEq(stateAfter.registry[0]?.status, "complete", "registry shows complete status");
+      assert.strictEqual(stateAfter.phase, "complete", "deriveState returns complete after summary exists");
+      assert.strictEqual(stateAfter.registry[0]?.status, "complete", "registry shows complete status");
     } finally {
       cleanup(base);
     }
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+  });
 });

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -127,7 +127,7 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   // Verify schema version is current (v10 after M001 planning migrations)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 10, 'schema version should be 10');
+  assertEq(versionRow?.['v'], 11, 'schema version should be 11');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();
@@ -188,9 +188,10 @@ console.log('\n=== complete-slice: handler happy path ===');
 
   const { basePath, roadmapPath } = createTempProject();
 
-  // Set up DB state: milestone, slice, 2 complete tasks
+  // Set up DB state: milestone, slices (S01 + S02), 2 complete tasks
   insertMilestone({ id: 'M001' });
   insertSlice({ id: 'S01', milestoneId: 'M001' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second Slice' });
   insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
   insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 2' });
 
@@ -230,10 +231,13 @@ console.log('\n=== complete-slice: handler happy path ===');
     assertMatch(uatContent, /Milestone:\*\* M001/, 'UAT should reference milestone');
     assertMatch(uatContent, /Smoke Test/, 'UAT should contain smoke test from params');
 
-    // (c) Verify roadmap checkbox toggled to [x]
+    // (c) Verify roadmap shows S01 complete (✅) and S02 pending (⬜) in table format
+    // Projection renders roadmap as a Slice Overview table, not checkbox list
     const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
-    assertMatch(roadmapContent, /\[x\]\s+\*\*S01:/, 'S01 should be checked in roadmap');
-    assertMatch(roadmapContent, /\[ \]\s+\*\*S02:/, 'S02 should still be unchecked in roadmap');
+    assertMatch(roadmapContent, /\| S01 \|/, 'S01 should appear in roadmap table');
+    assertTrue(roadmapContent.includes('✅'), 'completed S01 should show ✅ in roadmap table');
+    assertMatch(roadmapContent, /\| S02 \|/, 'S02 should appear in roadmap table');
+    assertTrue(roadmapContent.includes('⬜'), 'pending S02 should show ⬜ in roadmap table');
 
     // (d) Verify full_summary_md and full_uat_md stored in DB for D004 recovery
     const sliceAfter = getSlice('M001', 'S01');
@@ -353,20 +357,17 @@ console.log('\n=== complete-slice: handler idempotency ===');
   const r1 = await handleCompleteSlice(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
 
-  // Second call with same params — should not crash
+  // Second call — state machine guard rejects (slice is already complete)
   const r2 = await handleCompleteSlice(params, basePath);
-  assertTrue(!('error' in r2), 'second call should succeed (idempotent)');
+  assertTrue('error' in r2, 'second call should return error (slice already complete)');
+  if ('error' in r2) {
+    assertMatch(r2.error, /already complete/, 'error should mention already complete');
+  }
 
   // Verify only 1 slice row (not duplicated)
   const adapter = _getAdapter()!;
   const sliceRows = adapter.prepare("SELECT * FROM slices WHERE milestone_id = 'M001' AND id = 'S01'").all();
-  assertEq(sliceRows.length, 1, 'should have exactly 1 slice row after 2 calls');
-
-  // Files should still exist
-  if (!('error' in r2)) {
-    assertTrue(fs.existsSync(r2.summaryPath), 'summary should still exist after second call');
-    assertTrue(fs.existsSync(r2.uatPath), 'UAT should still exist after second call');
-  }
+  assertEq(sliceRows.length, 1, 'should have exactly 1 slice row after calls');
 
   cleanupDir(basePath);
   cleanup(dbPath);

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v10 after M001 planning migrations)
+  // Verify schema version is current (v11 after state machine migration)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 10, 'schema version should be 10');
+  assertEq(versionRow?.['v'], 11, 'schema version should be 11');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(
@@ -283,6 +283,11 @@ console.log('\n=== complete-task: handler happy path ===');
 
   const { basePath, planPath } = createTempProject();
 
+  // Seed milestone + slice + both tasks so projection renders T01 ([x]) and T02 ([ ])
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'pending', title: 'Second task' });
+
   const params = makeValidParams();
   const result = await handleCompleteTask(params, basePath);
 
@@ -384,25 +389,31 @@ console.log('\n=== complete-task: handler idempotency ===');
 
   const { basePath, planPath } = createTempProject();
 
+  // Seed milestone + slice so state machine guards pass
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
   const params = makeValidParams();
 
-  // First call
+  // First call should succeed
   const r1 = await handleCompleteTask(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
 
-  // Second call with same params — should not crash (INSERT OR REPLACE)
-  const r2 = await handleCompleteTask(params, basePath);
-  assertTrue(!('error' in r2), 'second call should succeed (idempotent)');
-
-  // Verify only 1 task row (upserted, not duplicated)
+  // Verify only 1 task row
   const tasks = getSliceTasks('M001', 'S01');
-  assertEq(tasks.length, 1, 'should have exactly 1 task row after 2 calls (upsert)');
+  assertEq(tasks.length, 1, 'should have exactly 1 task row after first call');
 
-  // File should still exist
-  if (!('error' in r2)) {
-    assertTrue(fs.existsSync(r2.summaryPath), 'summary should still exist after second call');
+  // Second call with same params — state machine guard rejects (task is already complete)
+  const r2 = await handleCompleteTask(params, basePath);
+  assertTrue('error' in r2, 'second call should return error (task already complete)');
+  if ('error' in r2) {
+    assertMatch(r2.error, /already complete/, 'error should mention already complete');
   }
 
+  // Still only 1 task row (no duplication from rejected second call)
+  const tasksAfter = getSliceTasks('M001', 'S01');
+  assertEq(tasksAfter.length, 1, 'should still have exactly 1 task row after rejected second call');
+
   cleanupDir(basePath);
   cleanup(dbPath);
 }
@@ -421,6 +432,10 @@ console.log('\n=== complete-task: handler with missing plan file ===');
   const tasksDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
   fs.mkdirSync(tasksDir, { recursive: true });
 
+  // Seed milestone + slice so state machine guards pass
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
   const params = makeValidParams();
   const result = await handleCompleteTask(params, basePath);
 

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -0,0 +1,114 @@
+/**
+ * completed-units-metrics-sync.test.ts — Regression tests for #2313.
+ *
+ * 1. completed-units.json should be archived (not wiped) on milestone transition
+ * 2. metrics.json should be in the worktree → project root sync file list
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// ─── Bug 1: completed-units.json should be archived, not wiped ─────────────
+
+const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
+
+test("#2313: completed-units.json should not be blindly wiped to [] on milestone transition", () => {
+  // The milestone transition block should NOT write an empty array to completed-units.json
+  // without first archiving the existing data. Look for the archive/rename pattern.
+  const transitionIdx = phasesSrc.indexOf("Milestone transition");
+  assert.ok(transitionIdx !== -1, "Milestone transition section exists");
+
+  // Find the completed-units handling block
+  const completedUnitsIdx = phasesSrc.indexOf("completed-units", transitionIdx);
+  assert.ok(completedUnitsIdx !== -1, "completed-units handling exists in transition");
+
+  // Get a window around the completed-units handling (1200 chars to
+  // accommodate CRLF line endings on Windows which inflate byte offsets).
+  const windowStart = Math.max(0, completedUnitsIdx - 300);
+  const windowEnd = Math.min(phasesSrc.length, completedUnitsIdx + 900);
+  const window = phasesSrc.slice(windowStart, windowEnd).toLowerCase();
+
+  // Should archive/rename the old file before resetting
+  const hasArchive = window.includes("archive") ||
+    window.includes("rename") ||
+    window.includes("cpsync") ||
+    window.includes("safecopy") ||
+    window.includes("completed-units-");
+
+  assert.ok(
+    hasArchive,
+    "completed-units.json should be archived before reset during milestone transition",
+  );
+});
+
+// ─── Bug 2: metrics.json should be in the sync file lists ──────────────────
+
+test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
+  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree-sync.ts");
+  const syncSrc = readFileSync(syncSrcPath, "utf-8");
+
+  // syncStateToProjectRoot should copy metrics.json from worktree to project root
+  assert.ok(
+    syncSrc.includes("metrics.json"),
+    "auto-worktree-sync.ts should reference metrics.json for sync",
+  );
+});
+
+test("#2313: syncWorktreeStateBack should include metrics.json in root files list", () => {
+  const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
+
+  // Find the rootFiles array in syncWorktreeStateBack
+  const syncBackIdx = autoWorktreeSrc.indexOf("syncWorktreeStateBack");
+  assert.ok(syncBackIdx !== -1, "syncWorktreeStateBack exists");
+
+  const rootFilesIdx = autoWorktreeSrc.indexOf("rootFiles", syncBackIdx);
+  assert.ok(rootFilesIdx !== -1, "rootFiles list exists in syncWorktreeStateBack");
+
+  // Get the rootFiles array content
+  const arrayStart = autoWorktreeSrc.indexOf("[", rootFilesIdx);
+  const arrayEnd = autoWorktreeSrc.indexOf("]", arrayStart);
+  const rootFilesBlock = autoWorktreeSrc.slice(arrayStart, arrayEnd);
+
+  assert.ok(
+    rootFilesBlock.includes("metrics.json"),
+    "metrics.json should be in syncWorktreeStateBack rootFiles list",
+  );
+});
+
+// ─── Functional test: completed-units archive ────────────────────────────────
+
+test("#2313: functional — completed-units archive creates milestone-specific file", () => {
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-completed-units-"));
+  const gsdDir = join(tmpBase, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Simulate existing completed-units.json with data
+  const existing = [
+    { type: "task", id: "T01" },
+    { type: "slice", id: "S01" },
+  ];
+  const completedKeysPath = join(gsdDir, "completed-units.json");
+  writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
+
+  // Simulate the archive behavior: copy to milestone-specific file
+  const milestoneId = "M001";
+  const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
+  cpSync(completedKeysPath, archivePath);
+
+  // Reset the main file
+  writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
+
+  // Verify archive exists with original data
+  assert.ok(existsSync(archivePath), "archive file should exist");
+  const archived = JSON.parse(readFileSync(archivePath, "utf-8"));
+  assert.deepEqual(archived, existing, "archived data should match original");
+
+  // Verify main file is reset
+  const current = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
+  assert.deepEqual(current, [], "current completed-units should be empty after transition");
+});