gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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,13 @@ 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");
+  });
 
-  // ─── 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("diagnoseExpectedArtifact logic for complete-milestone", async () => {
     // Import the path helpers used by diagnoseExpectedArtifact
     const { relMilestoneFile } = await import("../paths.ts");
 
@@ -144,21 +132,19 @@ 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("../files.ts");
+    const { parseRoadmap } = await import("../parsers-legacy.ts");
 
     const base = createFixtureBase();
     try {
@@ -180,30 +166,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

@@ -0,0 +1,375 @@
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  transaction,
+  _getAdapter,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getSlice,
+  updateSliceStatus,
+  getSliceTasks,
+} from '../gsd-db.ts';
+import { handleCompleteSlice } from '../tools/complete-slice.ts';
+import type { CompleteSliceParams } from '../types.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-complete-slice-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanup(dbPath: string): void {
+  closeDatabase();
+  try {
+    const dir = path.dirname(dbPath);
+    for (const f of fs.readdirSync(dir)) {
+      fs.unlinkSync(path.join(dir, f));
+    }
+    fs.rmdirSync(dir);
+  } catch {
+    // best effort
+  }
+}
+
+function cleanupDir(dirPath: string): void {
+  try {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  } catch {
+    // best effort
+  }
+}
+
+/**
+ * Create a temp project directory with .gsd structure and roadmap for handler tests.
+ */
+function createTempProject(): { basePath: string; roadmapPath: string } {
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-slice-handler-'));
+  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const tasksDir = path.join(sliceDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+
+  const roadmapPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+  fs.writeFileSync(roadmapPath, `# M001: Test Milestone
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:medium\` \`depends:[]\`
+  - After this: basic functionality works
+
+- [ ] **S02: Second Slice** \`risk:low\` \`depends:[S01]\`
+  - After this: advanced stuff
+`);
+
+  return { basePath, roadmapPath };
+}
+
+function makeValidSliceParams(): CompleteSliceParams {
+  return {
+    sliceId: 'S01',
+    milestoneId: 'M001',
+    sliceTitle: 'Test Slice',
+    oneLiner: 'Implemented test slice with full coverage',
+    narrative: 'Built the handler, registered the tool, and wrote comprehensive tests.',
+    verification: 'All 8 test sections pass with 0 failures.',
+    deviations: 'None.',
+    knownLimitations: 'None.',
+    followUps: 'None.',
+    keyFiles: ['src/tools/complete-slice.ts', 'src/bootstrap/db-tools.ts'],
+    keyDecisions: ['D001'],
+    patternsEstablished: ['SliceRow/rowToSlice follows same pattern as TaskRow/rowToTask'],
+    observabilitySurfaces: ['SELECT status FROM slices shows completion state'],
+    provides: ['complete_slice handler', 'gsd_slice_complete tool'],
+    requirementsSurfaced: [],
+    drillDownPaths: ['milestones/M001/slices/S01/tasks/T01-SUMMARY.md'],
+    affects: ['S02'],
+    requirementsAdvanced: [{ id: 'R001', how: 'Handler validates task completion' }],
+    requirementsValidated: [],
+    requirementsInvalidated: [],
+    filesModified: [
+      { path: 'src/tools/complete-slice.ts', description: 'Handler implementation' },
+      { path: 'src/bootstrap/db-tools.ts', description: 'Tool registration' },
+    ],
+    requires: [],
+    uatContent: `## Smoke Test
+
+Run the test suite and verify all assertions pass.
+
+## Test Cases
+
+### 1. Handler happy path
+
+1. Insert complete tasks in DB
+2. Call handleCompleteSlice()
+3. **Expected:** SUMMARY.md + UAT.md written, roadmap checkbox toggled, DB updated`,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("complete-slice: schema v6 migration", () => {
+  test("schema version and columns exist", () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    const adapter = _getAdapter()!;
+
+    // Verify schema version is current (v10 after M001 planning migrations)
+    const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
+    assert.strictEqual(versionRow?.['v'], 10, 'schema version should be 10');
+
+    // Verify slices table has full_summary_md and full_uat_md columns
+    const cols = adapter.prepare("PRAGMA table_info(slices)").all();
+    const colNames = cols.map(c => c['name'] as string);
+    assert.ok(colNames.includes('full_summary_md'), 'slices table should have full_summary_md column');
+    assert.ok(colNames.includes('full_uat_md'), 'slices table should have full_uat_md column');
+
+    cleanup(dbPath);
+  });
+});
+
+describe("complete-slice: getSlice/updateSliceStatus accessors", () => {
+  test("getSlice and updateSliceStatus work correctly", () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    // Insert milestone and slice
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', risk: 'high' });
+
+    // getSlice returns correct row
+    const slice = getSlice('M001', 'S01');
+    assert.ok(slice !== null, 'getSlice should return non-null for existing slice');
+    assert.strictEqual(slice!.id, 'S01', 'slice id');
+    assert.strictEqual(slice!.milestone_id, 'M001', 'slice milestone_id');
+    assert.strictEqual(slice!.title, 'Test Slice', 'slice title');
+    assert.strictEqual(slice!.risk, 'high', 'slice risk');
+    assert.strictEqual(slice!.status, 'pending', 'slice default status should be pending');
+    assert.strictEqual(slice!.completed_at, null, 'slice completed_at should be null initially');
+    assert.strictEqual(slice!.full_summary_md, '', 'slice full_summary_md should be empty initially');
+    assert.strictEqual(slice!.full_uat_md, '', 'slice full_uat_md should be empty initially');
+
+    // getSlice returns null for non-existent
+    const noSlice = getSlice('M001', 'S99');
+    assert.strictEqual(noSlice, null, 'non-existent slice should return null');
+
+    // updateSliceStatus changes status and completed_at
+    const now = new Date().toISOString();
+    updateSliceStatus('M001', 'S01', 'complete', now);
+    const updated = getSlice('M001', 'S01');
+    assert.strictEqual(updated!.status, 'complete', 'slice status should be updated to complete');
+    assert.strictEqual(updated!.completed_at, now, 'slice completed_at should be set');
+
+    cleanup(dbPath);
+  });
+});
+
+describe("complete-slice: handler", () => {
+  test("happy path", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    const { basePath, roadmapPath } = createTempProject();
+
+    // Set up DB state: milestone, slice, 2 complete tasks
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 2' });
+
+    const params = makeValidSliceParams();
+    const result = await handleCompleteSlice(params, basePath);
+
+    assert.ok(!('error' in result), 'handler should succeed without error');
+    if (!('error' in result)) {
+      assert.strictEqual(result.sliceId, 'S01', 'result sliceId');
+      assert.strictEqual(result.milestoneId, 'M001', 'result milestoneId');
+      assert.ok(result.summaryPath.endsWith('S01-SUMMARY.md'), 'summaryPath should end with S01-SUMMARY.md');
+      assert.ok(result.uatPath.endsWith('S01-UAT.md'), 'uatPath should end with S01-UAT.md');
+
+      // (a) Verify SUMMARY.md exists on disk with correct YAML frontmatter
+      assert.ok(fs.existsSync(result.summaryPath), 'summary file should exist on disk');
+      const summaryContent = fs.readFileSync(result.summaryPath, 'utf-8');
+      assert.match(summaryContent, /^---\n/, 'summary should start with YAML frontmatter');
+      assert.match(summaryContent, /id: S01/, 'summary should contain id: S01');
+      assert.match(summaryContent, /parent: M001/, 'summary should contain parent: M001');
+      assert.match(summaryContent, /milestone: M001/, 'summary should contain milestone: M001');
+      assert.match(summaryContent, /blocker_discovered: false/, 'summary should contain blocker_discovered');
+      assert.match(summaryContent, /verification_result: passed/, 'summary should contain verification_result');
+      assert.match(summaryContent, /key_files:/, 'summary should contain key_files');
+      assert.match(summaryContent, /patterns_established:/, 'summary should contain patterns_established');
+      assert.match(summaryContent, /observability_surfaces:/, 'summary should contain observability_surfaces');
+      assert.match(summaryContent, /provides:/, 'summary should contain provides');
+      assert.match(summaryContent, /# S01: Test Slice/, 'summary should have H1 with slice ID and title');
+      assert.match(summaryContent, /\*\*Implemented test slice with full coverage\*\*/, 'summary should have one-liner in bold');
+      assert.match(summaryContent, /## What Happened/, 'summary should have What Happened section');
+      assert.match(summaryContent, /## Verification/, 'summary should have Verification section');
+      assert.match(summaryContent, /## Requirements Advanced/, 'summary should have Requirements Advanced section');
+
+      // (b) Verify UAT.md exists on disk
+      assert.ok(fs.existsSync(result.uatPath), 'UAT file should exist on disk');
+      const uatContent = fs.readFileSync(result.uatPath, 'utf-8');
+      assert.match(uatContent, /# S01: Test Slice — UAT/, 'UAT should have correct title');
+      assert.match(uatContent, /Milestone:\*\* M001/, 'UAT should reference milestone');
+      assert.match(uatContent, /Smoke Test/, 'UAT should contain smoke test from params');
+
+      // (c) Verify roadmap checkbox toggled to [x]
+      const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
+      assert.match(roadmapContent, /\[x\]\s+\*\*S01:/, 'S01 should be checked in roadmap');
+      assert.match(roadmapContent, /\[ \]\s+\*\*S02:/, 'S02 should still be unchecked in roadmap');
+
+      // (d) Verify full_summary_md and full_uat_md stored in DB for D004 recovery
+      const sliceAfter = getSlice('M001', 'S01');
+      assert.ok(sliceAfter !== null, 'slice should exist in DB after handler');
+      assert.ok(sliceAfter!.full_summary_md.length > 0, 'full_summary_md should be non-empty in DB');
+      assert.match(sliceAfter!.full_summary_md, /id: S01/, 'full_summary_md should contain frontmatter');
+      assert.ok(sliceAfter!.full_uat_md.length > 0, 'full_uat_md should be non-empty in DB');
+      assert.match(sliceAfter!.full_uat_md, /S01: Test Slice — UAT/, 'full_uat_md should contain UAT title');
+
+      // (e) Verify slice status is complete in DB
+      assert.strictEqual(sliceAfter!.status, 'complete', 'slice status should be complete in DB');
+      assert.ok(sliceAfter!.completed_at !== null, 'completed_at should be set in DB');
+    }
+
+    cleanupDir(basePath);
+    cleanup(dbPath);
+  });
+
+  test("rejects incomplete tasks", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    // Insert milestone, slice, 2 tasks — one complete, one pending
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'pending', title: 'Task 2' });
+
+    const params = makeValidSliceParams();
+    const result = await handleCompleteSlice(params, '/tmp/fake');
+
+    assert.ok('error' in result, 'should return error when tasks are incomplete');
+    if ('error' in result) {
+      assert.match(result.error, /incomplete tasks/, 'error should mention incomplete tasks');
+      assert.match(result.error, /T02/, 'error should mention the specific incomplete task ID');
+    }
+
+    cleanup(dbPath);
+  });
+
+  test("rejects no tasks", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    // Insert milestone and slice but NO tasks
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+
+    const params = makeValidSliceParams();
+    const result = await handleCompleteSlice(params, '/tmp/fake');
+
+    assert.ok('error' in result, 'should return error when no tasks exist');
+    if ('error' in result) {
+      assert.match(result.error, /no tasks found/, 'error should say no tasks found');
+    }
+
+    cleanup(dbPath);
+  });
+
+  test("validation errors", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    const params = makeValidSliceParams();
+
+    // Empty sliceId
+    const r1 = await handleCompleteSlice({ ...params, sliceId: '' }, '/tmp/fake');
+    assert.ok('error' in r1, 'should return error for empty sliceId');
+    if ('error' in r1) {
+      assert.match(r1.error, /sliceId/, 'error should mention sliceId');
+    }
+
+    // Empty milestoneId
+    const r2 = await handleCompleteSlice({ ...params, milestoneId: '' }, '/tmp/fake');
+    assert.ok('error' in r2, 'should return error for empty milestoneId');
+    if ('error' in r2) {
+      assert.match(r2.error, /milestoneId/, 'error should mention milestoneId');
+    }
+
+    cleanup(dbPath);
+  });
+
+  test("idempotency", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    const { basePath, roadmapPath } = createTempProject();
+
+    // Set up DB state
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+
+    const params = makeValidSliceParams();
+
+    // First call
+    const r1 = await handleCompleteSlice(params, basePath);
+    assert.ok(!('error' in r1), 'first call should succeed');
+
+    // Second call with same params — should not crash
+    const r2 = await handleCompleteSlice(params, basePath);
+    assert.ok(!('error' in r2), 'second call should succeed (idempotent)');
+
+    // 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();
+    assert.strictEqual(sliceRows.length, 1, 'should have exactly 1 slice row after 2 calls');
+
+    // Files should still exist
+    if (!('error' in r2)) {
+      assert.ok(fs.existsSync(r2.summaryPath), 'summary should still exist after second call');
+      assert.ok(fs.existsSync(r2.uatPath), 'UAT should still exist after second call');
+    }
+
+    cleanupDir(basePath);
+    cleanup(dbPath);
+  });
+
+  test("missing roadmap (graceful)", async () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    // Create a temp dir WITHOUT a roadmap file
+    const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-no-roadmap-'));
+    const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+    fs.mkdirSync(sliceDir, { recursive: true });
+
+    // Set up DB state
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+
+    const params = makeValidSliceParams();
+    const result = await handleCompleteSlice(params, basePath);
+
+    // Should succeed even without roadmap file — just skip checkbox toggle
+    assert.ok(!('error' in result), 'handler should succeed without roadmap file');
+    if (!('error' in result)) {
+      assert.ok(fs.existsSync(result.summaryPath), 'summary should be written even without roadmap');
+      assert.ok(fs.existsSync(result.uatPath), 'UAT should be written even without roadmap');
+    }
+
+    cleanupDir(basePath);
+    cleanup(dbPath);
+  });
+});