@iservu-inc/adf-cli 0.17.1 → 0.18.0

package/tests/harness-event-logger.test.js

@@ -0,0 +1,148 @@
+const fs = require('fs-extra');
+const path = require('path');
+const EventLogger = require('../lib/harness/event-logger');
+const { Event } = require('../lib/harness/protocol');
+
+describe('EventLogger', () => {
+  const tempDir = path.join(__dirname, 'temp-event-logger-test');
+  const eventsFile = path.join(tempDir, '_events.jsonl');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should create logger for run directory', () => {
+    const logger = EventLogger.forRun(tempDir);
+    expect(logger.filePath).toBe(eventsFile);
+  });
+
+  test('should log and read events', async () => {
+    const logger = new EventLogger(eventsFile);
+
+    await logger.log({ type: 'answer', runId: 'run_1', data: { questionId: 'q1' } });
+    await logger.log({ type: 'skip', runId: 'run_1', data: { questionId: 'q2' } });
+
+    const events = await logger.readAll();
+    expect(events.length).toBe(2);
+    expect(events[0].type).toBe('answer');
+    expect(events[1].type).toBe('skip');
+  });
+
+  test('should accept Event instances', async () => {
+    const logger = new EventLogger(eventsFile);
+    const event = new Event({ type: 'checkpoint', runId: 'run_1', data: { message: 'test' } });
+
+    await logger.log(event);
+    const events = await logger.readAll();
+    expect(events.length).toBe(1);
+    expect(events[0].data.message).toBe('test');
+  });
+
+  test('should reject invalid events', async () => {
+    const logger = new EventLogger(eventsFile);
+    await expect(logger.log({ type: 'invalid_type', runId: 'run_1' }))
+      .rejects.toThrow('Invalid event');
+  });
+
+  test('should query by type', async () => {
+    const logger = new EventLogger(eventsFile);
+
+    await logger.log({ type: 'answer', runId: 'run_1', data: { q: 'q1' } });
+    await logger.log({ type: 'skip', runId: 'run_1', data: { q: 'q2' } });
+    await logger.log({ type: 'answer', runId: 'run_1', data: { q: 'q3' } });
+
+    const answers = await logger.queryByType('answer');
+    expect(answers.length).toBe(2);
+
+    const skips = await logger.queryByType('skip');
+    expect(skips.length).toBe(1);
+  });
+
+  test('should reject invalid query type', async () => {
+    const logger = new EventLogger(eventsFile);
+    await expect(logger.queryByType('fake')).rejects.toThrow('Invalid event type');
+  });
+
+  test('should query by context window', async () => {
+    const logger = new EventLogger(eventsFile);
+
+    await logger.log({ type: 'answer', runId: 'run_1', contextWindowId: 'cw_1', data: {} });
+    await logger.log({ type: 'answer', runId: 'run_1', contextWindowId: 'cw_2', data: {} });
+    await logger.log({ type: 'skip', runId: 'run_1', contextWindowId: 'cw_1', data: {} });
+
+    const cw1Events = await logger.queryByWindow('cw_1');
+    expect(cw1Events.length).toBe(2);
+
+    const cw2Events = await logger.queryByWindow('cw_2');
+    expect(cw2Events.length).toBe(1);
+  });
+
+  test('should query by time range', async () => {
+    const logger = new EventLogger(eventsFile);
+    const now = new Date();
+
+    await logger.log({
+      type: 'answer', runId: 'run_1',
+      timestamp: new Date(now.getTime() - 60000).toISOString(),
+      data: { q: 'old' }
+    });
+    await logger.log({
+      type: 'answer', runId: 'run_1',
+      timestamp: now.toISOString(),
+      data: { q: 'new' }
+    });
+
+    const recent = await logger.queryByTimeRange(
+      new Date(now.getTime() - 30000).toISOString(),
+      new Date(now.getTime() + 1000).toISOString()
+    );
+    expect(recent.length).toBe(1);
+    expect(recent[0].data.q).toBe('new');
+  });
+
+  test('should tail last N events', async () => {
+    const logger = new EventLogger(eventsFile);
+
+    for (let i = 0; i < 5; i++) {
+      await logger.log({ type: 'checkpoint', runId: 'run_1', data: { i } });
+    }
+
+    const last2 = await logger.tail(2);
+    expect(last2.length).toBe(2);
+    expect(last2[0].data.i).toBe(3);
+    expect(last2[1].data.i).toBe(4);
+  });
+
+  test('should get stats', async () => {
+    const logger = new EventLogger(eventsFile);
+
+    await logger.log({ type: 'answer', runId: 'run_1', data: {} });
+    await logger.log({ type: 'answer', runId: 'run_1', data: {} });
+    await logger.log({ type: 'skip', runId: 'run_1', data: {} });
+    await logger.log({ type: 'error', runId: 'run_1', data: {} });
+
+    const stats = await logger.getStats();
+    expect(stats.total).toBe(4);
+    expect(stats.byType.answer).toBe(2);
+    expect(stats.byType.skip).toBe(1);
+    expect(stats.byType.error).toBe(1);
+  });
+
+  test('should return empty array when file does not exist', async () => {
+    const logger = new EventLogger(path.join(tempDir, 'nonexistent.jsonl'));
+    const events = await logger.readAll();
+    expect(events).toEqual([]);
+  });
+
+  test('should check existence', async () => {
+    const logger = new EventLogger(eventsFile);
+    expect(await logger.exists()).toBe(false);
+
+    await logger.log({ type: 'checkpoint', runId: 'run_1', data: {} });
+    expect(await logger.exists()).toBe(true);
+  });
+});

