gsd-pi 2.24.0 → 2.26.0

package/src/resources/extensions/gsd/tests/memory-extractor.test.ts

@@ -0,0 +1,180 @@
+import { createTestContext } from './test-helpers.ts';
+import { parseMemoryResponse, _resetExtractionState } from '../memory-extractor.ts';
+import {
+  openDatabase,
+  closeDatabase,
+} from '../gsd-db.ts';
+import {
+  getActiveMemories,
+  applyMemoryActions,
+  getActiveMemoriesRanked,
+} from '../memory-store.ts';
+import type { MemoryAction } from '../memory-store.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse valid JSON response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse valid JSON ===');
+{
+  const response = JSON.stringify([
+    { action: 'CREATE', category: 'gotcha', content: 'esbuild drops binaries', confidence: 0.85 },
+    { action: 'REINFORCE', id: 'MEM001' },
+    { action: 'UPDATE', id: 'MEM002', content: 'revised content' },
+    { action: 'SUPERSEDE', id: 'MEM003', superseded_by: 'MEM004' },
+  ]);
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 4, 'should parse 4 actions');
+  assertEq(actions[0].action, 'CREATE', 'first action should be CREATE');
+  assertEq((actions[0] as any).category, 'gotcha', 'CREATE category');
+  assertEq((actions[0] as any).confidence, 0.85, 'CREATE confidence');
+  assertEq(actions[1].action, 'REINFORCE', 'second action should be REINFORCE');
+  assertEq(actions[2].action, 'UPDATE', 'third action should be UPDATE');
+  assertEq(actions[3].action, 'SUPERSEDE', 'fourth action should be SUPERSEDE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse fenced JSON response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse fenced JSON ===');
+{
+  const response = '```json\n[\n  {"action": "CREATE", "category": "convention", "content": "test memory"}\n]\n```';
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 1, 'should parse 1 action from fenced JSON');
+  assertEq(actions[0].action, 'CREATE', 'action should be CREATE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse empty array response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse empty array ===');
+{
+  const actions = parseMemoryResponse('[]');
+  assertEq(actions.length, 0, 'empty array should parse to empty actions');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse malformed response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: malformed responses ===');
+{
+  assertEq(parseMemoryResponse('not json at all'), [], 'garbage text should return []');
+  assertEq(parseMemoryResponse('{"action": "CREATE"}'), [], 'non-array should return []');
+  assertEq(parseMemoryResponse(''), [], 'empty string should return []');
+  assertEq(parseMemoryResponse('```\nbroken\n```'), [], 'fenced non-JSON should return []');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: validation of required fields
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: field validation ===');
+{
+  const response = JSON.stringify([
+    // Valid CREATE
+    { action: 'CREATE', category: 'gotcha', content: 'valid' },
+    // Invalid CREATE — missing content
+    { action: 'CREATE', category: 'gotcha' },
+    // Invalid CREATE — missing category
+    { action: 'CREATE', content: 'no category' },
+    // Valid REINFORCE
+    { action: 'REINFORCE', id: 'MEM001' },
+    // Invalid REINFORCE — missing id
+    { action: 'REINFORCE' },
+    // Valid UPDATE
+    { action: 'UPDATE', id: 'MEM002', content: 'new content' },
+    // Invalid UPDATE — missing content
+    { action: 'UPDATE', id: 'MEM002' },
+    // Valid SUPERSEDE
+    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM002' },
+    // Invalid SUPERSEDE — missing superseded_by
+    { action: 'SUPERSEDE', id: 'MEM001' },
+    // Unknown action
+    { action: 'DELETE', id: 'MEM001' },
+    // Null entry
+    null,
+  ]);
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 4, 'should only accept 4 valid actions');
+  assertEq(actions[0].action, 'CREATE', 'first valid is CREATE');
+  assertEq(actions[1].action, 'REINFORCE', 'second valid is REINFORCE');
+  assertEq(actions[2].action, 'UPDATE', 'third valid is UPDATE');
+  assertEq(actions[3].action, 'SUPERSEDE', 'fourth valid is SUPERSEDE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Integration: applyMemoryActions with mixed actions
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== integration: mixed action lifecycle ===');
+{
+  openDatabase(':memory:');
+
+  // Phase 1: Create initial memories
+  applyMemoryActions([
+    { action: 'CREATE', category: 'gotcha', content: 'npm run build needs tsc first', confidence: 0.7 },
+    { action: 'CREATE', category: 'convention', content: 'all DB queries use named params', confidence: 0.8 },
+    { action: 'CREATE', category: 'architecture', content: 'extensions loaded from two paths', confidence: 0.85 },
+  ], 'plan-slice', 'M001/S01');
+
+  let active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 3, 'phase 1: 3 active memories');
+
+  // Phase 2: Reinforce one, update another, create new
+  applyMemoryActions([
+    { action: 'REINFORCE', id: 'MEM002' },
+    { action: 'UPDATE', id: 'MEM001', content: 'npm run build requires tsc --noEmit first' },
+    { action: 'CREATE', category: 'pattern', content: 'use INSERT OR IGNORE for idempotency', confidence: 0.75 },
+  ], 'execute-task', 'M001/S01/T01');
+
+  active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 4, 'phase 2: 4 active memories');
+  assertEq(
+    active.find(m => m.id === 'MEM001')?.content,
+    'npm run build requires tsc --noEmit first',
+    'MEM001 content should be updated',
+  );
+  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
+
+  // Phase 3: Supersede MEM001 with MEM005
+  applyMemoryActions([
+    { action: 'CREATE', category: 'gotcha', content: 'build script handles tsc automatically now', confidence: 0.9 },
+    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM005' },
+  ], 'execute-task', 'M001/S01/T02');
+
+  active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 4, 'phase 3: 4 active (1 superseded, 1 created)');
+  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
+  assertTrue(!!active.find(m => m.id === 'MEM005'), 'MEM005 should be active');
+
+  // Verify ranking: MEM003 (0.85) > MEM005 (0.9) but MEM002 has 1 hit
+  // MEM002: 0.8 * (1 + 1*0.1) = 0.88
+  // MEM003: 0.85 * 1.0 = 0.85
+  // MEM005: 0.9 * 1.0 = 0.9
+  // MEM004: 0.75 * 1.0 = 0.75
+  assertEq(active[0].id, 'MEM005', 'MEM005 should rank first (0.9)');
+  assertEq(active[1].id, 'MEM002', 'MEM002 should rank second (0.88)');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: _resetExtractionState
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: reset extraction state ===');
+{
+  // Just verify it doesn't throw
+  _resetExtractionState();
+  assertTrue(true, '_resetExtractionState should not throw');
+}
+
+report();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -0,0 +1,345 @@
+import { createTestContext } from './test-helpers.ts';
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  _getAdapter,
+} from '../gsd-db.ts';
+import {
+  getActiveMemories,
+  getActiveMemoriesRanked,
+  nextMemoryId,
+  createMemory,
+  updateMemoryContent,
+  reinforceMemory,
+  supersedeMemory,
+  isUnitProcessed,
+  markUnitProcessed,
+  decayStaleMemories,
+  enforceMemoryCap,
+  applyMemoryActions,
+  formatMemoriesForPrompt,
+} from '../memory-store.ts';
+import type { MemoryAction } from '../memory-store.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: fallback when DB not open
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: fallback returns empty when DB not open ===');
+{
+  closeDatabase();
+  assertTrue(!isDbAvailable(), 'DB should not be available');
+
+  assertEq(getActiveMemories(), [], 'getActiveMemories returns [] when DB closed');
+  assertEq(getActiveMemoriesRanked(), [], 'getActiveMemoriesRanked returns [] when DB closed');
+  assertEq(nextMemoryId(), 'MEM001', 'nextMemoryId returns MEM001 when DB closed');
+  assertEq(createMemory({ category: 'test', content: 'test' }), null, 'createMemory returns null when DB closed');
+  assertTrue(!reinforceMemory('MEM001'), 'reinforceMemory returns false when DB closed');
+  assertTrue(!isUnitProcessed('test/key'), 'isUnitProcessed returns false when DB closed');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: CRUD operations
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: create and query memories ===');
+{
+  openDatabase(':memory:');
+
+  // Create memories
+  const id1 = createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
+  assertTrue(id1 !== null, 'createMemory should return an ID');
+  assertEq(id1, 'MEM001', 'first memory ID should be MEM001');
+
+  const id2 = createMemory({ category: 'convention', content: 'use :memory: for tests', confidence: 0.9 });
+  assertEq(id2, 'MEM002', 'second memory ID should be MEM002');
+
+  const id3 = createMemory({ category: 'architecture', content: 'extensions discovered from src/resources/' });
+  assertEq(id3, 'MEM003', 'third memory ID should be MEM003');
+
+  // Query all active
+  const active = getActiveMemories();
+  assertEq(active.length, 3, 'should have 3 active memories');
+  assertEq(active[0].category, 'gotcha', 'first memory category');
+  assertEq(active[0].content, 'esbuild drops .node binaries', 'first memory content');
+  assertEq(active[1].confidence, 0.9, 'second memory confidence');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: update and reinforce
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: update and reinforce ===');
+{
+  openDatabase(':memory:');
+
+  createMemory({ category: 'gotcha', content: 'original content' });
+
+  // Update content
+  const updated = updateMemoryContent('MEM001', 'revised content', 0.95);
+  assertTrue(updated, 'updateMemoryContent should return true');
+
+  const active = getActiveMemories();
+  assertEq(active[0].content, 'revised content', 'content should be updated');
+  assertEq(active[0].confidence, 0.95, 'confidence should be updated');
+
+  // Reinforce
+  const reinforced = reinforceMemory('MEM001');
+  assertTrue(reinforced, 'reinforceMemory should return true');
+
+  const after = getActiveMemories();
+  assertEq(after[0].hit_count, 1, 'hit_count should be 1 after reinforce');
+
+  // Reinforce again
+  reinforceMemory('MEM001');
+  const after2 = getActiveMemories();
+  assertEq(after2[0].hit_count, 2, 'hit_count should be 2 after second reinforce');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: supersede
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: supersede ===');
+{
+  openDatabase(':memory:');
+
+  createMemory({ category: 'convention', content: 'old convention' });
+  createMemory({ category: 'convention', content: 'new convention' });
+
+  supersedeMemory('MEM001', 'MEM002');
+
+  const active = getActiveMemories();
+  assertEq(active.length, 1, 'should have 1 active memory after supersede');
+  assertEq(active[0].id, 'MEM002', 'active memory should be MEM002');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: ranked query ordering
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: ranked query ordering ===');
+{
+  openDatabase(':memory:');
+
+  // Low confidence, no hits
+  createMemory({ category: 'pattern', content: 'low ranking', confidence: 0.5 });
+  // High confidence, no hits
+  createMemory({ category: 'gotcha', content: 'high confidence', confidence: 0.95 });
+  // Medium confidence, many hits
+  createMemory({ category: 'convention', content: 'frequently used', confidence: 0.7 });
+
+  // Reinforce MEM003 multiple times to boost its ranking
+  for (let i = 0; i < 10; i++) reinforceMemory('MEM003');
+
+  const ranked = getActiveMemoriesRanked(10);
+  assertEq(ranked.length, 3, 'should have 3 ranked memories');
+  // MEM003: 0.7 * (1 + 10*0.1) = 0.7 * 2.0 = 1.4
+  // MEM002: 0.95 * (1 + 0*0.1) = 0.95
+  // MEM001: 0.5 * (1 + 0*0.1) = 0.5
+  assertEq(ranked[0].id, 'MEM003', 'highest ranked should be MEM003 (reinforced)');
+  assertEq(ranked[1].id, 'MEM002', 'second ranked should be MEM002 (high confidence)');
+  assertEq(ranked[2].id, 'MEM001', 'lowest ranked should be MEM001');
+
+  // Test limit
+  const limited = getActiveMemoriesRanked(2);
+  assertEq(limited.length, 2, 'limit should cap results');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: processed unit tracking
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: processed unit tracking ===');
+{
+  openDatabase(':memory:');
+
+  assertTrue(!isUnitProcessed('execute-task/M001/S01/T01'), 'should not be processed initially');
+
+  markUnitProcessed('execute-task/M001/S01/T01', '/path/to/activity.jsonl');
+
+  assertTrue(isUnitProcessed('execute-task/M001/S01/T01'), 'should be processed after marking');
+  assertTrue(!isUnitProcessed('execute-task/M001/S01/T02'), 'different key should not be processed');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: enforce memory cap
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: enforce memory cap ===');
+{
+  openDatabase(':memory:');
+
+  // Create 5 memories with varying confidence
+  createMemory({ category: 'gotcha', content: 'mem 1', confidence: 0.9 });
+  createMemory({ category: 'gotcha', content: 'mem 2', confidence: 0.5 });
+  createMemory({ category: 'gotcha', content: 'mem 3', confidence: 0.3 });
+  createMemory({ category: 'gotcha', content: 'mem 4', confidence: 0.95 });
+  createMemory({ category: 'gotcha', content: 'mem 5', confidence: 0.7 });
+
+  // Enforce cap of 3
+  enforceMemoryCap(3);
+
+  const active = getActiveMemories();
+  assertEq(active.length, 3, 'should have 3 active memories after cap enforcement');
+
+  // The 2 lowest-ranked (MEM003=0.3 and MEM002=0.5) should be superseded
+  const ids = active.map(m => m.id).sort();
+  assertTrue(ids.includes('MEM001'), 'MEM001 (0.9) should survive');
+  assertTrue(ids.includes('MEM004'), 'MEM004 (0.95) should survive');
+  assertTrue(ids.includes('MEM005'), 'MEM005 (0.7) should survive');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: applyMemoryActions transaction
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: applyMemoryActions ===');
+{
+  openDatabase(':memory:');
+
+  const actions: MemoryAction[] = [
+    { action: 'CREATE', category: 'gotcha', content: 'first gotcha', confidence: 0.8 },
+    { action: 'CREATE', category: 'convention', content: 'first convention', confidence: 0.9 },
+  ];
+
+  applyMemoryActions(actions, 'execute-task', 'M001/S01/T01');
+
+  let active = getActiveMemories();
+  assertEq(active.length, 2, 'should have 2 memories after CREATE actions');
+
+  // Now apply UPDATE + REINFORCE
+  const updateActions: MemoryAction[] = [
+    { action: 'UPDATE', id: 'MEM001', content: 'updated gotcha' },
+    { action: 'REINFORCE', id: 'MEM002' },
+  ];
+
+  applyMemoryActions(updateActions, 'execute-task', 'M001/S01/T02');
+
+  active = getActiveMemories();
+  assertEq(active.find(m => m.id === 'MEM001')?.content, 'updated gotcha', 'MEM001 should be updated');
+  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
+
+  // SUPERSEDE
+  const supersedeActions: MemoryAction[] = [
+    { action: 'CREATE', category: 'gotcha', content: 'better gotcha', confidence: 0.95 },
+    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM003' },
+  ];
+
+  applyMemoryActions(supersedeActions, 'execute-task', 'M001/S01/T03');
+
+  active = getActiveMemories();
+  assertEq(active.length, 2, 'should have 2 active after supersede');
+  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
+  assertTrue(!!active.find(m => m.id === 'MEM003'), 'MEM003 should be active');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: formatMemoriesForPrompt
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: formatMemoriesForPrompt ===');
+{
+  openDatabase(':memory:');
+
+  createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
+  createMemory({ category: 'convention', content: 'use :memory: for tests' });
+  createMemory({ category: 'architecture', content: 'extensions in src/resources/' });
+  createMemory({ category: 'gotcha', content: 'TypeScript path aliases need .js' });
+
+  const memories = getActiveMemoriesRanked(30);
+  const formatted = formatMemoriesForPrompt(memories);
+
+  assertTrue(formatted.includes('## Project Memory (auto-learned)'), 'should have header');
+  assertTrue(formatted.includes('### Gotcha'), 'should have gotcha category');
+  assertTrue(formatted.includes('### Convention'), 'should have convention category');
+  assertTrue(formatted.includes('### Architecture'), 'should have architecture category');
+  assertTrue(formatted.includes('- esbuild drops .node binaries'), 'should have gotcha content');
+  assertTrue(formatted.includes('- use :memory: for tests'), 'should have convention content');
+
+  // Test empty memories
+  closeDatabase();
+  openDatabase(':memory:');
+  const emptyFormatted = formatMemoriesForPrompt([]);
+  assertEq(emptyFormatted, '', 'empty memories should return empty string');
+
+  // Test token budget truncation
+  closeDatabase();
+  openDatabase(':memory:');
+  for (let i = 0; i < 20; i++) {
+    createMemory({ category: 'pattern', content: `A very long memory entry that takes up space #${i}: ${'x'.repeat(200)}` });
+  }
+  const budgetMemories = getActiveMemoriesRanked(30);
+  const truncated = formatMemoriesForPrompt(budgetMemories, 500);
+  assertTrue(truncated.length < 2500, `formatted length ${truncated.length} should be under budget`);
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: ID generation
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: ID generation ===');
+{
+  openDatabase(':memory:');
+
+  assertEq(nextMemoryId(), 'MEM001', 'first ID should be MEM001');
+
+  createMemory({ category: 'test', content: 'test' });
+  assertEq(nextMemoryId(), 'MEM002', 'after first create, next should be MEM002');
+
+  // Create several more
+  for (let i = 0; i < 98; i++) createMemory({ category: 'test', content: `test ${i}` });
+  assertEq(nextMemoryId(), 'MEM100', 'after 99 creates, next should be MEM100');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-store: schema migration (v2 → v3)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-store: schema includes memories table ===');
+{
+  openDatabase(':memory:');
+
+  const adapter = _getAdapter()!;
+
+  // Verify memories table exists
+  const memCount = adapter.prepare('SELECT count(*) as cnt FROM memories').get();
+  assertEq(memCount?.['cnt'], 0, 'memories table should exist and be empty');
+
+  // Verify memory_processed_units table exists
+  const procCount = adapter.prepare('SELECT count(*) as cnt FROM memory_processed_units').get();
+  assertEq(procCount?.['cnt'], 0, 'memory_processed_units table should exist and be empty');
+
+  // Verify active_memories view exists
+  const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
+  assertEq(viewCount?.['cnt'], 0, 'active_memories view should exist');
+
+  // Verify schema version is 3
+  const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
+  assertEq(version?.['v'], 3, 'schema version should be 3');
+
+  closeDatabase();
+}
+
+report();

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -11,6 +11,7 @@ import { writeGSDDirectory } from '../migrate/writer.ts';
 import { generatePreview } from '../migrate/preview.ts';
 import { parseRoadmap, parsePlan, parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
+import { invalidateAllCaches } from '../cache.ts';
 import type {
   GSDProject,
   GSDMilestone,
@@ -207,6 +208,7 @@ async function main(): Promise<void> {
 
       // (e) deriveState
       console.log('  --- deriveState ---');
+      invalidateAllCaches();
       const state = await deriveState(base);
       assertEq(state.phase, 'executing', 'incomplete: deriveState phase is executing');
       assertTrue(state.activeMilestone !== null, 'incomplete: deriveState has activeMilestone');
@@ -262,14 +264,18 @@ async function main(): Promise<void> {
       assertTrue(!existsSync(join(m, 'M001-RESEARCH.md')), 'complete: M001-RESEARCH.md NOT written (null)');
       // No REQUIREMENTS.md since empty requirements
       assertTrue(!existsSync(join(base, '.gsd', 'REQUIREMENTS.md')), 'complete: REQUIREMENTS.md NOT written (empty)');
-
-      // deriveState: all slices done, all tasks done — needs validation then milestone summary
-      // Without VALIDATION file, it should be 'validating-milestone'
+      // Completed milestone should have VALIDATION and SUMMARY from migration (#819)
+      assertTrue(existsSync(join(m, 'M001-VALIDATION.md')), 'complete: M001-VALIDATION.md written for completed milestone');
+      assertTrue(existsSync(join(m, 'M001-SUMMARY.md')), 'complete: M001-SUMMARY.md written for completed milestone');
+
+      // deriveState: all slices done, all tasks done — migration now writes
+      // VALIDATION.md and SUMMARY.md for completed milestones (#819),
+      // so the milestone should be fully complete.
+      invalidateAllCaches();
       const state = await deriveState(base);
-      // All slices are done in roadmap. No VALIDATION or SUMMARY exists.
-      // deriveState should return 'validating-milestone' since validation gate precedes completion.
-      assertEq(state.phase, 'validating-milestone', 'complete: deriveState phase is validating-milestone');
-      assertTrue(state.activeMilestone !== null, 'complete: deriveState has activeMilestone');
+      assertEq(state.phase, 'complete', 'complete: deriveState phase is complete (validation + summary written by migration)');
+      // When all milestones are complete, activeMilestone points to the last entry (for display)
+      assertTrue(state.activeMilestone !== null, 'complete: deriveState has activeMilestone (last entry)');
       assertEq(state.activeMilestone!.id, 'M001', 'complete: deriveState activeMilestone is M001');
 
       // generatePreview for complete project