sofia-cli 0.1.1

package/dist/tests/integration/discoveryEnrichmentFlow.spec.js

@@ -0,0 +1,175 @@
+/**
+ * Integration test for Discovery Phase Enrichment Flow (T029).
+ *
+ * Simulates Step 1 completion in the discover handler and verifies:
+ * - The user is offered web search enrichment when available
+ * - DiscoveryEnricher.enrichFromWebSearch() is called when web search provided
+ * - Session is updated with discovery.enrichment
+ * - Enrichment data is included in the Ideate phase system prompt
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createPhaseHandler } from '../../src/phases/phaseHandlers.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makeSession(overrides) {
+    return {
+        sessionId: 'test-session',
+        schemaVersion: '0.3.0',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        ...overrides,
+    };
+}
+function makeLoopIO() {
+    return {
+        write: vi.fn(),
+        writeActivity: vi.fn(),
+        writeToolSummary: vi.fn(),
+        readInput: vi.fn().mockResolvedValue('n'),
+        showDecisionGate: vi.fn().mockResolvedValue({ choice: 'continue' }),
+        isJsonMode: false,
+        isTTY: true,
+    };
+}
+function makeMcpManager() {
+    return {
+        isAvailable: vi.fn().mockReturnValue(false),
+        callTool: vi.fn().mockResolvedValue({}),
+        markConnected: vi.fn(),
+        markDisconnected: vi.fn(),
+        disconnectAll: vi.fn().mockResolvedValue(undefined),
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('Discovery enrichment integration flow (T029)', () => {
+    let io;
+    let mcpManager;
+    let webSearchClient;
+    beforeEach(() => {
+        io = makeLoopIO();
+        mcpManager = makeMcpManager();
+        webSearchClient = {
+            search: vi.fn().mockResolvedValue({
+                results: [
+                    {
+                        title: 'Acme launches AI',
+                        url: 'https://news.com/1',
+                        snippet: 'Acme Corp announced a new AI product',
+                    },
+                ],
+                degraded: false,
+            }),
+        };
+    });
+    it('runs enrichment via postExtract when businessContext is available and webSearchClient provided', async () => {
+        const handler = createPhaseHandler('Discover', {
+            discover: { io, mcpManager, webSearchClient },
+        });
+        await handler._preload();
+        const session = makeSession({
+            businessContext: {
+                businessDescription: 'Acme Corp manufactures widgets and is exploring AI',
+                challenges: ['efficiency', 'quality control'],
+            },
+        });
+        // postExtract should trigger enrichment
+        const updates = await handler.postExtract(session);
+        expect(updates.discovery).toBeDefined();
+        expect(updates.discovery.enrichment).toBeDefined();
+        expect(updates.discovery.enrichment.sourcesUsed).toContain('websearch');
+        expect(updates.discovery.enrichment.companyNews).toBeDefined();
+        expect(updates.discovery.enrichment.companyNews.length).toBeGreaterThan(0);
+        expect(webSearchClient.search).toHaveBeenCalled();
+    });
+    it('does not run enrichment when businessContext is missing', async () => {
+        const handler = createPhaseHandler('Discover', {
+            discover: { io, mcpManager, webSearchClient },
+        });
+        await handler._preload();
+        const session = makeSession(); // no businessContext
+        const updates = await handler.postExtract(session);
+        expect(updates.discovery).toBeUndefined();
+        expect(webSearchClient.search).not.toHaveBeenCalled();
+    });
+    it('runs enrichment only once (first extraction)', async () => {
+        const handler = createPhaseHandler('Discover', {
+            discover: { io, mcpManager, webSearchClient },
+        });
+        await handler._preload();
+        const session = makeSession({
+            businessContext: {
+                businessDescription: 'Acme Corp',
+                challenges: ['challenge'],
+            },
+        });
+        // First call: triggers enrichment
+        const updates1 = await handler.postExtract(session);
+        expect(updates1.discovery).toBeDefined();
+        // Second call: should not re-trigger
+        const updates2 = await handler.postExtract(session);
+        expect(updates2).toEqual({});
+        // search is called once (first successful query) in the first call only, not in second
+        expect(webSearchClient.search).toHaveBeenCalledTimes(1);
+    });
+    it('does not run enrichment when no webSearchClient or WorkIQ available', async () => {
+        const handler = createPhaseHandler('Discover', {
+            discover: { io, mcpManager },
+        });
+        await handler._preload();
+        const session = makeSession({
+            businessContext: {
+                businessDescription: 'Acme Corp',
+                challenges: ['challenge'],
+            },
+        });
+        const updates = await handler.postExtract(session);
+        expect(updates).toEqual({});
+    });
+    it('enrichment result stored in session.discovery.enrichment is picked up by Ideate prompt', async () => {
+        // Create a session with enrichment already stored
+        const session = makeSession({
+            phase: 'Ideate',
+            businessContext: {
+                businessDescription: 'Acme Corp',
+                challenges: ['efficiency'],
+            },
+            discovery: {
+                enrichment: {
+                    companyNews: ['Acme raises $10M Series B'],
+                    competitorInfo: ['Widget Inc growing fast'],
+                    industryTrends: ['AI in manufacturing trending'],
+                    enrichedAt: new Date().toISOString(),
+                    sourcesUsed: ['websearch'],
+                },
+            },
+        });
+        const ideateHandler = createPhaseHandler('Ideate');
+        await ideateHandler._preload();
+        const prompt = ideateHandler.buildSystemPrompt(session);
+        // The ideate handler includes businessContext in its prompt
+        expect(prompt).toContain('Acme Corp');
+        // Note: Enrichment injection into ideation prompt is a downstream task,
+        // this test verifies the data is available for injection
+    });
+    it('enrichment does not interfere with normal extractResult', async () => {
+        const handler = createPhaseHandler('Discover', {
+            discover: { io, mcpManager, webSearchClient },
+        });
+        await handler._preload();
+        const session = makeSession();
+        // Normal extractResult should still work
+        const response = `## Business Context
+\`\`\`json
+{
+  "businessDescription": "Acme Corp",
+  "challenges": ["efficiency"]
+}
+\`\`\``;
+        const updates = handler.extractResult(session, response);
+        // extractResult should not contain discovery (that's postExtract's job)
+        expect(updates.businessContext).toBeDefined();
+    });
+});

package/dist/tests/integration/exportArtifacts.spec.js

@@ -0,0 +1,202 @@
+/**
+ * Integration test: Export Artifacts (T037)
+ *
+ * Tests the export pipeline from session to Markdown + summary.json:
+ * - Export a complete session with all phases populated
+ * - Verify per-phase Markdown files are generated
+ * - Verify summary.json matches contract structure
+ * - Verify export handles partial sessions (only some phases done)
+ * - Verify export paths and directory creation
+ */
+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 } from '../../src/sessions/exportWriter.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createFullSession() {
+    return {
+        sessionId: 'test-export-session',
+        schemaVersion: '1.0.0',
+        createdAt: '2025-01-01T00:00:00Z',
+        updatedAt: '2025-06-15T12:00:00Z',
+        phase: 'Complete',
+        status: 'Completed',
+        participants: [
+            { id: 'p1', displayName: 'Alice', role: 'Facilitator' },
+        ],
+        businessContext: {
+            businessDescription: 'Logistics company specializing in last-mile delivery',
+            challenges: ['Route optimization is manual', 'High fuel costs'],
+            constraints: ['Budget limited to $50k'],
+            successMetrics: [{ name: 'Delivery time', value: '30', unit: 'minutes' }],
+        },
+        workflow: {
+            activities: [
+                { id: 'a1', name: 'Receive Order', description: 'Customer places order' },
+                { id: 'a2', name: 'Plan Route', description: 'Manual route planning' },
+                { id: 'a3', name: 'Deliver', description: 'Driver delivers package' },
+            ],
+            edges: [
+                { fromStepId: 'a1', toStepId: 'a2' },
+                { fromStepId: 'a2', toStepId: 'a3' },
+            ],
+        },
+        ideas: [
+            {
+                id: 'i1',
+                title: 'AI Route Optimizer',
+                description: 'Use ML to find optimal delivery routes',
+                workflowStepIds: ['a2'],
+                aspirationalScope: 'Cover all urban routes',
+            },
+            {
+                id: 'i2',
+                title: 'Predictive Demand',
+                description: 'Forecast delivery demand to pre-position drivers',
+                workflowStepIds: ['a1', 'a2'],
+            },
+        ],
+        evaluation: {
+            method: 'feasibility-value-matrix',
+            ideas: [
+                { ideaId: 'i1', feasibility: 4, value: 5, risks: ['Data quality'] },
+                { ideaId: 'i2', feasibility: 3, value: 4 },
+            ],
+        },
+        selection: {
+            ideaId: 'i1',
+            selectionRationale: 'Highest combined feasibility + value score',
+            confirmedByUser: true,
+            confirmedAt: '2025-06-15T11:00:00Z',
+        },
+        plan: {
+            milestones: [
+                { id: 'm1', title: 'Data Collection', items: ['Set up telemetry', 'Collect 3 months of delivery data'] },
+                { id: 'm2', title: 'Model Training', items: ['Train route model', 'Validate on historical data'] },
+                { id: 'm3', title: 'Integration', items: ['API endpoint', 'Driver app integration'] },
+            ],
+            architectureNotes: 'Microservices with Azure Maps API',
+            dependencies: ['Azure subscription', 'Historical delivery data'],
+        },
+        poc: {
+            repoSource: 'local',
+            iterations: [
+                {
+                    iteration: 1,
+                    startedAt: '2025-06-15T11:30:00Z',
+                    outcome: 'scaffold',
+                    filesChanged: ['package.json', 'src/index.ts'],
+                    changesSummary: 'Initial scaffold with simple greedy routing',
+                },
+            ],
+        },
+        artifacts: { generatedFiles: [] },
+        turns: [
+            { phase: 'Discover', sequence: 1, role: 'user', content: 'We are a logistics company', timestamp: '2025-01-01T00:01:00Z' },
+            { phase: 'Discover', sequence: 2, role: 'assistant', content: 'Understood, let me document that.', timestamp: '2025-01-01T00:02:00Z' },
+            { phase: 'Ideate', sequence: 3, role: 'user', content: 'Generate ideas', timestamp: '2025-01-01T00:03:00Z' },
+        ],
+    };
+}
+function createPartialSession() {
+    return {
+        sessionId: 'test-partial-session',
+        schemaVersion: '1.0.0',
+        createdAt: '2025-01-01T00:00:00Z',
+        updatedAt: '2025-01-01T01:00:00Z',
+        phase: 'Ideate',
+        status: 'Active',
+        participants: [],
+        businessContext: {
+            businessDescription: 'A SaaS platform',
+            challenges: ['Customer churn'],
+        },
+        artifacts: { generatedFiles: [] },
+        turns: [],
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('Export Artifacts Flow', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('exports a complete session with all phase Markdown files', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        const result = await exportSession(session, exportDir);
+        expect(result.files.length).toBeGreaterThanOrEqual(6); // discover + ideate + design + select + plan + develop + summary
+        const files = await readdir(exportDir);
+        expect(files).toContain('summary.json');
+    });
+    it('generates valid summary.json matching contract', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        await exportSession(session, exportDir);
+        const summaryRaw = await readFile(join(exportDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(summaryRaw);
+        expect(summary.sessionId).toBe('test-export-session');
+        expect(summary.phase).toBe('Complete');
+        expect(summary.status).toBe('Completed');
+        expect(summary.exportedAt).toBeDefined();
+        expect(Array.isArray(summary.files)).toBe(true);
+        expect(summary.files.length).toBeGreaterThan(0);
+    });
+    it('exports Discover markdown with business context', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        await exportSession(session, exportDir);
+        const files = await readdir(exportDir);
+        const discoverFile = files.find((f) => f.includes('discover'));
+        expect(discoverFile).toBeDefined();
+        const content = await readFile(join(exportDir, discoverFile), 'utf-8');
+        expect(content).toContain('Logistics company');
+        expect(content).toContain('Route optimization');
+    });
+    it('exports Ideate markdown with ideas', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        await exportSession(session, exportDir);
+        const files = await readdir(exportDir);
+        const ideateFile = files.find((f) => f.includes('ideate'));
+        expect(ideateFile).toBeDefined();
+        const content = await readFile(join(exportDir, ideateFile), 'utf-8');
+        expect(content).toContain('AI Route Optimizer');
+    });
+    it('exports Plan markdown with milestones', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        await exportSession(session, exportDir);
+        const files = await readdir(exportDir);
+        const planFile = files.find((f) => f.includes('plan'));
+        expect(planFile).toBeDefined();
+        const content = await readFile(join(exportDir, planFile), 'utf-8');
+        expect(content).toContain('Data Collection');
+        expect(content).toContain('Model Training');
+    });
+    it('handles partial session with only Discover data', async () => {
+        const session = createPartialSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        const result = await exportSession(session, exportDir);
+        // Should still have at least discover markdown + summary.json
+        expect(result.files.length).toBeGreaterThanOrEqual(2);
+        const files = await readdir(exportDir);
+        expect(files).toContain('summary.json');
+        const discoverFile = files.find((f) => f.includes('discover'));
+        expect(discoverFile).toBeDefined();
+    });
+    it('summary file list contains relative paths', async () => {
+        const session = createFullSession();
+        const exportDir = join(tmpDir, session.sessionId);
+        await exportSession(session, exportDir);
+        const summaryRaw = await readFile(join(exportDir, 'summary.json'), 'utf-8');
+        const summary = JSON.parse(summaryRaw);
+        for (const file of summary.files) {
+            expect(file).not.toContain(tmpDir); // Should be relative, not absolute
+        }
+    });
+});