package/tests/harness-feature-manifest.test.js

@@ -0,0 +1,124 @@
+const fs = require('fs-extra');
+const path = require('path');
+const FeatureManifestManager = require('../lib/harness/feature-manifest');
+
+describe('FeatureManifestManager', () => {
+  const tempDir = path.join(__dirname, 'temp-feature-manifest-test');
+  let manager;
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+    manager = new FeatureManifestManager(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should generate from explicit feature list', async () => {
+    const manifest = await manager.generateFromList('run_1', [
+      { title: 'User Auth', description: 'Login/signup flow' },
+      { title: 'Dashboard', description: 'Admin dashboard' }
+    ]);
+
+    expect(manifest.features.length).toBe(2);
+    expect(manifest.features[0].title).toBe('User Auth');
+    expect(manifest.features[0].passes).toBe(false);
+  });
+
+  test('should mark passes (only mutation)', async () => {
+    await manager.generateFromList('run_1', [
+      { title: 'Feature A' },
+      { title: 'Feature B' }
+    ]);
+
+    const featId = manager.getManifest().features[0].id;
+    const feature = await manager.markPasses(featId);
+    expect(feature.passes).toBe(true);
+    expect(feature.status).toBe('passes');
+  });
+
+  test('should throw on unknown feature', async () => {
+    await manager.generateFromList('run_1', [{ title: 'X' }]);
+    await expect(manager.markPasses('feat_nonexistent')).rejects.toThrow('Feature not found');
+  });
+
+  test('should track progress', async () => {
+    await manager.generateFromList('run_1', [
+      { title: 'A' }, { title: 'B' }, { title: 'C' }
+    ]);
+
+    let progress = manager.getProgress();
+    expect(progress.total).toBe(3);
+    expect(progress.passed).toBe(0);
+    expect(progress.percentage).toBe(0);
+
+    const featId = manager.getManifest().features[0].id;
+    await manager.markPasses(featId);
+
+    progress = manager.getProgress();
+    expect(progress.passed).toBe(1);
+    expect(progress.percentage).toBe(33);
+  });
+
+  test('should save and load', async () => {
+    await manager.generateFromList('run_1', [
+      { title: 'Feature X', description: 'Does X' }
+    ]);
+
+    const manager2 = new FeatureManifestManager(tempDir);
+    const loaded = await manager2.load();
+    expect(loaded).toBe(true);
+    expect(manager2.getManifest().features[0].title).toBe('Feature X');
+  });
+
+  test('should return false when no manifest to load', async () => {
+    const loaded = await manager.load();
+    expect(loaded).toBe(false);
+  });
+
+  test('should extract features from markdown', async () => {
+    const markdown = `# Project Plan
+
+## Overview
+This is the overview section.
+
+## User Authentication
+Implement login and signup with OAuth2.
+
+## Dashboard Widget
+Interactive charts for analytics.
+
+## Appendix
+Reference material.
+`;
+
+    const manifest = await manager.generateFromSession('run_1', { prd: markdown });
+    const titles = manifest.features.map(f => f.title);
+
+    expect(titles).toContain('User Authentication');
+    expect(titles).toContain('Dashboard Widget');
+    // Should skip Overview and Appendix (generic headers)
+    expect(titles).not.toContain('Overview');
+    expect(titles).not.toContain('Appendix');
+  });
+
+  test('should extract from multiple outputs', async () => {
+    const manifest = await manager.generateFromSession('run_1', {
+      prp: '## Feature One\nDoes one thing.\n',
+      specification: '## Feature Two\nDoes another thing.\n'
+    });
+
+    expect(manifest.features.length).toBe(2);
+  });
+
+  test('should return zero progress when no manifest', () => {
+    const progress = manager.getProgress();
+    expect(progress.total).toBe(0);
+  });
+
+  test('should throw when marking passes without loaded manifest', async () => {
+    // No manifest generated or loaded
+    await expect(manager.markPasses('feat_x')).rejects.toThrow('No feature manifest loaded');
+  });
+});

