sofia-cli 0.1.1

package/dist/tests/unit/sessions/exportPaths.spec.js

@@ -0,0 +1,31 @@
+/**
+ * Unit tests for export path helpers.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { getExportDir, ensureExportDir } from '../../../src/sessions/exportPaths.js';
+describe('exportPaths', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('getExportDir returns correct path', () => {
+        const dir = getExportDir('sess-42', tmpDir);
+        expect(dir).toBe(join(tmpDir, 'sess-42'));
+    });
+    it('ensureExportDir creates the directory', async () => {
+        const dir = await ensureExportDir('sess-42', tmpDir);
+        const stats = await stat(dir);
+        expect(stats.isDirectory()).toBe(true);
+    });
+    it('ensureExportDir is idempotent', async () => {
+        await ensureExportDir('sess-42', tmpDir);
+        const dir = await ensureExportDir('sess-42', tmpDir);
+        expect(dir).toBe(join(tmpDir, 'sess-42'));
+    });
+});

package/dist/tests/unit/sessions/exportWriter.spec.js

@@ -0,0 +1,655 @@
+/**
+ * Export writer tests (T042, T044).
+ *
+ * Validates that the export writer:
+ * - Generates summary.json per contract
+ * - Creates Markdown files for each completed phase
+ * - Tracks generated files in the artifact index
+ * - Handles sessions with varying completion levels
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { exportSession, exportWorkshopDocs } from '../../../src/sessions/exportWriter.js';
+function createFullSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'export-test-session',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Complete',
+        status: 'Completed',
+        participants: [{ id: 'p1', displayName: 'Alice', role: 'Facilitator' }],
+        artifacts: { generatedFiles: [] },
+        turns: [
+            { phase: 'Discover', sequence: 1, role: 'user', content: 'We sell rockets', timestamp: now },
+            {
+                phase: 'Discover',
+                sequence: 2,
+                role: 'assistant',
+                content: 'Interesting! Tell me more.',
+                timestamp: now,
+            },
+            {
+                phase: 'Ideate',
+                sequence: 3,
+                role: 'user',
+                content: 'We need better delivery',
+                timestamp: now,
+            },
+            {
+                phase: 'Ideate',
+                sequence: 4,
+                role: 'assistant',
+                content: 'Here are some ideas.',
+                timestamp: now,
+            },
+        ],
+        businessContext: {
+            businessDescription: 'ACME Rockets Inc.',
+            challenges: ['Supply chain delays', 'Customer retention'],
+        },
+        workflow: {
+            activities: [
+                { id: 'a1', name: 'Order Processing' },
+                { id: 'a2', name: 'Delivery Tracking' },
+            ],
+            edges: [{ fromStepId: 'a1', toStepId: 'a2' }],
+        },
+        ideas: [
+            {
+                id: 'idea-1',
+                title: 'AI-Powered Delivery Tracking',
+                description: 'Use AI to predict delivery times',
+                workflowStepIds: ['a2'],
+            },
+            {
+                id: 'idea-2',
+                title: 'Smart Inventory Management',
+                description: 'ML-based inventory optimization',
+                workflowStepIds: ['a1'],
+            },
+        ],
+        selection: {
+            ideaId: 'idea-1',
+            selectionRationale: 'Highest feasibility score',
+            confirmedByUser: true,
+            confirmedAt: now,
+        },
+        plan: {
+            milestones: [
+                { id: 'm1', title: 'Data Pipeline Setup', items: ['Set up delivery data pipeline'] },
+                { id: 'm2', title: 'Model Training', items: ['Train prediction model'] },
+            ],
+        },
+        ...overrides,
+    };
+}
+describe('exportWriter', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('creates summary.json with required fields', async () => {
+        const session = createFullSession();
+        const result = await exportSession(session, tmpDir);
+        const summaryPath = join(tmpDir, 'summary.json');
+        const raw = await readFile(summaryPath, 'utf-8');
+        const summary = JSON.parse(raw);
+        expect(summary.sessionId).toBe('export-test-session');
+        expect(summary.exportedAt).toBeDefined();
+        expect(summary.phase).toBe('Complete');
+        expect(summary.status).toBe('Completed');
+        expect(summary.files).toBeInstanceOf(Array);
+        expect(summary.files.length).toBeGreaterThan(0);
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('creates Markdown files for completed phases', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('summary.json');
+        expect(files).toContain('discover.md');
+        // Should have at least discover and ideate based on turns
+    });
+    it('includes business context in discover.md', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'discover.md'), 'utf-8');
+        expect(content).toContain('ACME Rockets Inc.');
+        expect(content).toContain('Supply chain delays');
+    });
+    it('includes ideas in ideate.md', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'ideate.md'), 'utf-8');
+        expect(content).toContain('AI-Powered Delivery Tracking');
+        expect(content).toContain('Smart Inventory Management');
+    });
+    it('includes selection details in select.md', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'select.md'), 'utf-8');
+        expect(content).toContain('idea-1');
+        expect(content).toContain('Highest feasibility score');
+    });
+    it('includes plan milestones in plan.md', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'plan.md'), 'utf-8');
+        expect(content).toContain('Data Pipeline Setup');
+        expect(content).toContain('Model Training');
+    });
+    it('handles session with only Discover phase', async () => {
+        const session = createFullSession({
+            phase: 'Discover',
+            status: 'Active',
+            ideas: undefined,
+            selection: undefined,
+            plan: undefined,
+            turns: [
+                {
+                    phase: 'Discover',
+                    sequence: 1,
+                    role: 'user',
+                    content: 'We sell rockets',
+                    timestamp: new Date().toISOString(),
+                },
+            ],
+        });
+        const result = await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('summary.json');
+        expect(files).toContain('discover.md');
+        // Should not have plan.md since there's no plan data
+        expect(files).not.toContain('plan.md');
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('returns ExportResult with file list', async () => {
+        const session = createFullSession();
+        const result = await exportSession(session, tmpDir);
+        expect(result.exportDir).toBe(tmpDir);
+        expect(result.files.length).toBeGreaterThan(0);
+        expect(result.files.every((f) => f.path && f.type)).toBe(true);
+    });
+    it('summary.json files paths are relative', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const raw = await readFile(join(tmpDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(raw);
+        for (const file of summary.files) {
+            expect(file.path).not.toContain('/');
+            expect(file.path).not.toContain('\\');
+        }
+    });
+    it('does not include secrets in exported files', async () => {
+        const session = createFullSession();
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        for (const file of files) {
+            const content = await readFile(join(tmpDir, file), 'utf-8');
+            // Should not contain typical secret patterns
+            expect(content).not.toMatch(/api[_-]?key/i);
+            expect(content).not.toMatch(/secret/i);
+            expect(content).not.toMatch(/token/i);
+            expect(content).not.toMatch(/password/i);
+        }
+    });
+});
+// ── T010: Tests for enriched generateDevelopMarkdown (Feature 002) ───────────
+describe('generateDevelopMarkdown (Feature 002 enrichment)', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-develop-md-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    function createSessionWithPoc(overrides) {
+        const base = createFullSession();
+        return {
+            ...base,
+            poc: {
+                repoSource: 'local',
+                repoPath: './poc/test-session',
+                iterations: [],
+                ...(overrides?.poc ?? {}),
+            },
+            ...overrides,
+        };
+    }
+    it('generates develop.md when poc is present', async () => {
+        const session = createSessionWithPoc();
+        const result = await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('develop.md');
+        const fileEntry = result.files.find((f) => f.path === 'develop.md');
+        expect(fileEntry).toBeDefined();
+    });
+    it('does not generate develop.md when poc is absent', async () => {
+        const session = createFullSession();
+        // no poc field
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).not.toContain('develop.md');
+    });
+    it('includes repo path when repoSource is local', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                repoPath: './poc/test-session-001',
+                iterations: [],
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('./poc/test-session-001');
+        expect(content).toContain('local');
+    });
+    it('includes repo URL when manually set on local repoSource', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                repoUrl: 'https://github.com/acme/poc-route-optimizer',
+                iterations: [],
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('https://github.com/acme/poc-route-optimizer');
+        expect(content).toContain('local');
+    });
+    it('includes tech stack summary', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [],
+                techStack: {
+                    language: 'TypeScript',
+                    framework: 'Express',
+                    testRunner: 'npm test',
+                    buildCommand: 'npm run build',
+                    runtime: 'Node.js 20',
+                },
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('TypeScript');
+        expect(content).toContain('Express');
+        expect(content).toContain('Node.js 20');
+    });
+    it('includes iteration timeline with outcomes', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: '2026-01-15T10:00:00Z',
+                        endedAt: '2026-01-15T10:01:00Z',
+                        outcome: 'scaffold',
+                        filesChanged: ['package.json', 'src/index.ts'],
+                        changesSummary: 'Initial scaffold generated',
+                    },
+                    {
+                        iteration: 2,
+                        startedAt: '2026-01-15T10:01:00Z',
+                        endedAt: '2026-01-15T10:02:00Z',
+                        outcome: 'tests-passing',
+                        filesChanged: ['src/optimizer.ts'],
+                        testResults: {
+                            passed: 3,
+                            failed: 0,
+                            skipped: 0,
+                            total: 3,
+                            durationMs: 450,
+                            failures: [],
+                        },
+                    },
+                ],
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('Iteration 1');
+        expect(content).toContain('scaffold');
+        expect(content).toContain('Iteration 2');
+        expect(content).toContain('tests-passing');
+        expect(content).toContain('package.json');
+        expect(content).toContain('3 passed');
+    });
+    it('includes final test results', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [],
+                finalStatus: 'success',
+                terminationReason: 'tests-passing',
+                totalDurationMs: 60000,
+                finalTestResults: {
+                    passed: 5,
+                    failed: 0,
+                    skipped: 1,
+                    total: 6,
+                    durationMs: 800,
+                    failures: [],
+                },
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('success');
+        expect(content).toContain('tests-passing');
+        expect(content).toContain('5'); // passed count
+        expect(content).toContain('60.0s'); // total duration
+    });
+    it('includes failure details in final test results', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [],
+                finalStatus: 'failed',
+                terminationReason: 'max-iterations',
+                finalTestResults: {
+                    passed: 0,
+                    failed: 1,
+                    skipped: 0,
+                    total: 1,
+                    durationMs: 500,
+                    failures: [{ testName: 'route optimizer test', message: 'Expected 3 but got 5' }],
+                },
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('route optimizer test');
+        expect(content).toContain('Expected 3 but got 5');
+    });
+    it('includes termination reason', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [],
+                finalStatus: 'partial',
+                terminationReason: 'max-iterations',
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('partial');
+        expect(content).toContain('max-iterations');
+    });
+    it('handles error iteration with errorMessage', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 2,
+                        startedAt: '2026-01-15T10:01:00Z',
+                        outcome: 'error',
+                        filesChanged: [],
+                        errorMessage: 'npm install failed: ENOTFOUND registry.npmjs.org',
+                    },
+                ],
+            },
+        });
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'develop.md'), 'utf-8');
+        expect(content).toContain('error');
+        expect(content).toContain('npm install failed');
+    });
+    it('includes PoC highlights in summary.json (F030)', async () => {
+        const session = createSessionWithPoc({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: '2026-01-15T10:00:00Z',
+                        outcome: 'tests-passing',
+                        filesChanged: ['src/index.ts'],
+                    },
+                    {
+                        iteration: 2,
+                        startedAt: '2026-01-15T10:01:00Z',
+                        outcome: 'tests-passing',
+                        filesChanged: ['src/routes.ts'],
+                    },
+                ],
+                finalStatus: 'success',
+                terminationReason: 'tests-passing',
+            },
+        });
+        await exportSession(session, tmpDir);
+        const summaryRaw = await readFile(join(tmpDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(summaryRaw);
+        expect(summary.highlights).toBeDefined();
+        expect(summary.highlights).toEqual(expect.arrayContaining([
+            expect.stringContaining('PoC status: success'),
+            expect.stringContaining('PoC iterations: 2'),
+            expect.stringContaining('PoC termination: tests-passing'),
+        ]));
+    });
+    // ── Conversation Fallback Export Tests (T072-T076) ───────────────────────
+    it('generates ideate.md with conversation turns when ideas are null', async () => {
+        const now = new Date().toISOString();
+        const session = createFullSession({
+            ideas: undefined,
+            turns: [
+                { phase: 'Discover', sequence: 1, role: 'user', content: 'hello', timestamp: now },
+                {
+                    phase: 'Ideate',
+                    sequence: 2,
+                    role: 'user',
+                    content: 'brainstorm AI ideas',
+                    timestamp: now,
+                },
+                {
+                    phase: 'Ideate',
+                    sequence: 3,
+                    role: 'assistant',
+                    content: 'Here are some ideas for AI-powered solutions.',
+                    timestamp: now,
+                },
+            ],
+        });
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('ideate.md');
+        const content = await readFile(join(tmpDir, 'ideate.md'), 'utf-8');
+        expect(content).toContain('# Ideate Phase');
+        expect(content).toContain('## Conversation');
+        expect(content).toContain('brainstorm AI ideas');
+    });
+    it('generates design.md with conversation turns when evaluation is null', async () => {
+        const now = new Date().toISOString();
+        const session = createFullSession({
+            evaluation: undefined,
+            turns: [
+                { phase: 'Design', sequence: 1, role: 'user', content: 'evaluate ideas', timestamp: now },
+                {
+                    phase: 'Design',
+                    sequence: 2,
+                    role: 'assistant',
+                    content: 'Let me evaluate.',
+                    timestamp: now,
+                },
+            ],
+        });
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('design.md');
+        const content = await readFile(join(tmpDir, 'design.md'), 'utf-8');
+        expect(content).toContain('# Design Phase');
+        expect(content).toContain('## Conversation');
+        expect(content).toContain('evaluate ideas');
+    });
+    it('renders structured data first then conversation when both exist', async () => {
+        const now = new Date().toISOString();
+        const session = createFullSession({
+            turns: [
+                { phase: 'Ideate', sequence: 1, role: 'user', content: 'give ideas', timestamp: now },
+                {
+                    phase: 'Ideate',
+                    sequence: 2,
+                    role: 'assistant',
+                    content: 'here are ideas',
+                    timestamp: now,
+                },
+            ],
+        });
+        // session already has ideas from createFullSession
+        await exportSession(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'ideate.md'), 'utf-8');
+        // Structured data (Ideas section) should come before Conversation
+        const ideasIdx = content.indexOf('## Ideas');
+        const convIdx = content.indexOf('## Conversation');
+        expect(ideasIdx).toBeGreaterThan(-1);
+        expect(convIdx).toBeGreaterThan(-1);
+        expect(ideasIdx).toBeLessThan(convIdx);
+    });
+    it('summary.json lists all 6 phase files when all phases have turns', async () => {
+        const now = new Date().toISOString();
+        const phases = ['Discover', 'Ideate', 'Design', 'Select', 'Plan', 'Develop'];
+        const turns = phases.flatMap((phase, i) => [
+            {
+                phase,
+                sequence: i * 2 + 1,
+                role: 'user',
+                content: `${phase} input`,
+                timestamp: now,
+            },
+            {
+                phase,
+                sequence: i * 2 + 2,
+                role: 'assistant',
+                content: `${phase} response`,
+                timestamp: now,
+            },
+        ]);
+        const session = createFullSession({ turns });
+        await exportSession(session, tmpDir);
+        const summaryRaw = await readFile(join(tmpDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(summaryRaw);
+        const mdFiles = summary.files.filter((f) => f.path.endsWith('.md'));
+        expect(mdFiles.length).toBeGreaterThanOrEqual(6);
+    });
+    it('summary.json highlights include one entry per phase with turns', async () => {
+        const now = new Date().toISOString();
+        const session = createFullSession({
+            ideas: undefined,
+            evaluation: undefined,
+            selection: undefined,
+            plan: undefined,
+            poc: undefined,
+            turns: [
+                { phase: 'Ideate', sequence: 1, role: 'user', content: 'ideas please', timestamp: now },
+                {
+                    phase: 'Ideate',
+                    sequence: 2,
+                    role: 'assistant',
+                    content: 'Here are creative ideas.',
+                    timestamp: now,
+                },
+                { phase: 'Design', sequence: 3, role: 'user', content: 'evaluate', timestamp: now },
+                {
+                    phase: 'Design',
+                    sequence: 4,
+                    role: 'assistant',
+                    content: 'Evaluation results.',
+                    timestamp: now,
+                },
+            ],
+        });
+        await exportSession(session, tmpDir);
+        const summaryRaw = await readFile(join(tmpDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(summaryRaw);
+        expect(summary.highlights).toBeDefined();
+        // Should have highlights for phases with turns (fallback to first assistant turn)
+        expect(summary.highlights.some((h) => h.includes('Ideate'))).toBe(true);
+        expect(summary.highlights.some((h) => h.includes('Design'))).toBe(true);
+    });
+});
+// ── exportWorkshopDocs — workshop docs for PoC repos ─────────────────────────
+describe('exportWorkshopDocs', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-wsdocs-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('creates docs/workshop/ directory with phase markdown files', async () => {
+        const session = createFullSession();
+        const result = await exportWorkshopDocs(session, tmpDir);
+        const workshopDir = join(tmpDir, 'docs', 'workshop');
+        const files = await readdir(workshopDir);
+        expect(files).toContain('discover.md');
+        expect(files).toContain('ideate.md');
+        expect(files).toContain('select.md');
+        expect(files).toContain('plan.md');
+        expect(result.createdFiles.length).toBeGreaterThan(0);
+    });
+    it('creates a WORKSHOP.md index at the repo root', async () => {
+        const session = createFullSession();
+        await exportWorkshopDocs(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'WORKSHOP.md'), 'utf-8');
+        expect(content).toContain('Workshop Summary');
+        expect(content).toContain('discover.md');
+        expect(content).toContain(session.sessionId);
+    });
+    it('excludes develop.md since the repo IS the PoC', async () => {
+        const session = createFullSession({
+            poc: {
+                repoSource: 'local',
+                repoPath: '/tmp/poc',
+                iterations: [],
+            },
+        });
+        await exportWorkshopDocs(session, tmpDir);
+        const workshopDir = join(tmpDir, 'docs', 'workshop');
+        const files = await readdir(workshopDir);
+        expect(files).not.toContain('develop.md');
+    });
+    it('includes business context in discover.md', async () => {
+        const session = createFullSession();
+        await exportWorkshopDocs(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'docs', 'workshop', 'discover.md'), 'utf-8');
+        expect(content).toContain('ACME Rockets Inc.');
+    });
+    it('includes selection rationale in select.md', async () => {
+        const session = createFullSession();
+        await exportWorkshopDocs(session, tmpDir);
+        const content = await readFile(join(tmpDir, 'docs', 'workshop', 'select.md'), 'utf-8');
+        expect(content).toContain('Highest feasibility score');
+    });
+    it('returns list of created files relative to repoDir', async () => {
+        const session = createFullSession();
+        const result = await exportWorkshopDocs(session, tmpDir);
+        expect(result.createdFiles).toContain('WORKSHOP.md');
+        expect(result.createdFiles.some((f) => f.startsWith('docs/workshop/'))).toBe(true);
+    });
+    it('handles session with only Discover data', async () => {
+        const session = createFullSession({
+            phase: 'Discover',
+            status: 'Active',
+            ideas: undefined,
+            selection: undefined,
+            plan: undefined,
+            evaluation: undefined,
+        });
+        const result = await exportWorkshopDocs(session, tmpDir);
+        const workshopDir = join(tmpDir, 'docs', 'workshop');
+        const files = await readdir(workshopDir);
+        expect(files).toContain('discover.md');
+        expect(files).not.toContain('plan.md');
+        expect(result.createdFiles.length).toBeGreaterThan(0);
+    });
+});