@iservu-inc/adf-cli 0.17.1 → 0.18.0

package/tests/context-extractor.test.js

@@ -50,6 +50,51 @@ Add many cool features.
     expect(context.proposedChanges).toContain('Add many cool features');
   });
 
+  test('should extract context from Gemini CLI Conductor', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    await fs.writeFile(path.join(tempDir, 'conductor', 'product.md'), `# My Product
+
+## Overview
+An AI-powered task management system.
+
+## Features
+- Smart task prioritization
+- Team collaboration
+`);
+    await fs.writeFile(path.join(tempDir, 'conductor', 'tech-stack.md'), `# Tech Stack
+
+- **Language**: TypeScript
+- **Runtime**: Node.js
+- **Framework**: Express
+`);
+    await fs.writeFile(path.join(tempDir, 'conductor', 'workflow.md'), `# Development Workflow
+
+## Quality Gates
+All PRs must pass linting, tests, and review.
+`);
+
+    const context = await ContextExtractor.extract(tempDir, ['gemini-conductor']);
+    expect(context.name).toBe('My Product');
+    expect(context.overview).toContain('AI-powered task management');
+    expect(context.techStack).toContain('TypeScript');
+    expect(context.architecture).toContain('linting, tests, and review');
+  });
+
+  test('should extract Conductor context with partial files', async () => {
+    await fs.ensureDir(path.join(tempDir, 'conductor'));
+    await fs.writeFile(path.join(tempDir, 'conductor', 'product.md'), `# TaskFlow
+
+## Vision
+A next-gen project management tool.
+`);
+
+    const context = await ContextExtractor.extract(tempDir, ['gemini-conductor']);
+    expect(context.name).toBe('TaskFlow');
+    expect(context.overview).toContain('next-gen project management');
+    expect(context.techStack).toBe('');
+    expect(context.architecture).toBe('');
+  });
+
   test('should extract tech stack and architecture from specification-driven', async () => {
     const specContent = `# Specification: App Core
 

package/tests/framework-detector.test.js

@@ -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/harness-backward-compat.test.js

@@ -0,0 +1,251 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ProgressTracker = require('../lib/frameworks/progress-tracker');
+const SessionManager = require('../lib/frameworks/session-manager');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+const DynamicPipeline = require('../lib/analysis/dynamic-pipeline');
+
+describe('Harness Backward Compatibility', () => {
+  const tempDir = path.join(__dirname, 'temp-backward-compat');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('ProgressTracker', () => {
+    test('should work without harness options (backward compat)', async () => {
+      const sessionPath = path.join(tempDir, 'session-1');
+      await fs.ensureDir(sessionPath);
+
+      // Create tracker without harness options (old way)
+      const tracker = new ProgressTracker(sessionPath, 3, 'rapid');
+      await tracker.initialize();
+
+      await tracker.startBlock(1, 'Overview');
+      await tracker.answerQuestion('q1', 'What?', 'React app', {
+        wordCount: 2, qualityScore: 80, isComprehensive: true
+      });
+      await tracker.completeBlock(1, 'Overview', 1);
+
+      // Should work exactly as before
+      const progress = tracker.getProgress();
+      expect(progress.status).toBe('in-progress');
+      expect(progress.totalQuestionsAnswered).toBe(1);
+      expect(progress.answers.q1).toBeDefined();
+    });
+
+    test('should work with harness options (new way)', async () => {
+      const sessionPath = path.join(tempDir, 'session-2');
+      await fs.ensureDir(sessionPath);
+
+      const EventLogger = require('../lib/harness/event-logger');
+      const loggerPath = path.join(tempDir, '_events.jsonl');
+      const logger = new EventLogger(loggerPath);
+
+      // Create tracker with harness options (new way)
+      const tracker = new ProgressTracker(sessionPath, 3, 'balanced', null, {
+        eventLogger: logger,
+        contextWindowId: 'cw_test-1'
+      });
+      await tracker.initialize();
+
+      // Set runId so events pass validation
+      tracker.progress.runId = 'run_test-1';
+
+      await tracker.startBlock(1, 'Overview');
+      await tracker.answerQuestion('q1', 'What?', 'React app', {
+        wordCount: 2, qualityScore: 80, isComprehensive: true
+      });
+      await tracker.completeBlock(1, 'Overview', 1);
+
+      // Should emit events
+      const events = await logger.readAll();
+      expect(events.length).toBeGreaterThanOrEqual(3); // block_start + answer + block_complete
+
+      const answerEvent = events.find(e => e.type === 'answer');
+      expect(answerEvent.contextWindowId).toBe('cw_test-1');
+    });
+  });
+
+  describe('SessionManager', () => {
+    test('should work without harness (backward compat)', async () => {
+      const sessionsDir = path.join(tempDir, '.adf', 'sessions');
+      await fs.ensureDir(sessionsDir);
+
+      // Create a legacy session (no harness)
+      const sessionDir = path.join(sessionsDir, '2026-01-01T00-00-00_rapid');
+      await fs.ensureDir(sessionDir);
+      await fs.writeJson(path.join(sessionDir, '_progress.json'), {
+        sessionId: '2026-01-01T00-00-00_rapid',
+        framework: 'rapid',
+        status: 'in-progress',
+        canResume: true,
+        lastUpdated: '2026-01-01T00:00:00.000Z',
+        totalBlocks: 3,
+        currentBlock: 1,
+        completedBlocks: [],
+        skippedBlocks: [],
+        totalQuestionsAnswered: 0,
+        answers: {}
+      }, { spaces: 2 });
+
+      const manager = new SessionManager(tempDir);
+      const sessions = await manager.listSessions();
+      expect(sessions.length).toBe(1);
+
+      const resumable = await manager.getResumableSessions();
+      expect(resumable.length).toBe(1);
+    });
+
+    test('getCurrentSession should fallback to mtime when no harness', async () => {
+      const sessionsDir = path.join(tempDir, '.adf', 'sessions');
+      await fs.ensureDir(sessionsDir);
+
+      // Create two sessions
+      const session1Dir = path.join(sessionsDir, '2026-01-01T00-00-00_rapid');
+      await fs.ensureDir(session1Dir);
+      await fs.writeJson(path.join(session1Dir, '_progress.json'), {
+        sessionId: '2026-01-01T00-00-00_rapid',
+        status: 'completed',
+        lastUpdated: '2026-01-01T00:00:00.000Z',
+        completedBlocks: [],
+        answers: {}
+      });
+
+      const session2Dir = path.join(sessionsDir, '2026-02-01T00-00-00_balanced');
+      await fs.ensureDir(session2Dir);
+      await fs.writeJson(path.join(session2Dir, '_progress.json'), {
+        sessionId: '2026-02-01T00-00-00_balanced',
+        status: 'in-progress',
+        lastUpdated: '2026-02-01T00:00:00.000Z',
+        completedBlocks: [],
+        answers: {}
+      });
+
+      const manager = new SessionManager(tempDir);
+      const current = await manager.getCurrentSession();
+      // Should return most recent by lastUpdated
+      expect(current.sessionId).toBe('2026-02-01T00-00-00_balanced');
+    });
+
+    test('forkSession should copy progress and knowledge graph', async () => {
+      const sessionsDir = path.join(tempDir, '.adf', 'sessions');
+      await fs.ensureDir(sessionsDir);
+
+      // Create source session
+      const sourceDir = path.join(sessionsDir, 'source-session');
+      await fs.ensureDir(sourceDir);
+      await fs.writeJson(path.join(sourceDir, '_progress.json'), {
+        sessionId: 'source-session',
+        framework: 'balanced',
+        status: 'completed',
+        answers: { q1: { text: 'React', quality: { qualityScore: 85 } } }
+      });
+      await fs.writeJson(path.join(sourceDir, '_knowledge_graph.json'), {
+        savedAt: '2026-01-01T00:00:00.000Z',
+        knowledge: [{ type: 'tech_stack', items: [{ content: 'React', confidence: 90, sources: ['q1'] }] }]
+      });
+
+      const manager = new SessionManager(tempDir);
+      const forked = await manager.forkSession('source-session');
+
+      expect(forked.sessionId).toContain('forked');
+      expect(await fs.pathExists(path.join(forked.sessionPath, '_progress.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(forked.sessionPath, '_knowledge_graph.json'))).toBe(true);
+
+      // Verify forked progress
+      const progress = await fs.readJson(path.join(forked.sessionPath, '_progress.json'));
+      expect(progress.status).toBe('in-progress');
+      expect(progress.canResume).toBe(true);
+      expect(progress.answers.q1.text).toBe('React');
+    });
+  });
+
+  describe('KnowledgeGraph', () => {
+    test('existing methods still work unchanged', () => {
+      const kg = new KnowledgeGraph(tempDir);
+
+      // All existing methods should still work
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'architecture', content: 'Monolith', confidence: 70, source: 'q2' }
+      ]);
+
+      expect(kg.has('tech_stack', 90)).toBe(true);
+      expect(kg.get('tech_stack').length).toBe(1);
+      expect(kg.getConfidence('tech_stack')).toBe(90);
+      expect(kg.getSummary().tech_stack.count).toBe(1);
+      expect(kg.getDisplaySummary().length).toBeGreaterThan(0);
+      expect(kg.getStats().totalItems).toBe(2);
+    });
+
+    test('new handoff methods do not break existing data', () => {
+      const kg = new KnowledgeGraph(tempDir);
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' }
+      ]);
+
+      // Export to handoff
+      const handoff = kg.toHandoffFormat();
+      expect(handoff.highConfidenceItems.length).toBe(1);
+
+      // Existing data untouched
+      expect(kg.has('tech_stack', 90)).toBe(true);
+      expect(kg.getStats().totalItems).toBe(1);
+
+      // Import from handoff into new graph
+      const kg2 = new KnowledgeGraph(tempDir);
+      kg2.fromHandoffFormat(handoff);
+      expect(kg2.has('tech_stack', 90)).toBe(true);
+    });
+  });
+
+  describe('DynamicPipeline', () => {
+    test('existing methods still work unchanged', () => {
+      const pipeline = new DynamicPipeline(tempDir, null, { enabled: true });
+
+      // Existing methods
+      expect(pipeline.isEnabled()).toBe(true);
+      pipeline.setEnabled(false);
+      expect(pipeline.isEnabled()).toBe(false);
+      pipeline.setEnabled(true);
+
+      const stats = pipeline.getStats();
+      expect(stats.questionsAsked).toBe(0);
+    });
+
+    test('new serialization methods do not break existing functionality', () => {
+      const pipeline = new DynamicPipeline(tempDir, null, { enabled: true });
+      pipeline.stats.questionsAsked = 5;
+
+      // New methods
+      const serialized = pipeline.serializeForHandoff();
+      expect(serialized.stats.questionsAsked).toBe(5);
+
+      // Existing state unchanged
+      expect(pipeline.stats.questionsAsked).toBe(5);
+      expect(pipeline.isEnabled()).toBe(true);
+
+      // Deserialize into new pipeline
+      const pipeline2 = new DynamicPipeline(tempDir, null, { enabled: true });
+      pipeline2.deserializeFromHandoff(serialized);
+      expect(pipeline2.stats.questionsAsked).toBe(5);
+    });
+  });
+
+  describe('No harness directory when not using --harness', () => {
+    test('should not create harness dir for normal init flow', async () => {
+      // Simulate normal flow - just create .adf directory
+      const adfDir = path.join(tempDir, '.adf');
+      await fs.ensureDir(adfDir);
+      await fs.ensureDir(path.join(adfDir, 'sessions'));
+
+      // Harness dir should not exist
+      expect(await fs.pathExists(path.join(adfDir, 'harness'))).toBe(false);
+    });
+  });
+});

package/tests/harness-context-window.test.js

@@ -0,0 +1,310 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ContextWindowManager = require('../lib/harness/context-window-manager');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+const DynamicPipeline = require('../lib/analysis/dynamic-pipeline');
+
+describe('ContextWindowManager', () => {
+  const tempDir = path.join(__dirname, 'temp-context-window-test');
+  let manager;
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+    await fs.ensureDir(path.join(tempDir, 'context-windows'));
+    manager = new ContextWindowManager(tempDir, 'run_test');
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should open a new context window', async () => {
+    const window = await manager.openWindow();
+    expect(window.id).toMatch(/^cw_/);
+    expect(window.runId).toBe('run_test');
+    expect(window.sequence).toBe(1);
+    expect(window.status).toBe('active');
+    expect(window.previousWindowId).toBeNull();
+  });
+
+  test('should chain windows with sequence numbers', async () => {
+    const w1 = await manager.openWindow();
+    await manager.closeWindow();
+
+    const w2 = await manager.openWindow();
+    expect(w2.sequence).toBe(2);
+    expect(w2.previousWindowId).toBe(w1.id);
+  });
+
+  test('should close current window', async () => {
+    await manager.openWindow();
+    const closed = await manager.closeWindow();
+    expect(closed.status).toBe('completed');
+    expect(closed.closedAt).toBeDefined();
+    expect(manager.getCurrentWindow()).toBeNull();
+  });
+
+  test('should auto-close previous window on open', async () => {
+    const w1 = await manager.openWindow();
+    const w2 = await manager.openWindow();
+
+    // w1 should have been closed
+    const windows = await manager.listWindows();
+    const closedW1 = windows.find(w => w.id === w1.id);
+    expect(closedW1.status).toBe('completed');
+    expect(w2.status).toBe('active');
+  });
+
+  test('should generate handoff package', async () => {
+    await manager.openWindow();
+
+    const handoff = await manager.generateHandoffPackage({
+      progressSummary: 'Completed 3 of 5 blocks',
+      completedWork: ['Block 1: Overview', 'Block 2: Architecture', 'Block 3: Features'],
+      nextSteps: ['Block 4: Deployment'],
+      currentMilestone: { index: 3, title: 'Deployment', percentage: 0 },
+      knowledgeGraph: { highConfidenceItems: [{ type: 'tech_stack', content: 'React' }], totalItems: 5, typesSeen: ['tech_stack'] },
+      criticalAnswers: [{ questionId: 'q1', summary: 'React SPA', quality: 90 }],
+      position: {
+        currentBlock: 4,
+        totalBlocks: 5,
+        answeredIds: ['q1', 'q2', 'q3'],
+        remainingIds: ['q4', 'q5']
+      }
+    });
+
+    expect(handoff.progressSummary).toBe('Completed 3 of 5 blocks');
+    expect(handoff.completedWork.length).toBe(3);
+    expect(handoff.position.answeredIds.length).toBe(3);
+    expect(handoff.sourceWindowId).toBeDefined();
+  });
+
+  test('should save handoff to file', async () => {
+    const window = await manager.openWindow();
+    await manager.generateHandoffPackage({
+      progressSummary: 'Test handoff'
+    });
+
+    const handoffFile = path.join(tempDir, 'context-windows', `${window.id}_handoff.json`);
+    expect(await fs.pathExists(handoffFile)).toBe(true);
+  });
+
+  test('should consume handoff package', async () => {
+    // Window 1: generate handoff
+    const w1 = await manager.openWindow();
+    await manager.generateHandoffPackage({
+      progressSummary: 'Half done',
+      position: { currentBlock: 3, totalBlocks: 6, answeredIds: ['q1', 'q2'], remainingIds: ['q3'] }
+    });
+    await manager.closeWindow();
+
+    // Window 2: consume handoff
+    await manager.openWindow();
+    const handoff = await manager.consumeHandoffPackage(w1.id);
+    expect(handoff).not.toBeNull();
+    expect(handoff.progressSummary).toBe('Half done');
+    expect(handoff.position.answeredIds).toEqual(['q1', 'q2']);
+  });
+
+  test('should consume latest handoff', async () => {
+    // Generate two handoffs
+    await manager.openWindow();
+    await manager.generateHandoffPackage({ progressSummary: 'First' });
+    await manager.closeWindow();
+
+    await manager.openWindow();
+    await manager.generateHandoffPackage({ progressSummary: 'Second' });
+    await manager.closeWindow();
+
+    // Consume latest
+    await manager.openWindow();
+    const handoff = await manager.consumeHandoffPackage('latest');
+    expect(handoff.progressSummary).toBe('Second');
+  });
+
+  test('should return null when no handoff available', async () => {
+    const handoff = await manager.consumeHandoffPackage('cw_nonexistent');
+    expect(handoff).toBeNull();
+  });
+
+  test('should record questions and blocks', async () => {
+    await manager.openWindow();
+
+    manager.recordQuestionAnswered('q1');
+    manager.recordQuestionAnswered('q2');
+    manager.recordBlockCompleted(1);
+
+    const window = manager.getCurrentWindow();
+    expect(window.questionsAnswered).toEqual(['q1', 'q2']);
+    expect(window.blocksCompleted).toEqual([1]);
+  });
+
+  test('should record knowledge types (no duplicates)', async () => {
+    await manager.openWindow();
+
+    manager.recordKnowledgeAdded('tech_stack');
+    manager.recordKnowledgeAdded('architecture');
+    manager.recordKnowledgeAdded('tech_stack'); // duplicate
+
+    const window = manager.getCurrentWindow();
+    expect(window.knowledgeAdded).toEqual(['tech_stack', 'architecture']);
+  });
+
+  test('should track token consumption', async () => {
+    await manager.openWindow({ tokenLimit: 100000 });
+
+    await manager.updateTokens(5000);
+    await manager.updateTokens(3000);
+
+    const window = manager.getCurrentWindow();
+    expect(window.tokensConsumed).toBe(8000);
+  });
+
+  test('should detect approaching token limit', async () => {
+    await manager.openWindow({ tokenLimit: 10000 });
+
+    expect(manager.isApproachingLimit()).toBe(false);
+
+    await manager.updateTokens(8600);
+    expect(manager.isApproachingLimit()).toBe(true);
+  });
+
+  test('should list all windows', async () => {
+    await manager.openWindow();
+    await manager.closeWindow();
+    await manager.openWindow();
+    await manager.closeWindow();
+    await manager.openWindow();
+
+    const windows = await manager.listWindows();
+    expect(windows.length).toBe(3);
+    expect(windows[0].sequence).toBe(1);
+    expect(windows[2].sequence).toBe(3);
+  });
+});
+
+describe('KnowledgeGraph Handoff Methods', () => {
+  const tempDir = path.join(__dirname, 'temp-kg-handoff-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should export to handoff format', () => {
+    const kg = new KnowledgeGraph(tempDir);
+    kg.add([
+      { type: 'tech_stack', content: 'React with TypeScript for the frontend', confidence: 90, source: 'q1' },
+      { type: 'architecture', content: 'Microservices with API gateway', confidence: 85, source: 'q2' },
+      { type: 'timeline', content: 'Some low confidence item', confidence: 50, source: 'q3' }
+    ]);
+
+    const handoff = kg.toHandoffFormat(70);
+    expect(handoff.highConfidenceItems.length).toBe(2);
+    expect(handoff.totalItems).toBe(3);
+    expect(handoff.typesSeen).toContain('tech_stack');
+    expect(handoff.typesSeen).toContain('architecture');
+    expect(handoff.typesSeen).toContain('timeline');
+  });
+
+  test('should truncate long content in handoff', () => {
+    const kg = new KnowledgeGraph(tempDir);
+    const longContent = 'A'.repeat(300);
+    kg.add([{ type: 'tech_stack', content: longContent, confidence: 90, source: 'q1' }]);
+
+    const handoff = kg.toHandoffFormat(70, 200);
+    expect(handoff.highConfidenceItems[0].content.length).toBeLessThanOrEqual(203); // 200 + '...'
+  });
+
+  test('should restore from handoff format', () => {
+    const kg = new KnowledgeGraph(tempDir);
+    kg.fromHandoffFormat({
+      highConfidenceItems: [
+        { type: 'tech_stack', content: 'React', confidence: 90, sources: ['q1'] },
+        { type: 'architecture', content: 'REST API', confidence: 85, sources: ['q2'] }
+      ],
+      totalItems: 2,
+      typesSeen: ['tech_stack', 'architecture']
+    });
+
+    expect(kg.has('tech_stack', 90)).toBe(true);
+    expect(kg.has('architecture', 85)).toBe(true);
+    expect(kg.getStats().totalItems).toBe(2);
+  });
+
+  test('should handle empty handoff data', () => {
+    const kg = new KnowledgeGraph(tempDir);
+    kg.fromHandoffFormat(null);
+    expect(kg.getStats().totalItems).toBe(0);
+
+    kg.fromHandoffFormat({});
+    expect(kg.getStats().totalItems).toBe(0);
+  });
+
+  test('should get high confidence snapshot', () => {
+    const kg = new KnowledgeGraph(tempDir);
+    kg.add([
+      { type: 'tech_stack', content: 'React', confidence: 95, source: 'q1' },
+      { type: 'tech_stack', content: 'Node.js', confidence: 70, source: 'q2' },
+      { type: 'architecture', content: 'Monolith', confidence: 85, source: 'q3' }
+    ]);
+
+    const snapshot = kg.getHighConfidenceSnapshot();
+    expect(snapshot.tech_stack.length).toBe(1); // Only 95 confidence one
+    expect(snapshot.architecture.length).toBe(1);
+  });
+});
+
+describe('DynamicPipeline Serialization', () => {
+  const tempDir = path.join(__dirname, 'temp-pipeline-handoff-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should serialize pipeline state', () => {
+    const pipeline = new DynamicPipeline(tempDir, null, { enabled: true });
+    pipeline.stats.questionsAsked = 5;
+    pipeline.stats.questionsSkipped = 2;
+
+    // Add some knowledge
+    pipeline.knowledgeGraph.add([
+      { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' }
+    ]);
+
+    const serialized = pipeline.serializeForHandoff();
+    expect(serialized.stats.questionsAsked).toBe(5);
+    expect(serialized.knowledgeGraph.highConfidenceItems.length).toBe(1);
+  });
+
+  test('should deserialize pipeline state', () => {
+    const pipeline = new DynamicPipeline(tempDir, null, { enabled: true });
+
+    pipeline.deserializeFromHandoff({
+      knowledgeGraph: {
+        highConfidenceItems: [
+          { type: 'tech_stack', content: 'Vue.js', confidence: 88, sources: ['q5'] }
+        ],
+        totalItems: 1,
+        typesSeen: ['tech_stack']
+      },
+      stats: { questionsAsked: 10, questionsSkipped: 3 }
+    });
+
+    expect(pipeline.knowledgeGraph.has('tech_stack', 88)).toBe(true);
+    expect(pipeline.stats.questionsAsked).toBe(10);
+  });
+
+  test('should handle null deserialization', () => {
+    const pipeline = new DynamicPipeline(tempDir, null, { enabled: true });
+    pipeline.deserializeFromHandoff(null);
+    expect(pipeline.stats.questionsAsked).toBe(0);
+  });
+});