package/dist/tests/integration/exportFallbackFlow.spec.js

@@ -0,0 +1,99 @@
+/**
+ * Integration test: Export fallback flow.
+ *
+ * Tests the full export pipeline with null structured data but present
+ * conversation turns — verifies that all phase files are generated.
+ */
+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 } from '../../src/sessions/exportWriter.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-fallback-'));
+});
+afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+});
+describe('export fallback flow', () => {
+    it('generates 6 markdown files when all phases have turns but no structured data', 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: `Tell me about the ${phase} phase`,
+                timestamp: now,
+            },
+            {
+                phase,
+                sequence: i * 2 + 2,
+                role: 'assistant',
+                content: `Here is information about the ${phase} phase.`,
+                timestamp: now,
+            },
+        ]);
+        const session = {
+            sessionId: 'fallback-test',
+            schemaVersion: '1.0.0',
+            createdAt: now,
+            updatedAt: now,
+            phase: 'Complete',
+            status: 'Completed',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns,
+            // Discover has conversation fallback built-in
+            businessContext: {
+                businessDescription: 'Test Company',
+                challenges: ['Testing'],
+            },
+            // All other structured fields are null/undefined
+        };
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        expect(files).toContain('discover.md');
+        expect(files).toContain('ideate.md');
+        expect(files).toContain('design.md');
+        expect(files).toContain('select.md');
+        expect(files).toContain('plan.md');
+        expect(files).toContain('develop.md');
+        expect(files).toContain('summary.json');
+        // Verify each file has conversation content
+        for (const phase of phases) {
+            const content = await readFile(join(tmpDir, `${phase.toLowerCase()}.md`), 'utf-8');
+            expect(content).toContain('## Conversation');
+        }
+        // Verify summary.json lists all files
+        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).toBe(6);
+        // Verify highlights exist
+        expect(summary.highlights).toBeDefined();
+        expect(summary.highlights.length).toBeGreaterThan(0);
+    });
+    it('returns null for phase with neither structured data nor turns', async () => {
+        const now = new Date().toISOString();
+        const session = {
+            sessionId: 'empty-test',
+            schemaVersion: '1.0.0',
+            createdAt: now,
+            updatedAt: now,
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        await exportSession(session, tmpDir);
+        const files = await readdir(tmpDir);
+        // Only summary.json should be generated — no phase files
+        expect(files).toContain('summary.json');
+        const mdFiles = files.filter((f) => f.endsWith('.md'));
+        expect(mdFiles).toHaveLength(0);
+    });
+});

