sofia-cli 0.1.1

package/dist/tests/unit/phases/contextSummarizer.spec.js

@@ -0,0 +1,140 @@
+/**
+ * Context summarizer tests.
+ *
+ * Tests for buildSummarizedContext() and renderSummarizedContext()
+ * that project structured session fields into compact markdown
+ * for injection into phase system prompts.
+ */
+import { describe, it, expect } from 'vitest';
+import { buildSummarizedContext, renderSummarizedContext, } from '../../../src/phases/contextSummarizer.js';
+function emptySession(overrides) {
+    return {
+        sessionId: 'test-1',
+        schemaVersion: '1.0.0',
+        createdAt: '2025-01-01T00:00:00Z',
+        updatedAt: '2025-01-01T00:00:00Z',
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        turns: [],
+        ...overrides,
+    };
+}
+describe('buildSummarizedContext', () => {
+    it('returns empty context for empty session', () => {
+        const ctx = buildSummarizedContext(emptySession());
+        expect(ctx.businessSummary).toBeUndefined();
+        expect(ctx.challenges).toBeUndefined();
+        expect(ctx.ideaSummaries).toBeUndefined();
+        expect(ctx.evaluationSummary).toBeUndefined();
+        expect(ctx.selectionSummary).toBeUndefined();
+        expect(ctx.planMilestones).toBeUndefined();
+    });
+    it('projects all fields from a full session', () => {
+        const session = emptySession({
+            businessContext: {
+                businessDescription: 'Zava Industries',
+                challenges: ['Scaling', 'Automation'],
+            },
+            topic: { topicArea: 'Customer Support' },
+            workflow: {
+                activities: [
+                    { id: 's1', name: 'Intake' },
+                    { id: 's2', name: 'Processing' },
+                ],
+                edges: [],
+            },
+            ideas: [
+                { id: 'idea-1', title: 'AI Bot', description: 'Automate support', workflowStepIds: ['s1'] },
+            ],
+            evaluation: {
+                method: 'feasibility-value-matrix',
+                ideas: [{ ideaId: 'idea-1', feasibility: 8, value: 9 }],
+            },
+            selection: {
+                ideaId: 'idea-1',
+                selectionRationale: 'Best fit',
+                confirmedByUser: true,
+            },
+            plan: {
+                milestones: [
+                    { id: 'm1', title: 'Phase 1', items: ['Task 1'] },
+                ],
+                architectureNotes: 'Node.js + TypeScript',
+            },
+        });
+        const ctx = buildSummarizedContext(session);
+        expect(ctx.businessSummary).toBe('Zava Industries');
+        expect(ctx.challenges).toEqual(['Scaling', 'Automation']);
+        expect(ctx.topicArea).toBe('Customer Support');
+        expect(ctx.workflowSteps).toEqual(['Intake', 'Processing']);
+        expect(ctx.ideaSummaries).toHaveLength(1);
+        expect(ctx.ideaSummaries[0].title).toBe('AI Bot');
+        expect(ctx.evaluationSummary).toContain('feasibility-value-matrix');
+        expect(ctx.selectionSummary).toContain('idea-1');
+        expect(ctx.planMilestones).toEqual(['Phase 1']);
+        expect(ctx.architectureNotes).toBe('Node.js + TypeScript');
+    });
+    it('gracefully handles null fields', () => {
+        const session = emptySession({
+            businessContext: {
+                businessDescription: 'Test Inc',
+                challenges: [],
+            },
+            // Everything else is null/undefined
+        });
+        const ctx = buildSummarizedContext(session);
+        expect(ctx.businessSummary).toBe('Test Inc');
+        expect(ctx.ideaSummaries).toBeUndefined();
+        expect(ctx.evaluationSummary).toBeUndefined();
+    });
+    it('includes discovery enrichment highlights', () => {
+        const session = emptySession({
+            discovery: {
+                enrichment: {
+                    industryTrends: ['AI adoption growing', 'Cloud migration'],
+                    companyNews: ['Raised Series B'],
+                },
+            },
+        });
+        const ctx = buildSummarizedContext(session);
+        expect(ctx.enrichmentHighlights).toBeDefined();
+        expect(ctx.enrichmentHighlights).toContain('AI adoption growing');
+        expect(ctx.enrichmentHighlights).toContain('Raised Series B');
+    });
+});
+describe('renderSummarizedContext', () => {
+    it('returns empty string for empty context', () => {
+        expect(renderSummarizedContext({})).toBe('');
+    });
+    it('renders markdown with all sections', () => {
+        const markdown = renderSummarizedContext({
+            businessSummary: 'Zava Industries',
+            challenges: ['Scaling'],
+            topicArea: 'Support',
+            workflowSteps: ['Intake', 'Processing'],
+            ideaSummaries: [{ id: 'idea-1', title: 'AI Bot', description: 'Automate' }],
+            evaluationSummary: 'Method: feasibility-value-matrix, 1 ideas evaluated',
+            selectionSummary: 'Selected: idea-1',
+            planMilestones: ['Phase 1'],
+            architectureNotes: 'Node.js',
+        });
+        expect(markdown).toContain('## Prior Phase Context');
+        expect(markdown).toContain('### Business Context');
+        expect(markdown).toContain('Zava Industries');
+        expect(markdown).toContain('### Workflow');
+        expect(markdown).toContain('### Ideas');
+        expect(markdown).toContain('### Evaluation');
+        expect(markdown).toContain('### Selection');
+        expect(markdown).toContain('### Plan');
+    });
+    it('omits sections when data is absent', () => {
+        const markdown = renderSummarizedContext({
+            businessSummary: 'Test Inc',
+        });
+        expect(markdown).toContain('Test Inc');
+        expect(markdown).not.toContain('### Ideas');
+        expect(markdown).not.toContain('### Plan');
+    });
+});