package/tests/harness-headless-adapter.test.js

@@ -0,0 +1,196 @@
+const fs = require('fs-extra');
+const path = require('path');
+const HeadlessAdapter = require('../lib/harness/headless-adapter');
+
+describe('HeadlessAdapter', () => {
+  const tempDir = path.join(__dirname, 'temp-headless-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should create with mapped answers', () => {
+    const adapter = new HeadlessAdapter({
+      'q1': 'React',
+      'q2': 'TypeScript'
+    });
+
+    expect(adapter.getAnswer('q1')).toBe('React');
+    expect(adapter.getAnswer('q2')).toBe('TypeScript');
+  });
+
+  test('should create with ordered answers', () => {
+    const adapter = new HeadlessAdapter([
+      'First answer',
+      'Second answer',
+      'Third answer'
+    ]);
+
+    expect(adapter.getAnswer('q1', 'Question 1?')).toBe('First answer');
+    expect(adapter.getAnswer('q2', 'Question 2?')).toBe('Second answer');
+    expect(adapter.getAnswer('q3', 'Question 3?')).toBe('Third answer');
+  });
+
+  test('should use default answer as fallback', () => {
+    const adapter = new HeadlessAdapter({
+      'q1': 'Specific answer'
+    });
+    adapter.defaultAnswer = 'I will provide this later.';
+
+    expect(adapter.getAnswer('q1')).toBe('Specific answer');
+    expect(adapter.getAnswer('q_unknown')).toBe('I will provide this later.');
+  });
+
+  test('should support function default answer', () => {
+    const adapter = new HeadlessAdapter();
+    adapter.defaultAnswer = (id, text) => `Auto-answer for ${id}`;
+
+    expect(adapter.getAnswer('q1', 'What framework?')).toBe('Auto-answer for q1');
+  });
+
+  test('should return null when no answer available', () => {
+    const adapter = new HeadlessAdapter();
+    expect(adapter.getAnswer('q1')).toBeNull();
+  });
+
+  test('should load from JSON file', async () => {
+    const inputFile = path.join(tempDir, 'input.json');
+    await fs.writeJson(inputFile, {
+      answers: { 'q1': 'React', 'q2': 'PostgreSQL' },
+      defaultAnswer: 'TBD'
+    });
+
+    const adapter = new HeadlessAdapter();
+    await adapter.loadFromFile(inputFile);
+
+    expect(adapter.getAnswer('q1')).toBe('React');
+    expect(adapter.getAnswer('q_other')).toBe('TBD');
+  });
+
+  test('should load ordered answers from file', async () => {
+    const inputFile = path.join(tempDir, 'ordered.json');
+    await fs.writeJson(inputFile, {
+      orderedAnswers: ['Answer 1', 'Answer 2']
+    });
+
+    const adapter = new HeadlessAdapter();
+    await adapter.loadFromFile(inputFile);
+
+    expect(adapter.getAnswer('q1')).toBe('Answer 1');
+    expect(adapter.getAnswer('q2')).toBe('Answer 2');
+  });
+
+  test('should throw on missing file', async () => {
+    const adapter = new HeadlessAdapter();
+    await expect(adapter.loadFromFile('/nonexistent/file.json'))
+      .rejects.toThrow('not found');
+  });
+
+  test('should initialize from string source (file path)', async () => {
+    const inputFile = path.join(tempDir, 'init-test.json');
+    await fs.writeJson(inputFile, { answers: { 'q1': 'Value' } });
+
+    const adapter = new HeadlessAdapter(inputFile);
+    await adapter.initialize();
+
+    expect(adapter.getAnswer('q1')).toBe('Value');
+  });
+
+  test('should handle choice selection', () => {
+    const adapter = new HeadlessAdapter({ 'workflow': 'balanced' });
+
+    const choices = [
+      { name: 'Rapid', value: 'rapid' },
+      { name: 'Balanced', value: 'balanced' },
+      { name: 'Comprehensive', value: 'comprehensive' }
+    ];
+
+    expect(adapter.getChoice('workflow', choices)).toBe('balanced');
+  });
+
+  test('should return default choice when no mapping', () => {
+    const adapter = new HeadlessAdapter();
+
+    const choices = [
+      { name: 'A', value: 'a' },
+      { name: 'B', value: 'b' }
+    ];
+
+    expect(adapter.getChoice('unknown', choices, 'a')).toBe('a');
+  });
+
+  test('should return first choice as last resort', () => {
+    const adapter = new HeadlessAdapter();
+
+    const choices = [
+      { name: 'First', value: 'first' },
+      { name: 'Second', value: 'second' }
+    ];
+
+    expect(adapter.getChoice('unknown', choices)).toBe('first');
+  });
+
+  test('should handle string choices', () => {
+    const adapter = new HeadlessAdapter({ 'q': 'option-b' });
+    const choices = ['option-a', 'option-b', 'option-c'];
+    expect(adapter.getChoice('q', choices)).toBe('option-b');
+  });
+
+  test('should handle confirmation', () => {
+    const adapter = new HeadlessAdapter({ 'confirm': true, 'deny': 'no' });
+
+    expect(adapter.getConfirmation('confirm')).toBe(true);
+    expect(adapter.getConfirmation('deny')).toBe(false);
+    expect(adapter.getConfirmation('unknown', true)).toBe(true);
+    expect(adapter.getConfirmation('unknown', false)).toBe(false);
+  });
+
+  test('should check if more answers available', () => {
+    const adapter = new HeadlessAdapter(['a', 'b']);
+    expect(adapter.hasMoreAnswers()).toBe(true);
+
+    adapter.getAnswer('q1');
+    adapter.getAnswer('q2');
+    expect(adapter.hasMoreAnswers()).toBe(false);
+  });
+
+  test('should track interaction log', () => {
+    const adapter = new HeadlessAdapter({ 'q1': 'React' });
+    adapter.getAnswer('q1', 'What framework?');
+    adapter.getAnswer('q2', 'What database?');
+
+    const log = adapter.getLog();
+    expect(log.length).toBe(2);
+    expect(log[0].questionId).toBe('q1');
+    expect(log[0].answer).toBe('React');
+    expect(log[1].answer).toBeNull();
+  });
+
+  test('should get stats', () => {
+    const adapter = new HeadlessAdapter({ 'q1': 'React' });
+    adapter.getAnswer('q1', 'What framework?');
+    adapter.getAnswer('q2', 'What database?');
+
+    const stats = adapter.getStats();
+    expect(stats.totalQuestions).toBe(2);
+    expect(stats.answered).toBe(1);
+    expect(stats.unanswered).toBe(1);
+  });
+
+  test('should export log to file', async () => {
+    const adapter = new HeadlessAdapter({ 'q1': 'React' });
+    adapter.getAnswer('q1', 'What framework?');
+
+    const logFile = path.join(tempDir, 'log.json');
+    await adapter.exportLog(logFile);
+
+    expect(await fs.pathExists(logFile)).toBe(true);
+    const data = await fs.readJson(logFile);
+    expect(data.stats.totalQuestions).toBe(1);
+    expect(data.log.length).toBe(1);
+  });
+});