package/dist/tests/integration/mcpDegradationFlow.spec.js

@@ -0,0 +1,190 @@
+/**
+ * T042: Integration test for MCP degradation flow.
+ *
+ * Configures McpManager with servers marked unavailable (or stub transports
+ * that throw), runs GitHubMcpAdapter + McpContextEnricher calls, and asserts
+ * graceful degradation (no throws; adapters return { available: false, reason }
+ * or fallback context) per US1 Acceptance Scenario 4 and FR-013.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { McpManager } from '../../src/mcp/mcpManager.js';
+import { GitHubMcpAdapter } from '../../src/develop/githubMcpAdapter.js';
+import { McpContextEnricher } from '../../src/develop/mcpContextEnricher.js';
+vi.mock('../../src/mcp/webSearch.js', () => ({
+    isWebSearchConfigured: vi.fn(() => false),
+}));
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makeEmptyConfig() {
+    return { servers: {} };
+}
+function makeConfigWithServers() {
+    return {
+        servers: {
+            github: {
+                name: 'github',
+                type: 'http',
+                url: 'https://api.github.com/mcp',
+            },
+            context7: {
+                name: 'context7',
+                type: 'stdio',
+                command: 'npx',
+                args: ['-y', '@upstash/context7-mcp'],
+            },
+            azure: {
+                name: 'azure',
+                type: 'stdio',
+                command: 'npx',
+                args: ['-y', '@azure/mcp'],
+            },
+        },
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('MCP Degradation Flow (integration)', () => {
+    let originalGithubToken;
+    beforeEach(() => {
+        originalGithubToken = process.env.GITHUB_TOKEN;
+    });
+    afterEach(() => {
+        if (originalGithubToken !== undefined) {
+            process.env.GITHUB_TOKEN = originalGithubToken;
+        }
+        else {
+            delete process.env.GITHUB_TOKEN;
+        }
+        vi.restoreAllMocks();
+    });
+    describe('GitHubMcpAdapter graceful degradation', () => {
+        it('returns available:false when GitHub MCP is not configured', async () => {
+            const manager = new McpManager(makeEmptyConfig());
+            const adapter = new GitHubMcpAdapter(manager);
+            expect(adapter.isAvailable()).toBe(false);
+            const createResult = await adapter.createRepository({ name: 'test-poc' });
+            expect(createResult.available).toBe(false);
+            if (!createResult.available) {
+                expect(createResult.reason).toBeDefined();
+            }
+            const pushResult = await adapter.pushFiles({
+                repoUrl: 'https://github.com/acme/test',
+                files: [{ path: 'index.ts', content: 'hello' }],
+                commitMessage: 'init',
+            });
+            expect(pushResult.available).toBe(false);
+            if (!pushResult.available) {
+                expect(pushResult.reason).toBeDefined();
+            }
+        });
+        it('returns available:false when GitHub is configured but not connected', async () => {
+            const manager = new McpManager(makeConfigWithServers());
+            // Do NOT call markConnected — server is configured but unavailable
+            const adapter = new GitHubMcpAdapter(manager);
+            expect(adapter.isAvailable()).toBe(false);
+            const createResult = await adapter.createRepository({ name: 'test-poc' });
+            expect(createResult.available).toBe(false);
+        });
+        it('never throws from createRepository or pushFiles', async () => {
+            const manager = new McpManager(makeConfigWithServers());
+            manager.markConnected('github');
+            // Stub callTool to throw
+            vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('network crash'));
+            const adapter = new GitHubMcpAdapter(manager);
+            // Should not throw
+            const createResult = await adapter.createRepository({ name: 'test-poc' });
+            expect(createResult.available).toBe(false);
+            if (!createResult.available) {
+                expect(createResult.reason).toBeDefined();
+            }
+            const pushResult = await adapter.pushFiles({
+                repoUrl: 'https://github.com/acme/test',
+                files: [{ path: 'index.ts', content: 'hello' }],
+                commitMessage: 'init',
+            });
+            expect(pushResult.available).toBe(false);
+        });
+    });
+    describe('McpContextEnricher graceful degradation', () => {
+        it('returns empty context when all services unavailable', async () => {
+            const manager = new McpManager(makeEmptyConfig());
+            const enricher = new McpContextEnricher(manager);
+            const result = await enricher.enrich({
+                dependencies: ['express', 'zod'],
+                architectureNotes: 'Use Azure Cosmos DB',
+                stuckIterations: 3,
+                failingTests: ['test fails with TypeError'],
+            });
+            expect(result.combined).toBe('');
+            expect(result.libraryDocs).toBeUndefined();
+            expect(result.azureGuidance).toBeUndefined();
+            expect(result.webSearchResults).toBeUndefined();
+        });
+        it('returns empty context when servers configured but not connected', async () => {
+            const manager = new McpManager(makeConfigWithServers());
+            // Not marking any server as connected
+            const enricher = new McpContextEnricher(manager);
+            const result = await enricher.enrich({
+                dependencies: ['express'],
+                architectureNotes: 'Use Azure Functions',
+            });
+            expect(result.combined).toBe('');
+            expect(result.libraryDocs).toBeUndefined();
+            expect(result.azureGuidance).toBeUndefined();
+        });
+        it('returns fallback context when callTool throws for all services', async () => {
+            const manager = new McpManager(makeConfigWithServers());
+            manager.markConnected('context7');
+            manager.markConnected('azure');
+            // Stub callTool to throw for all calls
+            vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('transport broken'));
+            const enricher = new McpContextEnricher(manager);
+            const result = await enricher.enrich({
+                dependencies: ['express'],
+                architectureNotes: 'Use Azure Cosmos DB for data',
+            });
+            // Context7 should fall back to npm links
+            if (result.libraryDocs) {
+                expect(result.libraryDocs).toContain('npmjs.com');
+            }
+            // Azure should fall back to static guidance
+            if (result.azureGuidance) {
+                expect(result.azureGuidance).toContain('DefaultAzureCredential');
+            }
+        });
+        it('never throws from enrich()', async () => {
+            const manager = new McpManager(makeConfigWithServers());
+            manager.markConnected('context7');
+            manager.markConnected('azure');
+            vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('catastrophic'));
+            const enricher = new McpContextEnricher(manager);
+            // Should not throw
+            const result = await enricher.enrich({
+                dependencies: ['express', 'zod'],
+                architectureNotes: 'Use Azure Cosmos DB',
+                stuckIterations: 5,
+                failingTests: ['test fails'],
+            });
+            // Should still return a valid EnrichedContext
+            expect(result).toHaveProperty('combined');
+            expect(typeof result.combined).toBe('string');
+        });
+    });
+    describe('Combined adapter + enricher degradation', () => {
+        it('full workflow with all MCP unavailable returns graceful defaults', async () => {
+            const manager = new McpManager(makeEmptyConfig());
+            const adapter = new GitHubMcpAdapter(manager);
+            const enricher = new McpContextEnricher(manager);
+            // Adapter: not available
+            expect(adapter.isAvailable()).toBe(false);
+            const repoResult = await adapter.createRepository({ name: 'test' });
+            expect(repoResult.available).toBe(false);
+            // Enricher: empty context
+            const contextResult = await enricher.enrich({
+                dependencies: ['express'],
+                architectureNotes: 'Use Azure',
+                stuckIterations: 3,
+                failingTests: ['test fails'],
+            });
+            expect(contextResult.combined).toBe('');
+        });
+    });
+});