package/dist/tests/unit/phases/discoveryEnricher.repeatCalls.spec.js

@@ -0,0 +1,93 @@
+/**
+ * T041 focused: Discovery enricher repeated calls (simplified live test).
+ *
+ * Reproduces the exact scenario from T041 but with detailed logging
+ * to isolate web search behavior across repeated enrichFromWebSearch() calls.
+ *
+ * Gated behind SOFIA_LIVE_MCP_TESTS=true to skip in CI.
+ *
+ * Run with:
+ *   SOFIA_LIVE_MCP_TESTS=true \
+ *   FOUNDRY_PROJECT_ENDPOINT=... \
+ *   FOUNDRY_MODEL_DEPLOYMENT_NAME=... \
+ *   npm test -- tests/unit/phases/discoveryEnricher.repeatCalls.spec.ts
+ */
+import { describe, it, expect } from 'vitest';
+const LIVE = process.env.SOFIA_LIVE_MCP_TESTS === 'true';
+const TEST_COMPANIES = [
+    {
+        summary: '"Nestlé" is a global food and beverage company headquartered in Switzerland.',
+        keywords: ['food', 'beverage', 'switzerland'],
+    },
+    {
+        summary: '"Zara" is a global retail company headquartered in Spain.',
+        keywords: ['retail', 'fashion', 'spain'],
+    },
+    {
+        summary: '"Microsoft Corporation" is a global technology company headquartered in Redmond, Washington.',
+        keywords: ['technology', 'software', 'cloud'],
+    },
+];
+describe.skipIf(!LIVE)('DiscoveryEnricher repeated web search calls (T041 focused)', () => {
+    it('enrichFromWebSearch returns results for each company when called sequentially', async () => {
+        const { DiscoveryEnricher } = await import('../../../src/phases/discoveryEnricher.js');
+        const { createWebSearchTool } = await import('../../../src/mcp/webSearch.js');
+        const webSearchFn = createWebSearchTool({
+            projectEndpoint: process.env.FOUNDRY_PROJECT_ENDPOINT,
+            modelDeploymentName: process.env.FOUNDRY_MODEL_DEPLOYMENT_NAME,
+        });
+        const webSearchClient = {
+            search: async (query) => {
+                console.log(`  [WebSearch] Query: "${query}"`);
+                const result = await webSearchFn(query);
+                console.log(`  [WebSearch] Results: ${result.results.length} items, degraded=${result.degraded}`);
+                if (result.error) {
+                    console.log(`  [WebSearch] Error: ${result.error}`);
+                }
+                return result;
+            },
+        };
+        const enricher = new DiscoveryEnricher();
+        console.log('\n=== T041 Focused: Sequential enrichFromWebSearch Calls ===\n');
+        const allResults = [];
+        for (let idx = 0; idx < TEST_COMPANIES.length; idx++) {
+            const company = TEST_COMPANIES[idx];
+            console.log(`\n[${idx + 1}/${TEST_COMPANIES.length}] Processing: ${company.summary.split('"')[1]}`);
+            const enrichment = await enricher.enrichFromWebSearch(company.summary, webSearchClient);
+            const content = [
+                ...(enrichment.companyNews ?? []),
+                ...(enrichment.competitorInfo ?? []),
+                ...(enrichment.industryTrends ?? []),
+            ];
+            const allText = content.join(' ').toLowerCase();
+            const hasRelevant = company.keywords.some((kw) => allText.includes(kw.toLowerCase()));
+            console.log(`  [Enrichment] companyNews: ${enrichment.companyNews?.length ?? 0}`);
+            console.log(`  [Enrichment] competitorInfo: ${enrichment.competitorInfo?.length ?? 0}`);
+            console.log(`  [Enrichment] industryTrends: ${enrichment.industryTrends?.length ?? 0}`);
+            console.log(`  [Enrichment] Total snippets: ${content.length}`);
+            console.log(`  [Enrichment] Has relevant keyword: ${hasRelevant}`);
+            if (content.length > 0) {
+                console.log(`  [Enrichment] First snippet: ${content[0].slice(0, 80)}...`);
+            }
+            allResults.push({
+                company: company.summary.split('"')[1],
+                snippetCount: content.length,
+                hasRelevantKeyword: hasRelevant,
+                rawContent: content,
+            });
+        }
+        console.log('\n=== Summary ===\n');
+        let relevantCount = 0;
+        for (const r of allResults) {
+            const status = r.hasRelevantKeyword && r.snippetCount > 0 ? '✓' : '✗';
+            console.log(`${status} ${r.company}: ${r.snippetCount} snippets, relevant=${r.hasRelevantKeyword}`);
+            if (r.hasRelevantKeyword && r.snippetCount > 0) {
+                relevantCount++;
+            }
+        }
+        console.log(`\nResult: ${relevantCount}/${TEST_COMPANIES.length} companies have relevant results`);
+        console.log(`Expected: >= 2 for pass (simplified from T041's 3/5 threshold)\n`);
+        // Simplified threshold: at least 2/3
+        expect(relevantCount).toBeGreaterThanOrEqual(2);
+    }, 180_000); // 3 minute timeout for live queries
+});

