@iservu-inc/adf-cli 0.17.0 → 0.17.5

package/tests/decay-manager.test.js

@@ -20,6 +20,9 @@ describe('DecayManager Integration Tests', () => {
     await fs.remove(testProjectPath);
   });
 
+  // Helper: get a date N days ago
+  const daysAgo = (n) => new Date(Date.now() - n * 24 * 60 * 60 * 1000).toISOString();
+
   const createTestPattern = (overrides = {}) => ({
     id: `pattern_${Date.now()}`,
     type: 'consistent_skip',
@@ -30,19 +33,19 @@ describe('DecayManager Integration Tests', () => {
     skipCount: 9,
     status: 'active',
     userApproved: false,
-    createdAt: new Date('2025-01-01').toISOString(),
-    lastSeen: new Date('2025-09-01').toISOString(),
-    lastDecayCalculation: new Date('2025-09-01').toISOString(),
+    createdAt: daysAgo(60),
+    lastSeen: daysAgo(10),
+    lastDecayCalculation: daysAgo(10),
     timesRenewed: 0,
     ...overrides
   });
 
   describe('loadPatternsWithDecay', () => {
     test('loads patterns and applies decay', async () => {
-      // Create patterns with old lastSeen dates
+      // Create patterns with lastSeen dates ~2 months ago (enough for measurable decay)
       const patterns = [
-        createTestPattern({ id: 'p1', confidence: 90, lastSeen: new Date('2025-07-01').toISOString() }),
-        createTestPattern({ id: 'p2', confidence: 80, lastSeen: new Date('2025-07-01').toISOString() })
+        createTestPattern({ id: 'p1', confidence: 90, lastSeen: daysAgo(60) }),
+        createTestPattern({ id: 'p2', confidence: 80, lastSeen: daysAgo(60) })
       ];
 
       await storage.savePatterns(testProjectPath, {
@@ -58,17 +61,17 @@ describe('DecayManager Integration Tests', () => {
     });
 
     test('removes stale patterns automatically', async () => {
-      // Create patterns - one stale, one active
+      // Create patterns - one stale (below threshold), one active
       const patterns = [
         createTestPattern({
           id: 'stale',
           confidence: 35, // Below removeBelow threshold (40)
-          lastSeen: new Date('2025-09-01').toISOString()
+          lastSeen: daysAgo(10)
         }),
         createTestPattern({
           id: 'active',
           confidence: 80,
-          lastSeen: new Date('2025-09-01').toISOString()
+          lastSeen: daysAgo(10)
         })
       ];
 
@@ -91,7 +94,7 @@ describe('DecayManager Integration Tests', () => {
       await storage.saveLearningConfig(testProjectPath, config);
 
       const patterns = [
-        createTestPattern({ confidence: 90, lastSeen: new Date('2025-06-01').toISOString() })
+        createTestPattern({ confidence: 90, lastSeen: daysAgo(60) })
       ];
 
       await storage.savePatterns(testProjectPath, {
@@ -269,12 +272,12 @@ describe('DecayManager Integration Tests', () => {
         createTestPattern({
           id: 'ancient',
           confidence: 80,
-          lastSeen: new Date('2024-12-01').toISOString() // 10 months ago
+          lastSeen: daysAgo(300) // ~10 months ago
         }),
         createTestPattern({
           id: 'recent',
           confidence: 80,
-          lastSeen: new Date('2025-09-01').toISOString()
+          lastSeen: daysAgo(10)
         })
       ];
 
@@ -289,8 +292,8 @@ describe('DecayManager Integration Tests', () => {
 
     test('keeps all patterns if none meet removal criteria', () => {
       const patterns = [
-        createTestPattern({ confidence: 80, lastSeen: new Date('2025-09-01').toISOString() }),
-        createTestPattern({ confidence: 70, lastSeen: new Date('2025-09-01').toISOString() })
+        createTestPattern({ confidence: 80, lastSeen: daysAgo(10) }),
+        createTestPattern({ confidence: 70, lastSeen: daysAgo(10) })
       ];
 
       const { activePatterns, removedPatterns } = decayManager.cleanupStalePatterns(patterns);
@@ -303,8 +306,8 @@ describe('DecayManager Integration Tests', () => {
   describe('triggerDecayCalculation', () => {
     test('manually triggers decay and returns stats', async () => {
       const patterns = [
-        createTestPattern({ confidence: 90, lastSeen: new Date('2025-07-01').toISOString() }),
-        createTestPattern({ confidence: 35, lastSeen: new Date('2025-07-01').toISOString() }) // Will be removed
+        createTestPattern({ confidence: 90, lastSeen: daysAgo(60) }),
+        createTestPattern({ confidence: 35, lastSeen: daysAgo(60) }) // Will be removed (below threshold)
       ];
 
       await storage.savePatterns(testProjectPath, {
@@ -337,9 +340,9 @@ describe('DecayManager Integration Tests', () => {
   describe('getDecayStats', () => {
     test('calculates decay statistics', async () => {
       const patterns = [
-        createTestPattern({ confidence: 85, createdAt: new Date('2025-08-01').toISOString() }), // High
-        createTestPattern({ confidence: 70, createdAt: new Date('2025-08-01').toISOString() }), // Medium
-        createTestPattern({ confidence: 55, createdAt: new Date('2025-08-01').toISOString() })  // Low
+        createTestPattern({ confidence: 85, createdAt: daysAgo(30) }), // High
+        createTestPattern({ confidence: 70, createdAt: daysAgo(30) }), // Medium
+        createTestPattern({ confidence: 55, createdAt: daysAgo(30) })  // Low
       ];
 
       await storage.savePatterns(testProjectPath, {

package/tests/deploy.test.js

@@ -11,9 +11,13 @@ jest.mock('../lib/generators', () => ({
   generateVSCode: jest.fn(),
   generateZed: jest.fn(),
   generateAntigravity: jest.fn(),
-  generateOpenCode: jest.fn().mockResolvedValue({ config: 'opencode.json' }),
+  generateOpenCode: jest.fn().mockResolvedValue({ config: '.opencode.json' }),
   generateGeminiCLI: jest.fn(),
-  generateDeepAgent: jest.fn()
+  generateDeepAgent: jest.fn(),
+  generateA2A: jest.fn(),
+  generateKiro: jest.fn(),
+  generateTrae: jest.fn(),
+  generateCodexCLI: jest.fn()
 }));
 
 const TEST_DIR = path.join(__dirname, 'test-deploy-opencode');
@@ -51,7 +55,7 @@ describe('Deploy Command - OpenCode', () => {
     // However, deploy.js writes a fallback/wrapper config at the end.
     
     // The key check here is that it didn't crash and tried to write to opencode.json
-    const configPath = path.join(TEST_DIR, 'opencode.json');
+    const configPath = path.join(TEST_DIR, '.opencode.json');
     expect(await fs.pathExists(configPath)).toBe(true);
   });
 });

package/tests/dynamic-question-generator.test.js

@@ -4,7 +4,7 @@ describe('Dynamic Question Generator', () => {
   test('should generate questions from heuristic and AI gaps', () => {
     const heuristicGaps = {
       missingFields: ['architecture'],
-      missingQuestions: ['bal-37']
+      missingQuestions: ['bal-19']
     };
     const aiGaps = [
       'Authentication flow is mentioned but not defined',
@@ -14,7 +14,7 @@ describe('Dynamic Question Generator', () => {
     const questions = DynamicQuestionGenerator.generate(heuristicGaps, aiGaps);
 
     // Heuristic questions (existing ones)
-    expect(questions.some(q => q.id === 'bal-37')).toBe(true);
+    expect(questions.some(q => q.id === 'bal-19')).toBe(true);
 
     // Dynamic AI questions (new ones)
     expect(questions.some(q => q.text.includes('Authentication flow'))).toBe(true);

package/tests/framework-detector.test.js

@@ -23,7 +23,7 @@ describe('Framework Detector', () => {
     await fs.ensureDir(path.join(tempDir, 'docs/prd'));
     await fs.ensureDir(path.join(tempDir, 'docs/architecture'));
     const detected = await FrameworkDetector.detect(tempDir);
-    expect(detected).toContain('bmad');
+    expect(detected).toContain('agent-native');
   });
 
   test('should detect OpenSpec project', async () => {
@@ -33,11 +33,11 @@ describe('Framework Detector', () => {
     expect(detected).toContain('openspec');
   });
 
-  test('should detect Spec-Kit project', async () => {
+  test('should detect specification-driven project', async () => {
     await fs.writeFile(path.join(tempDir, 'constitution.md'), '# Constitution');
     await fs.writeFile(path.join(tempDir, 'specification.md'), '# Specification');
     const detected = await FrameworkDetector.detect(tempDir);
-    expect(detected).toContain('spec-kit');
+    expect(detected).toContain('specification-driven');
   });
 
   test('should detect multiple frameworks', async () => {
@@ -48,6 +48,34 @@ describe('Framework Detector', () => {
     expect(detected).toContain('openspec');
   });
 
+  test('should detect Gemini CLI Conductor project', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    await fs.writeFile(path.join(tempDir, 'conductor', 'product.md'), '# My Product');
+    await fs.writeFile(path.join(tempDir, 'conductor', 'workflow.md'), '# Workflow');
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('gemini-conductor');
+  });
+
+  test('should detect Conductor with only product.md', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    await fs.writeFile(path.join(tempDir, 'conductor', 'product.md'), '# My Product');
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('gemini-conductor');
+  });
+
+  test('should detect Conductor with only workflow.md', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    await fs.writeFile(path.join(tempDir, 'conductor', 'workflow.md'), '# Workflow');
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('gemini-conductor');
+  });
+
+  test('should not detect Conductor for empty conductor directory', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).not.toContain('gemini-conductor');
+  });
+
   test('should return empty array for no frameworks', async () => {
     const detected = await FrameworkDetector.detect(tempDir);
     expect(detected).toEqual([]);

package/tests/heuristic-gap-analyzer.test.js

@@ -11,9 +11,9 @@ describe('Heuristic Gap Analyzer', () => {
     };
 
     const gaps = HeuristicGapAnalyzer.analyze(context, 'balanced');
-    
+
     expect(gaps.missingFields).toContain('architecture');
-    expect(gaps.missingQuestions).toContain('bal-37');
+    expect(gaps.missingQuestions).toContain('bal-19');
   });
 
   test('should identify missing tech stack in rapid framework', () => {
@@ -24,9 +24,9 @@ describe('Heuristic Gap Analyzer', () => {
     };
 
     const gaps = HeuristicGapAnalyzer.analyze(context, 'rapid');
-    
+
     expect(gaps.missingFields).toContain('techStack');
-    expect(gaps.missingQuestions).toContain('prp-8');
+    expect(gaps.missingQuestions).toContain('prp-5');
   });
 
   test('should find no gaps when context is complete', () => {
@@ -39,7 +39,7 @@ describe('Heuristic Gap Analyzer', () => {
     };
 
     const gaps = HeuristicGapAnalyzer.analyze(context, 'balanced');
-    
+
     expect(gaps.missingFields.length).toBe(0);
     expect(gaps.missingQuestions.length).toBe(0);
   });

package/tests/pattern-decay.test.js

@@ -40,11 +40,15 @@ describe('Pattern Decay Algorithm', () => {
 
     test('low confidence (<75) decays at 1.5x rate', () => {
       const lowRate = getDecayRate(65, 0.15);
-      expect(lowRate).toBe(0.225); // 22.5%
+      expect(lowRate).toBeCloseTo(0.225); // 22.5%
     });
   });
 
   describe('calculateDecay', () => {
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
     test('decays confidence over time', () => {
       const pattern = createPattern({
         confidence: 90,
@@ -52,16 +56,14 @@ describe('Pattern Decay Algorithm', () => {
       });
 
       // Mock current date to 2 months later
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = calculateDecay(pattern, config);
 
       // Should decay over 2 months
       expect(decayed.confidence).toBeLessThan(90);
-      expect(decayed.lastDecayCalculation).toBe(mockDate.toISOString());
-
-      jest.restoreAllMocks();
+      expect(decayed.lastDecayCalculation).toBe(new Date('2025-10-01').toISOString());
     });
 
     test('high confidence patterns decay slower than low confidence', () => {
@@ -75,8 +77,8 @@ describe('Pattern Decay Algorithm', () => {
         lastSeen: new Date('2025-08-01').toISOString()
       });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const highDecayed = calculateDecay(highPattern, config);
       const lowDecayed = calculateDecay(lowPattern, config);
@@ -86,8 +88,6 @@ describe('Pattern Decay Algorithm', () => {
       const lowDecayPct = (lowPattern.confidence - lowDecayed.confidence) / lowPattern.confidence;
 
       expect(highDecayPct).toBeLessThan(lowDecayPct);
-
-      jest.restoreAllMocks();
     });
 
     test('skips decay if disabled', () => {
@@ -107,16 +107,14 @@ describe('Pattern Decay Algorithm', () => {
 
       const protectConfig = { ...config, protectApproved: true };
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = calculateDecay(approvedPattern, protectConfig);
       const normalDecayed = calculateDecay(createPattern({ userApproved: false, lastSeen: new Date('2025-06-01').toISOString() }), config);
 
       // User-approved should decay slower
       expect(decayed.confidence).toBeGreaterThan(normalDecayed.confidence);
-
-      jest.restoreAllMocks();
     });
 
     test('skips decay if recently seen (< 1 week)', () => {
@@ -124,14 +122,12 @@ describe('Pattern Decay Algorithm', () => {
         lastSeen: new Date('2025-09-28').toISOString()
       });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const result = calculateDecay(recentPattern, config);
 
       expect(result.confidence).toBe(recentPattern.confidence);
-
-      jest.restoreAllMocks();
     });
 
     test('confidence never goes below 0', () => {
@@ -140,14 +136,12 @@ describe('Pattern Decay Algorithm', () => {
         lastSeen: new Date('2024-01-01').toISOString()
       });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = calculateDecay(lowPattern, config);
 
       expect(decayed.confidence).toBeGreaterThanOrEqual(0);
-
-      jest.restoreAllMocks();
     });
   });
 
@@ -155,16 +149,11 @@ describe('Pattern Decay Algorithm', () => {
     test('increases confidence by renewal boost', () => {
       const pattern = createPattern({ confidence: 60 });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
-
       const renewed = renewPattern(pattern, config);
 
       expect(renewed.confidence).toBe(70); // 60 + 10 (renewalBoost)
       expect(renewed.timesRenewed).toBe(1);
-      expect(renewed.lastSeen).toBe(mockDate.toISOString());
-
-      jest.restoreAllMocks();
+      expect(renewed.lastSeen).toBeTruthy();
     });
 
     test('caps at initialConfidence + 5', () => {
@@ -192,19 +181,19 @@ describe('Pattern Decay Algorithm', () => {
     test('updates lastSeen and prevents immediate decay', () => {
       const pattern = createPattern();
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
-
       const renewed = renewPattern(pattern, config);
 
-      expect(renewed.lastSeen).toBe(mockDate.toISOString());
-      expect(renewed.lastDecayCalculation).toBe(mockDate.toISOString());
-
-      jest.restoreAllMocks();
+      expect(renewed.lastSeen).toBeTruthy();
+      expect(renewed.lastDecayCalculation).toBeTruthy();
+      expect(renewed.lastSeen).toBe(renewed.lastDecayCalculation);
     });
   });
 
   describe('applyDecayToStoredPatterns', () => {
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
     test('applies decay to all patterns', () => {
       const patterns = [
         createPattern({ id: 'p1', confidence: 90, lastSeen: new Date('2025-08-01').toISOString() }),
@@ -212,8 +201,8 @@ describe('Pattern Decay Algorithm', () => {
         createPattern({ id: 'p3', confidence: 70, lastSeen: new Date('2025-08-01').toISOString() })
       ];
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = applyDecayToStoredPatterns(patterns, config);
 
@@ -221,8 +210,6 @@ describe('Pattern Decay Algorithm', () => {
       expect(decayed[0].confidence).toBeLessThan(90);
       expect(decayed[1].confidence).toBeLessThan(80);
       expect(decayed[2].confidence).toBeLessThan(70);
-
-      jest.restoreAllMocks();
     });
 
     test('handles empty pattern array', () => {
@@ -237,34 +224,31 @@ describe('Pattern Decay Algorithm', () => {
     test('renews a single pattern', () => {
       const pattern = createPattern({ confidence: 65 });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
-
       const renewed = renewStoredPattern(pattern, config);
 
       expect(renewed.confidence).toBe(75);
       expect(renewed.timesRenewed).toBe(1);
-
-      jest.restoreAllMocks();
     });
   });
 
   describe('Edge Cases', () => {
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
     test('handles very old patterns (6+ months)', () => {
       const oldPattern = createPattern({
         confidence: 80,
         lastSeen: new Date('2024-12-01').toISOString()
       });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = calculateDecay(oldPattern, config);
 
       // Should have significantly decayed after 10 months
       expect(decayed.confidence).toBeLessThan(40);
-
-      jest.restoreAllMocks();
     });
 
     test('handles pattern oscillation (multiple renewals)', () => {
@@ -306,15 +290,13 @@ describe('Pattern Decay Algorithm', () => {
         lastSeen: new Date('2025-08-01').toISOString()
       });
 
-      const mockDate = new Date('2025-10-01');
-      jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2025-10-01'));
 
       const decayed = calculateDecay(maxPattern, config);
 
       expect(decayed.confidence).toBeLessThan(100);
       expect(decayed.confidence).toBeGreaterThan(0);
-
-      jest.restoreAllMocks();
     });
   });
 

package/tests/session-manager.test.js

@@ -132,6 +132,131 @@ describe('SessionManager', () => {
     });
   });
 
+  describe('getSessionsWithDetails', () => {
+    it('should return empty array when no sessions exist', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+      const sessions = await manager.getSessionsWithDetails();
+
+      expect(sessions).toEqual([]);
+    });
+
+    it('should count answered and unanswered questions correctly', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-details');
+      await fs.ensureDir(sessionPath);
+
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+
+      // Simulate 2 answered questions (rapid has 10 questions starting with prp-1, prp-2, etc.)
+      tracker.progress.answers['prp-1'] = { text: 'Answer 1', quality: { qualityScore: 80, wordCount: 10, isComprehensive: true }, timestamp: new Date().toISOString() };
+      tracker.progress.answers['prp-2'] = { text: 'Answer 2', quality: { qualityScore: 75, wordCount: 8, isComprehensive: false }, timestamp: new Date().toISOString() };
+      await tracker.save();
+
+      const sessions = await manager.getSessionsWithDetails();
+
+      expect(sessions.length).toBe(1);
+      expect(sessions[0].totalQuestions).toBe(10); // rapid/prp has 10 questions
+      expect(sessions[0].answeredCount).toBe(2);
+      expect(sessions[0].unansweredCount).toBe(8);
+      expect(sessions[0].hasGaps).toBe(true);
+    });
+
+    it('should report hasGaps false when all questions answered', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-full');
+      await fs.ensureDir(sessionPath);
+
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+
+      // Simulate all 10 PRP questions answered
+      for (let i = 1; i <= 10; i++) {
+        tracker.progress.answers[`prp-${i}`] = {
+          text: `Answer ${i}`,
+          quality: { qualityScore: 80, wordCount: 10, isComprehensive: true },
+          timestamp: new Date().toISOString()
+        };
+      }
+      await tracker.save();
+
+      const sessions = await manager.getSessionsWithDetails();
+
+      expect(sessions.length).toBe(1);
+      expect(sessions[0].answeredCount).toBe(10);
+      expect(sessions[0].unansweredCount).toBe(0);
+      expect(sessions[0].hasGaps).toBe(false);
+    });
+
+    it('should ignore answer keys that do not match framework questions', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-stale');
+      await fs.ensureDir(sessionPath);
+
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+
+      // Add a valid answer and a stale/invalid key
+      tracker.progress.answers['prp-1'] = { text: 'Answer 1', quality: { qualityScore: 80, wordCount: 10, isComprehensive: true }, timestamp: new Date().toISOString() };
+      tracker.progress.answers['old-removed-question'] = { text: 'Stale', quality: { qualityScore: 50, wordCount: 3, isComprehensive: false }, timestamp: new Date().toISOString() };
+      await tracker.save();
+
+      const sessions = await manager.getSessionsWithDetails();
+
+      expect(sessions[0].answeredCount).toBe(1); // only prp-1 counts
+      expect(sessions[0].unansweredCount).toBe(9);
+    });
+  });
+
+  describe('reopenSession', () => {
+    it('should reset counters but preserve answers', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      const sessionPath = path.join(TEST_SESSIONS_DIR, 'session-reopen');
+      await fs.ensureDir(sessionPath);
+
+      const tracker = new ProgressTracker(sessionPath, 5, 'rapid');
+      await tracker.initialize();
+
+      // Simulate some progress and complete
+      tracker.progress.answers['prp-1'] = { text: 'Answer 1', quality: { qualityScore: 80, wordCount: 10, isComprehensive: true }, timestamp: new Date().toISOString() };
+      tracker.progress.completedBlocks = [{ number: 1, title: 'Block 1', questionsAnswered: 1, completedAt: new Date().toISOString() }];
+      tracker.progress.totalQuestionsAnswered = 1;
+      tracker.progress.currentBlock = 1;
+      await tracker.complete();
+
+      // Verify it's completed
+      const beforeReopen = await fs.readJson(path.join(sessionPath, '_progress.json'));
+      expect(beforeReopen.status).toBe('completed');
+      expect(beforeReopen.canResume).toBe(false);
+
+      // Reopen it
+      const result = await manager.reopenSession('session-reopen');
+
+      expect(result.progress.status).toBe('in-progress');
+      expect(result.progress.canResume).toBe(true);
+      expect(result.progress.completedAt).toBeNull();
+      expect(result.progress.completedBlocks).toEqual([]);
+      expect(result.progress.skippedBlocks).toEqual([]);
+      expect(result.progress.totalQuestionsAnswered).toBe(0);
+      expect(result.progress.currentBlock).toBe(0);
+
+      // Answers should be preserved
+      expect(result.progress.answers['prp-1']).toBeDefined();
+      expect(result.progress.answers['prp-1'].text).toBe('Answer 1');
+    });
+
+    it('should throw error for non-existent session', async () => {
+      const manager = new SessionManager(TEST_PROJECT_PATH);
+
+      await expect(manager.reopenSession('non-existent'))
+        .rejects.toThrow('Session not found: non-existent');
+    });
+  });
+
   describe('deleteAllSessions', () => {
     it('should delete all sessions and recreate directory', async () => {
       const manager = new SessionManager(TEST_PROJECT_PATH);