package/tests/harness-integration.test.js

@@ -0,0 +1,207 @@
+const fs = require('fs-extra');
+const path = require('path');
+const RunManager = require('../lib/harness/run-manager');
+const ContextWindowManager = require('../lib/harness/context-window-manager');
+const MilestoneTracker = require('../lib/harness/milestone-tracker');
+const FeatureManifestManager = require('../lib/harness/feature-manifest');
+const EventLogger = require('../lib/harness/event-logger');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+
+describe('Harness Integration', () => {
+  const tempDir = path.join(__dirname, 'temp-harness-integration');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('full lifecycle: create > answer > handoff > resume > complete', async () => {
+    // Phase 1: Create run
+    const manager = new RunManager(tempDir);
+    const run = await manager.createRun({
+      workflow: 'balanced',
+      provider: { id: 'anthropic', model: 'claude-opus-4-6', contextWindowSize: 200000 },
+      sessionId: 'test-session-1'
+    });
+
+    expect(run.status).toBe('initializing');
+    const started = await manager.startRun(run.id);
+    expect(started.status).toBe('running');
+
+    // Phase 2: Open context window
+    const runDir = manager.getRunDir(run.id);
+    const cwManager = new ContextWindowManager(runDir, run.id);
+    const window1 = await cwManager.openWindow({ tokenLimit: 100000 });
+
+    expect(window1.sequence).toBe(1);
+    expect(window1.status).toBe('active');
+
+    // Phase 3: Generate milestones
+    const milestoneTracker = new MilestoneTracker(runDir);
+    await milestoneTracker.generateFromBlocks([
+      { title: 'Overview', number: 1, questions: [{ id: 'q1' }, { id: 'q2' }] },
+      { title: 'Architecture', number: 2, questions: [{ id: 'q3' }, { id: 'q4' }] },
+      { title: 'Features', number: 3, questions: [{ id: 'q5' }] }
+    ]);
+
+    // Phase 4: Simulate answering questions
+    cwManager.recordQuestionAnswered('q1');
+    cwManager.recordQuestionAnswered('q2');
+    await milestoneTracker.completeQuestion('q1');
+    await milestoneTracker.completeQuestion('q2');
+
+    const logger = EventLogger.forRun(runDir);
+    await logger.log({
+      type: 'answer', runId: run.id, contextWindowId: window1.id,
+      data: { questionId: 'q1', quality: 85 }
+    });
+    await logger.log({
+      type: 'answer', runId: run.id, contextWindowId: window1.id,
+      data: { questionId: 'q2', quality: 90 }
+    });
+
+    // Simulate knowledge extraction
+    const kgSessionDir = path.join(tempDir, '.adf', 'sessions', 'test-session');
+    await fs.ensureDir(kgSessionDir);
+    const kg = new KnowledgeGraph(kgSessionDir);
+    kg.add([
+      { type: 'tech_stack', content: 'React with TypeScript', confidence: 90, source: 'q1' },
+      { type: 'architecture', content: 'Microservices with API gateway', confidence: 85, source: 'q2' }
+    ]);
+
+    // Phase 5: Generate handoff package
+    const handoff = await cwManager.generateHandoffPackage({
+      progressSummary: 'Completed Overview block (2 of 5 questions answered)',
+      completedWork: ['Block 1: Overview'],
+      nextSteps: ['Block 2: Architecture'],
+      currentMilestone: milestoneTracker.getHandoffInfo(),
+      knowledgeGraph: kg.toHandoffFormat(),
+      criticalAnswers: [
+        { questionId: 'q1', summary: 'React with TypeScript', quality: 85 },
+        { questionId: 'q2', summary: 'Microservices', quality: 90 }
+      ],
+      position: {
+        currentBlock: 2,
+        totalBlocks: 3,
+        answeredIds: ['q1', 'q2'],
+        remainingIds: ['q3', 'q4', 'q5']
+      },
+      activeRules: [],
+      sourceProviderId: 'anthropic'
+    });
+
+    expect(handoff.position.answeredIds).toEqual(['q1', 'q2']);
+    expect(handoff.knowledgeGraph.highConfidenceItems.length).toBe(2);
+
+    // Phase 6: Close window, pause run
+    await cwManager.closeWindow('completed');
+    const paused = await manager.pauseRun(run.id);
+    expect(paused.status).toBe('paused');
+
+    // Phase 7: Resume run in new context window
+    const resumed = await manager.resumeRun(run.id);
+    expect(resumed.status).toBe('running');
+
+    const window2 = await cwManager.openWindow({ tokenLimit: 100000 });
+    expect(window2.sequence).toBe(2);
+    expect(window2.previousWindowId).toBe(window1.id);
+
+    // Phase 8: Consume handoff
+    const consumedHandoff = await cwManager.consumeHandoffPackage('latest');
+    expect(consumedHandoff).not.toBeNull();
+    expect(consumedHandoff.progressSummary).toContain('Completed Overview');
+    expect(consumedHandoff.position.answeredIds).toEqual(['q1', 'q2']);
+
+    // Restore knowledge from handoff
+    const kg2 = new KnowledgeGraph(kgSessionDir);
+    kg2.fromHandoffFormat(consumedHandoff.knowledgeGraph);
+    expect(kg2.has('tech_stack', 90)).toBe(true);
+    expect(kg2.has('architecture', 85)).toBe(true);
+
+    // Phase 9: Continue answering
+    cwManager.recordQuestionAnswered('q3');
+    cwManager.recordQuestionAnswered('q4');
+    cwManager.recordQuestionAnswered('q5');
+    await milestoneTracker.completeQuestion('q3');
+    await milestoneTracker.completeQuestion('q4');
+    await milestoneTracker.completeQuestion('q5');
+
+    // Phase 10: Complete run
+    const completed = await manager.completeRun(run.id);
+    expect(completed.status).toBe('completed');
+
+    // Verify final state
+    const milestoneProgress = milestoneTracker.getProgress();
+    expect(milestoneProgress.completed).toBe(3);
+    expect(milestoneProgress.percentage).toBe(100);
+
+    // Verify event log
+    const stats = await logger.getStats();
+    expect(stats.total).toBeGreaterThan(0);
+    expect(stats.byType.answer).toBe(2);
+
+    // Verify windows
+    const allWindows = await cwManager.listWindows();
+    expect(allWindows.length).toBe(2);
+  });
+
+  test('feature manifest lifecycle', async () => {
+    const manager = new RunManager(tempDir);
+    const run = await manager.createRun({ workflow: 'rapid' });
+    const runDir = manager.getRunDir(run.id);
+
+    const manifestManager = new FeatureManifestManager(runDir);
+    await manifestManager.generateFromList(run.id, [
+      { title: 'User Authentication', description: 'Login/signup' },
+      { title: 'Dashboard', description: 'Admin panel' },
+      { title: 'API Endpoints', description: 'REST API' }
+    ]);
+
+    let progress = manifestManager.getProgress();
+    expect(progress.total).toBe(3);
+    expect(progress.passed).toBe(0);
+
+    // Mark features as passing
+    const features = manifestManager.getManifest().features;
+    await manifestManager.markPasses(features[0].id);
+    await manifestManager.markPasses(features[2].id);
+
+    progress = manifestManager.getProgress();
+    expect(progress.passed).toBe(2);
+    expect(progress.percentage).toBe(67);
+
+    // Verify persistence
+    const manifestManager2 = new FeatureManifestManager(runDir);
+    await manifestManager2.load();
+    expect(manifestManager2.getProgress().passed).toBe(2);
+  });
+
+  test('multiple runs coexist', async () => {
+    const manager = new RunManager(tempDir);
+
+    const run1 = await manager.createRun({ workflow: 'rapid' });
+    const run2 = await manager.createRun({ workflow: 'balanced' });
+
+    // run2 should be current
+    const current = await manager.getCurrentRun();
+    expect(current.id).toBe(run2.id);
+
+    // Both should be listable
+    const runs = await manager.listRuns();
+    expect(runs.length).toBe(2);
+
+    // Complete run2, run1 still exists
+    await manager.startRun(run2.id);
+    await manager.completeRun(run2.id);
+
+    const currentAfter = await manager.getCurrentRunId();
+    expect(currentAfter).toBeNull();
+
+    const run1Loaded = await manager.loadRun(run1.id);
+    expect(run1Loaded).not.toBeNull();
+    expect(run1Loaded.workflow).toBe('rapid');
+  });
+});