package/dist/tests/unit/phases/discoveryEnricher.spec.js

@@ -0,0 +1,411 @@
+/**
+ * Tests for DiscoveryEnricher — US3 web search enrichment
+ * and US4 WorkIQ enrichment.
+ *
+ * T026: enrichFromWebSearch() basic functionality
+ * T027: User consent prompt integration
+ * T028: Session schema integration
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DiscoveryEnricher } from '../../../src/phases/discoveryEnricher.js';
+import { DiscoveryEnrichmentSchema, workshopSessionSchema, } from '../../../src/shared/schemas/session.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makeWebSearchClient(results = [], opts) {
+    return {
+        search: opts?.throws
+            ? vi.fn().mockRejectedValue(new Error('search failed'))
+            : vi.fn().mockResolvedValue({
+                results,
+                degraded: opts?.degraded ?? false,
+            }),
+    };
+}
+function makeLoopIO(overrides) {
+    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,
+        ...overrides,
+    };
+}
+function makeMcpManager(overrides) {
+    return {
+        isAvailable: vi.fn().mockReturnValue(false),
+        callTool: vi.fn().mockResolvedValue({}),
+        markConnected: vi.fn(),
+        markDisconnected: vi.fn(),
+        disconnectAll: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}
+// ── T026: enrichFromWebSearch() ──────────────────────────────────────────────
+describe('DiscoveryEnricher', () => {
+    let enricher;
+    beforeEach(() => {
+        enricher = new DiscoveryEnricher();
+    });
+    describe('enrichFromWebSearch() (T026)', () => {
+        it('calls webSearchClient.search with company-news, competitor, and industry-trends queries', async () => {
+            const searchFn = vi.fn().mockResolvedValue({ results: [], degraded: false });
+            const client = { search: searchFn };
+            await enricher.enrichFromWebSearch('Acme Corp makes widgets', client);
+            // Should make 3 search calls (company news, competitors, industry trends)
+            expect(searchFn).toHaveBeenCalledTimes(3);
+            // First query should mention company/news
+            expect(searchFn.mock.calls[0][0]).toMatch(/acme/i);
+            expect(searchFn.mock.calls[0][0]).toMatch(/news/i);
+            // Second should mention competitors/market
+            expect(searchFn.mock.calls[1][0]).toMatch(/competitor|market/i);
+            // Third should mention trends
+            expect(searchFn.mock.calls[2][0]).toMatch(/trend/i);
+        });
+        it('populates companyNews, competitorInfo, industryTrends from results', async () => {
+            const newsResults = [
+                { title: 'Acme raises $10M', url: 'https://a.com', snippet: 'Acme Corp raised $10M' },
+                { title: 'Acme launches product', url: 'https://b.com', snippet: 'New product launched' },
+            ];
+            const competitorResults = [
+                { title: 'Widget Inc grows', url: 'https://c.com', snippet: 'Widget Inc sees 20% growth' },
+            ];
+            const trendResults = [
+                {
+                    title: 'AI in manufacturing',
+                    url: 'https://d.com',
+                    snippet: 'AI transforms manufacturing',
+                },
+            ];
+            const searchFn = vi
+                .fn()
+                .mockResolvedValueOnce({ results: newsResults, degraded: false })
+                .mockResolvedValueOnce({ results: competitorResults, degraded: false })
+                .mockResolvedValueOnce({ results: trendResults, degraded: false });
+            const result = await enricher.enrichFromWebSearch('Acme Corp makes widgets', {
+                search: searchFn,
+            });
+            expect(result.companyNews).toHaveLength(2);
+            expect(result.companyNews[0]).toContain('Acme raises $10M');
+            expect(result.competitorInfo ?? []).toHaveLength(0);
+            expect(result.industryTrends ?? []).toHaveLength(0);
+        });
+        it('stops after first successful query to reduce web search calls', async () => {
+            const searchFn = vi
+                .fn()
+                .mockResolvedValueOnce({
+                results: [{ title: 'Acme news', url: 'https://a.com', snippet: 'Acme in manufacturing' }],
+                degraded: false,
+            })
+                .mockResolvedValue({
+                results: [{ title: 'Should not be used', url: 'https://b.com', snippet: 'unused' }],
+                degraded: false,
+            });
+            const result = await enricher.enrichFromWebSearch('Acme Corp makes widgets', {
+                search: searchFn,
+            });
+            expect(searchFn).toHaveBeenCalledTimes(1);
+            expect(result.companyNews).toHaveLength(1);
+            expect(result.competitorInfo ?? []).toHaveLength(0);
+            expect(result.industryTrends ?? []).toHaveLength(0);
+        });
+        it('returns gracefully with empty arrays when search throws', async () => {
+            const client = makeWebSearchClient([], { throws: true });
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            // Should not throw, should return empty-ish object
+            expect(result.companyNews ?? []).toHaveLength(0);
+            expect(result.competitorInfo ?? []).toHaveLength(0);
+            expect(result.industryTrends ?? []).toHaveLength(0);
+        });
+        it('returns empty when search result is degraded', async () => {
+            const searchFn = vi.fn().mockResolvedValue({ results: [], degraded: true });
+            const client = { search: searchFn };
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            expect(result.companyNews ?? []).toHaveLength(0);
+            expect(result.competitorInfo ?? []).toHaveLength(0);
+        });
+        it('sets sourcesUsed to ["websearch"] when search succeeds', async () => {
+            const newsResults = [{ title: 'News', url: 'https://a.com', snippet: 'snippet' }];
+            const searchFn = vi.fn().mockResolvedValue({ results: newsResults, degraded: false });
+            const client = { search: searchFn };
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            expect(result.sourcesUsed).toContain('websearch');
+        });
+        it('sets enrichedAt to an ISO 8601 timestamp', async () => {
+            const newsResults = [{ title: 'News', url: 'https://a.com', snippet: 'snippet' }];
+            const searchFn = vi.fn().mockResolvedValue({ results: newsResults, degraded: false });
+            const client = { search: searchFn };
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            expect(result.enrichedAt).toBeDefined();
+            // Validate it's a parseable date
+            expect(new Date(result.enrichedAt).toISOString()).toBe(result.enrichedAt);
+        });
+        it('caps array fields at 10 items', async () => {
+            // Return 15 results per query
+            const bigResults = Array.from({ length: 15 }, (_, i) => ({
+                title: `Title ${i}`,
+                url: `https://example.com/${i}`,
+                snippet: `Snippet ${i}`,
+            }));
+            const searchFn = vi.fn().mockResolvedValue({ results: bigResults, degraded: false });
+            const client = { search: searchFn };
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            expect((result.companyNews ?? []).length).toBeLessThanOrEqual(10);
+            expect((result.competitorInfo ?? []).length).toBeLessThanOrEqual(10);
+            expect((result.industryTrends ?? []).length).toBeLessThanOrEqual(10);
+        });
+        it('populates webSearchResults with combined snippets', async () => {
+            const newsResults = [
+                { title: 'News', url: 'https://a.com', snippet: 'Company news snippet' },
+            ];
+            const searchFn = vi.fn().mockResolvedValue({ results: newsResults, degraded: false });
+            const client = { search: searchFn };
+            const result = await enricher.enrichFromWebSearch('Acme Corp', client);
+            expect(result.webSearchResults).toBeDefined();
+            expect(result.webSearchResults).toContain('Company news snippet');
+        });
+    });
+    // ── T027: enrich() user consent / prompt flow ────────────────────────────
+    describe('enrich() consent flow (T027)', () => {
+        it('does not prompt for web search when webSearchClient is not provided', async () => {
+            const io = makeLoopIO();
+            const mcpManager = makeMcpManager();
+            await enricher.enrich({
+                companySummary: 'Acme Corp',
+                mcpManager,
+                io,
+            });
+            // readInput should not be called for web search consent
+            // (web search consent is implicit when webSearchClient is provided)
+            expect(io.readInput).not.toHaveBeenCalled();
+        });
+        it('runs web search when webSearchClient is provided', async () => {
+            const searchFn = vi.fn().mockResolvedValue({
+                results: [{ title: 'News', url: 'https://a.com', snippet: 'snip' }],
+                degraded: false,
+            });
+            const io = makeLoopIO();
+            const mcpManager = makeMcpManager();
+            const result = await enricher.enrich({
+                companySummary: 'Acme Corp',
+                mcpManager,
+                io,
+                webSearchClient: { search: searchFn },
+            });
+            expect(searchFn).toHaveBeenCalled();
+            expect(result.sourcesUsed).toContain('websearch');
+        });
+        it('returns valid DiscoveryEnrichment when all sources unavailable', async () => {
+            const io = makeLoopIO();
+            const mcpManager = makeMcpManager();
+            const result = await enricher.enrich({
+                companySummary: 'Acme Corp',
+                mcpManager,
+                io,
+            });
+            // Should return a valid (possibly empty) enrichment — no crash
+            const parsed = DiscoveryEnrichmentSchema.safeParse(result);
+            expect(parsed.success).toBe(true);
+        });
+    });
+    // ── T028: Session schema integration ─────────────────────────────────────
+    describe('session schema integration (T028)', () => {
+        it('DiscoveryEnrichmentSchema parses valid enrichment', () => {
+            const valid = {
+                webSearchResults: 'Some results',
+                companyNews: ['News 1', 'News 2'],
+                competitorInfo: ['Competitor A'],
+                industryTrends: ['Trend 1'],
+                enrichedAt: new Date().toISOString(),
+                sourcesUsed: ['websearch'],
+            };
+            const parsed = DiscoveryEnrichmentSchema.safeParse(valid);
+            expect(parsed.success).toBe(true);
+        });
+        it('validates enrichedAt is ISO 8601 when present', () => {
+            const invalidDate = {
+                enrichedAt: 'not-a-date',
+                sourcesUsed: ['websearch'],
+            };
+            const parsed = DiscoveryEnrichmentSchema.safeParse(invalidDate);
+            expect(parsed.success).toBe(false);
+        });
+        it('validates sourcesUsed entries are lowercase strings', () => {
+            const valid = {
+                sourcesUsed: ['websearch', 'workiq'],
+            };
+            const parsed = DiscoveryEnrichmentSchema.safeParse(valid);
+            expect(parsed.success).toBe(true);
+        });
+        it('session with discovery.enrichment round-trips through workshopSessionSchema.parse()', () => {
+            const session = {
+                sessionId: 'test-123',
+                schemaVersion: '0.3.0',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                phase: 'Discover',
+                status: 'Active',
+                participants: [],
+                artifacts: { generatedFiles: [] },
+                discovery: {
+                    enrichment: {
+                        companyNews: ['News headline'],
+                        competitorInfo: ['Competitor X'],
+                        industryTrends: ['AI trend'],
+                        enrichedAt: new Date().toISOString(),
+                        sourcesUsed: ['websearch'],
+                    },
+                },
+            };
+            const parsed = workshopSessionSchema.safeParse(session);
+            expect(parsed.success).toBe(true);
+            if (parsed.success) {
+                expect(parsed.data.discovery?.enrichment?.companyNews).toEqual(['News headline']);
+            }
+        });
+        it('rejects array fields exceeding max 10 items', () => {
+            const tooMany = {
+                companyNews: Array.from({ length: 11 }, (_, i) => `News ${i}`),
+            };
+            const parsed = DiscoveryEnrichmentSchema.safeParse(tooMany);
+            expect(parsed.success).toBe(false);
+        });
+        it('accepts completely empty enrichment', () => {
+            const parsed = DiscoveryEnrichmentSchema.safeParse({});
+            expect(parsed.success).toBe(true);
+        });
+    });
+    // ── T034: enrichFromWorkIQ() ──────────────────────────────────────────────
+    describe('enrichFromWorkIQ() (T034)', () => {
+        it('prompts user for consent via io.readInput before any callTool call', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('n') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+            });
+            await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            expect(io.readInput).toHaveBeenCalled();
+            // Should have asked before calling callTool
+            expect(mcpManager.callTool).not.toHaveBeenCalled();
+        });
+        it('calls mcpManager.callTool when user consents with "y"', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockResolvedValue({
+                    teamExpertise: ['TypeScript', 'React'],
+                    collaborationPatterns: ['Daily standups'],
+                    documentationGaps: ['API docs missing'],
+                }),
+            });
+            const result = await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            expect(mcpManager.callTool).toHaveBeenCalledWith('workiq', 'analyze_team', expect.objectContaining({ summary: 'Acme Corp' }), { timeoutMs: 30_000 });
+            expect(result.workiqInsights).toBeDefined();
+            expect(result.workiqInsights.teamExpertise).toContain('TypeScript');
+            expect(result.workiqInsights.collaborationPatterns).toContain('Daily standups');
+            expect(result.workiqInsights.documentationGaps).toContain('API docs missing');
+            expect(result.sourcesUsed).toContain('workiq');
+        });
+        it('returns empty workiqInsights when user declines', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('n') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+            });
+            const result = await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            expect(result.workiqInsights).toBeUndefined();
+            expect(mcpManager.callTool).not.toHaveBeenCalled();
+        });
+        it('returns empty workiqInsights when user presses Enter (default No)', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+            });
+            const result = await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            expect(result.workiqInsights).toBeUndefined();
+            expect(mcpManager.callTool).not.toHaveBeenCalled();
+        });
+        it('returns empty workiqInsights gracefully when callTool throws', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockRejectedValue(new Error('WorkIQ timeout')),
+            });
+            const result = await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            // Should not throw
+            expect(result.workiqInsights).toBeUndefined();
+        });
+        it('extracts insights from response.insights fallback (split by newline)', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockResolvedValue({
+                    insights: 'Expert in TypeScript\nDaily standups\nMissing API docs',
+                }),
+            });
+            const result = await enricher.enrichFromWorkIQ('Acme Corp', mcpManager, io);
+            expect(result.workiqInsights).toBeDefined();
+            // When response has only 'insights' string, it gets split
+            expect(result.workiqInsights.teamExpertise).toBeDefined();
+        });
+    });
+    // ── T035: enrich() orchestrator with WorkIQ ──────────────────────────────
+    describe('enrich() orchestrator with WorkIQ (T035)', () => {
+        it('calls enrichFromWorkIQ when WorkIQ is available', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockResolvedValue({
+                    teamExpertise: ['Node.js'],
+                    collaborationPatterns: ['Async reviews'],
+                    documentationGaps: ['Onboarding docs'],
+                }),
+            });
+            const result = await enricher.enrich({
+                companySummary: 'Acme Corp makes widgets',
+                mcpManager,
+                io,
+            });
+            expect(result.workiqInsights).toBeDefined();
+            expect(result.sourcesUsed).toContain('workiq');
+        });
+        it('merges WorkIQ results with web search results', async () => {
+            const searchFn = vi.fn().mockResolvedValue({
+                results: [{ title: 'News', url: 'https://a.com', snippet: 'snip' }],
+                degraded: false,
+            });
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockResolvedValue({
+                    teamExpertise: ['Python'],
+                    collaborationPatterns: [],
+                    documentationGaps: [],
+                }),
+            });
+            const result = await enricher.enrich({
+                companySummary: 'Acme Corp',
+                mcpManager,
+                io,
+                webSearchClient: { search: searchFn },
+            });
+            expect(result.sourcesUsed).toContain('websearch');
+            expect(result.sourcesUsed).toContain('workiq');
+            expect(result.companyNews).toBeDefined();
+            expect(result.workiqInsights).toBeDefined();
+        });
+        it('returns valid DiscoveryEnrichment with all empty fields when WorkIQ fails', async () => {
+            const io = makeLoopIO({ readInput: vi.fn().mockResolvedValue('y') });
+            const mcpManager = makeMcpManager({
+                isAvailable: vi.fn().mockReturnValue(true),
+                callTool: vi.fn().mockRejectedValue(new Error('WorkIQ down')),
+            });
+            const result = await enricher.enrich({
+                companySummary: 'Acme Corp',
+                mcpManager,
+                io,
+            });
+            const parsed = DiscoveryEnrichmentSchema.safeParse(result);
+            expect(parsed.success).toBe(true);
+        });
+    });
+});