edsger 0.51.0 → 0.53.0

package/dist/phases/feature-analysis-verification/index.d.ts

@@ -1,25 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type FeatureAnalysisContext } from '../feature-analysis/context.js';
-import { type ChecklistVerificationResult } from './agent.js';
-interface VerificationCycleResult {
-    passed: boolean;
-    verificationResult: ChecklistVerificationResult | null;
-    nextPrompt?: string;
-}
-/**
- * Perform verification and determine if iteration should continue
- * This function only verifies - it does NOT manage artifacts (save/delete/update)
- */
-export interface FeatureAnalysisVerificationOptions {
-    structuredAnalysisResult: Record<string, unknown>;
-    checklistContext: ChecklistPhaseContext | null;
-    context: FeatureAnalysisContext;
-    config: EdsgerConfig;
-    currentIteration: number;
-    maxIterations: number;
-    featureId: string;
-    verbose?: boolean;
-}
-export declare function performVerificationCycle(opts: FeatureAnalysisVerificationOptions): Promise<VerificationCycleResult>;
-export {};

package/dist/phases/feature-analysis-verification/index.js

@@ -1,92 +0,0 @@
-import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createImprovementPrompt } from '../feature-analysis/prompts.js';
-import { verifyChecklistCompliance, } from './agent.js';
-export async function performVerificationCycle(opts) {
-    const { structuredAnalysisResult, checklistContext, context, config, currentIteration, maxIterations, featureId, verbose, } = opts;
-    // No verification needed if no checklist context
-    if (!checklistContext || checklistContext.checklists.length === 0) {
-        return { passed: true, verificationResult: null };
-    }
-    const createdUserStories = (structuredAnalysisResult.created_user_stories ||
-        []);
-    const createdTestCases = (structuredAnalysisResult.created_test_cases ||
-        []);
-    if (verbose) {
-        logInfo('🔍 Starting checklist verification...');
-    }
-    const verificationResult = await verifyChecklistCompliance({
-        checklistContext,
-        analysisContext: context,
-        createdUserStories: createdUserStories || [],
-        createdTestCases: createdTestCases || [],
-        verbose,
-    }, config);
-    // Verification passed
-    if (verificationResult.rejected_count === 0) {
-        if (verbose) {
-            logInfo(`✅ Checklist verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
-        }
-        // Log verification success
-        await logFeatureVerificationEvent({
-            featureId,
-            phase: 'feature_analysis',
-            iteration: currentIteration,
-            result: 'success',
-            verificationData: {
-                confirmed_count: verificationResult.confirmed_count,
-                rejected_count: verificationResult.rejected_count,
-                uncertain_count: verificationResult.uncertain_count,
-                summary: verificationResult.summary,
-            },
-        }, verbose);
-        return { passed: true, verificationResult };
-    }
-    // Verification failed
-    logError(`❌ Iteration ${currentIteration}: Checklist verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
-    // Log verification failure with improvement suggestions
-    await logFeatureVerificationEvent({
-        featureId,
-        phase: 'feature_analysis',
-        iteration: currentIteration,
-        result: 'error',
-        verificationData: {
-            confirmed_count: verificationResult.confirmed_count,
-            rejected_count: verificationResult.rejected_count,
-            uncertain_count: verificationResult.uncertain_count,
-            rejected_items: verificationResult.item_verifications
-                .filter((item) => item.verification_status === 'rejected')
-                .map((item) => ({
-                checklist_item_id: item.checklist_item_id,
-                reason: item.verification_reason || 'No reason provided',
-                concerns: item.concerns || [],
-                improvement_suggestions: item.improvement_suggestions || [],
-            })),
-            uncertain_items: verificationResult.item_verifications
-                .filter((item) => item.verification_status === 'uncertain')
-                .map((item) => ({
-                checklist_item_id: item.checklist_item_id,
-                reason: item.verification_reason || 'No reason provided',
-                concerns: item.concerns || [],
-                improvement_suggestions: item.improvement_suggestions || [],
-            })),
-            summary: verificationResult.summary,
-            overall_suggestions: verificationResult.overall_suggestions || [],
-        },
-    }, verbose);
-    // Check if we can iterate again
-    if (currentIteration < maxIterations) {
-        if (verbose) {
-            logInfo(`   Will retry with improvement feedback (${maxIterations - currentIteration} attempts remaining)`);
-        }
-        // Create improvement prompt for next iteration
-        const nextPrompt = createImprovementPrompt(verificationResult, {
-            created_user_stories: createdUserStories || [],
-            created_test_cases: createdTestCases || [],
-        });
-        return { passed: false, verificationResult, nextPrompt };
-    }
-    // Max iterations reached
-    logError(`❌ Maximum iterations (${maxIterations}) reached. Checklist verification still failing.`);
-    return { passed: false, verificationResult };
-}

package/dist/phases/feature-analysis-verification/prompts.d.ts

@@ -1,10 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type FeatureAnalysisContext } from '../feature-analysis/context.js';
-export declare const createChecklistVerificationSystemPrompt: (projectDir?: string) => Promise<string>;
-export interface ChecklistVerificationPromptOptions {
-    checklistContext: ChecklistPhaseContext;
-    analysisContext: FeatureAnalysisContext;
-    createdUserStories: any[];
-    createdTestCases: any[];
-}
-export declare const createChecklistVerificationPrompt: (options: ChecklistVerificationPromptOptions) => string;

package/dist/phases/feature-analysis-verification/prompts.js

@@ -1,100 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createChecklistVerificationSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/feature-analysis-verification', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/feature-analysis-verification');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['feature-analysis-verification']}`;
-};
-export const createChecklistVerificationPrompt = (options) => {
-    const { checklistContext, analysisContext, createdUserStories, createdTestCases, } = options;
-    // Format all checklist items with their requirements
-    const checklistItemsSection = checklistContext.checklists
-        .flatMap((checklist) => checklist.items.map((item) => {
-        return `### Checklist Item: ${item.title}
-**ID**: ${item.id}
-**Checklist**: ${checklist.name} (${checklist.role})
-**Requirement**: ${item.description}
-**Required**: ${item.is_required ? 'Yes' : 'No'}
-**Type**: ${item.item_type}
-`;
-    }))
-        .join('\n---\n');
-    // Format created user stories
-    const userStoriesSection = createdUserStories.length > 0
-        ? createdUserStories
-            .map((story, index) => `${index + 1}. **${story.title}**
-   ${story.description}
-   Status: ${story.status || 'draft'}`)
-            .join('\n\n')
-        : 'No user stories were created';
-    // Format created test cases
-    const testCasesSection = createdTestCases.length > 0
-        ? createdTestCases
-            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
-   ${testCase.description}`)
-            .join('\n\n')
-        : 'No test cases were created';
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    return `# Checklist Verification Task
-
-You are verifying that generated artifacts (user stories and test cases) satisfy checklist requirements.
-
-## Feature Context
-
-**Feature**: ${analysisContext.feature.name}
-**Feature ID**: ${analysisContext.feature.id}
-**Description**: ${analysisContext.feature.description || 'No description'}
-**Product**: ${analysisContext.product.name}
-
-## Generated Artifacts
-
-### User Stories (${createdUserStories.length})
-${userStoriesSection}
-
-### Test Cases (${createdTestCases.length})
-${testCasesSection}
-
-## Checklist Requirements to Verify (${totalChecklistItems})
-
-${checklistItemsSection}
-
----
-
-## Your Verification Task
-
-For EACH checklist item above:
-
-1. **Understand the Requirement**: What does this checklist item require?
-
-2. **Examine the Artifacts**: Look at the user stories and test cases above
-
-3. **Determine Coverage**: Do the artifacts adequately address this requirement?
-   - Do they directly address the requirement?
-   - Is the coverage concrete and specific?
-   - Is there sufficient quality and depth?
-   - Are there any gaps or missing elements?
-
-   **Note**: Verify the actual quality/result, not whether the artifacts mention the requirement.
-   Example: For "check duplicates" → verify if artifacts are actually duplicate-free, not if they mention checking duplicates.
-
-4. **Make Your Determination**:
-   - **CONFIRMED** (is_satisfied: true): The artifacts clearly and adequately satisfy this requirement
-   - **REJECTED** (is_satisfied: false): The requirement is not addressed, or addressed insufficiently
-   - **UNCERTAIN** (is_satisfied: false): The artifacts partially address the requirement but with gaps
-
-5. **Document Your Reasoning**: Provide specific, detailed reasons for your decision
-
-6. **Provide Improvement Suggestions** (for rejected/uncertain items):
-   - Be specific and actionable
-   - Suggest what user stories or test cases should be added
-   - Indicate what should be expanded or modified
-   - Give concrete examples when possible
-
-Remember: Focus on what the artifacts actually contain, not on claims. Be thorough and fair.
-
-Provide your verification results in the required JSON format with improvement_suggestions for any rejected or uncertain items.`;
-};

package/dist/phases/intelligence-analysis/__tests__/context.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for intelligence analysis context formatting.
- */
-export {};

package/dist/phases/intelligence-analysis/__tests__/context.test.js

@@ -1,192 +0,0 @@
-/**
- * Unit tests for intelligence analysis context formatting.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { formatContextForPrompt, } from '../context.js';
-const makeContext = (overrides = {}) => ({
-    product: {
-        id: 'prod-001',
-        name: 'Edsger',
-        description: 'AI-powered software development automation.',
-        features: [
-            {
-                name: 'Code Generation',
-                description: 'AI writes code',
-                status: 'shipped',
-            },
-            {
-                name: 'Growth Analysis',
-                description: 'Marketing automation',
-                status: 'shipped',
-            },
-        ],
-    },
-    confirmedCompetitors: [],
-    suggestedCompetitors: [],
-    previousSnapshots: new Map(),
-    ...overrides,
-});
-const makeCompetitor = (name, id = `comp-${name.toLowerCase()}`) => ({
-    id,
-    product_id: 'prod-001',
-    name,
-    url: `https://${name.toLowerCase()}.com`,
-    app_store_url: null,
-    play_store_url: null,
-    description: `${name} description`,
-    category: 'developer-tools',
-    status: 'confirmed',
-    discovery_source: 'ai_discovery',
-    discovery_reason: 'Frequently compared',
-    notes: null,
-    created_by: 'user-1',
-    created_at: '2026-03-25',
-    updated_at: '2026-03-25',
-});
-// ============================================================
-// Product info in context
-// ============================================================
-void describe('formatContextForPrompt — product info', () => {
-    void it('should include product name', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('Edsger'));
-    });
-    void it('should include product description', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('AI-powered software development automation'));
-    });
-    void it('should include product ID', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('prod-001'));
-    });
-    void it('should list features with bold names', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('**Code Generation**'));
-        assert.ok(result.includes('**Growth Analysis**'));
-    });
-    void it('should show feature count', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('Product Features (2)'));
-    });
-    void it('should handle empty features', () => {
-        const ctx = makeContext({
-            product: { id: 'p1', name: 'X', description: '', features: [] },
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No features listed'));
-    });
-    void it('should handle missing description', () => {
-        const ctx = makeContext({
-            product: {
-                id: 'p1',
-                name: 'X',
-                description: undefined,
-                features: [],
-            },
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No description provided'));
-    });
-});
-// ============================================================
-// No competitors — discovery prompt
-// ============================================================
-void describe('formatContextForPrompt — no competitors', () => {
-    void it('should indicate no competitors registered', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('No competitors registered yet'));
-    });
-    void it('should instruct to discover competitors', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('discover'));
-    });
-});
-// ============================================================
-// With confirmed competitors
-// ============================================================
-void describe('formatContextForPrompt — with confirmed competitors', () => {
-    const competitor = makeCompetitor('Linear');
-    void it('should show competitor name as heading', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('### Linear'));
-    });
-    void it('should show competitor ID', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('comp-linear'));
-    });
-    void it('should show competitor URL', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('https://linear.com'));
-    });
-    void it('should show confirmed count', () => {
-        const ctx = makeContext({
-            confirmedCompetitors: [makeCompetitor('A'), makeCompetitor('B')],
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('Confirmed Competitors (2)'));
-    });
-    void it('should show N/A for missing app store URLs', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('App Store**: N/A'));
-    });
-    void it('should include snapshot data when available', () => {
-        const snapshots = new Map();
-        snapshots.set('comp-linear', [
-            {
-                id: 'snap-1',
-                competitor_id: 'comp-linear',
-                product_id: 'prod-001',
-                features: [
-                    { name: 'Issues', description: 'Issue tracking', is_new: false },
-                ],
-                pricing: { model: 'freemium' },
-                tech_stack: [],
-                app_rating: 4.5,
-                app_review_count: 1200,
-                app_version: '2.0',
-                app_last_updated: null,
-                recent_reviews: [],
-                social_mentions: {},
-                changes_detected: [],
-                source: 'ai_analysis',
-                raw_data: null,
-                created_at: '2026-03-25',
-            },
-        ]);
-        const ctx = makeContext({
-            confirmedCompetitors: [competitor],
-            previousSnapshots: snapshots,
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('Rating: 4.5'));
-        assert.ok(result.includes('Reviews: 1200'));
-        assert.ok(result.includes('Pricing model: freemium'));
-    });
-    void it('should show "No previous data" without snapshots', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No previous data'));
-    });
-});
-// ============================================================
-// Human guidance
-// ============================================================
-void describe('formatContextForPrompt — guidance', () => {
-    void it('should include guidance when provided', () => {
-        const result = formatContextForPrompt(makeContext(), 'Focus on pricing changes');
-        assert.ok(result.includes('Focus on pricing changes'));
-    });
-    void it('should have priority callout for guidance', () => {
-        const result = formatContextForPrompt(makeContext(), 'Focus on pricing');
-        assert.ok(result.includes('Follow this guidance closely'));
-    });
-    void it('should not include guidance section when absent', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(!result.includes('Human Analysis Guidance'));
-    });
-});

package/dist/phases/intelligence-analysis/__tests__/matching.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Unit tests for competitor snapshot matching logic.
- *
- * Tests the PRODUCTION resolveCompetitorId and buildCompetitorIndex
- * functions exported from index.ts.
- *
- * The matching uses a 4-tier strategy:
- * 1. Direct competitor_id match
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip suffixes like "App", "Inc")
- * 4. Substring match
- */
-export {};

package/dist/phases/intelligence-analysis/__tests__/matching.test.js

@@ -1,154 +0,0 @@
-/**
- * Unit tests for competitor snapshot matching logic.
- *
- * Tests the PRODUCTION resolveCompetitorId and buildCompetitorIndex
- * functions exported from index.ts.
- *
- * The matching uses a 4-tier strategy:
- * 1. Direct competitor_id match
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip suffixes like "App", "Inc")
- * 4. Substring match
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildCompetitorIndex, resolveCompetitorId } from '../index.js';
-const competitors = [
-    { id: 'id-linear', name: 'Linear' },
-    { id: 'id-cursor', name: 'Cursor' },
-    { id: 'id-github-copilot', name: 'GitHub Copilot' },
-    { id: 'id-vercel', name: 'Vercel Inc' },
-];
-const { idSet, nameToId } = buildCompetitorIndex(competitors);
-// ============================================================
-// buildCompetitorIndex
-// ============================================================
-void describe('buildCompetitorIndex', () => {
-    void it('should populate idSet with all competitor IDs', () => {
-        assert.strictEqual(idSet.size, 4);
-        assert.ok(idSet.has('id-linear'));
-        assert.ok(idSet.has('id-cursor'));
-        assert.ok(idSet.has('id-github-copilot'));
-        assert.ok(idSet.has('id-vercel'));
-    });
-    void it('should index exact names (lowercased)', () => {
-        assert.strictEqual(nameToId.get('linear'), 'id-linear');
-        assert.strictEqual(nameToId.get('cursor'), 'id-cursor');
-        assert.strictEqual(nameToId.get('github copilot'), 'id-github-copilot');
-    });
-    void it('should index normalized names (suffix stripped)', () => {
-        // "Vercel Inc" → "vercel" should also be indexed
-        assert.strictEqual(nameToId.get('vercel'), 'id-vercel');
-    });
-    void it('should not double-index when name has no suffix', () => {
-        // "Linear" has no suffix to strip, so only "linear" should be in map
-        // Count entries for id-linear
-        let count = 0;
-        for (const [, id] of nameToId) {
-            if (id === 'id-linear') {
-                count++;
-            }
-        }
-        assert.strictEqual(count, 1);
-    });
-    void it('should handle empty list', () => {
-        const { idSet: emptyIds, nameToId: emptyNames } = buildCompetitorIndex([]);
-        assert.strictEqual(emptyIds.size, 0);
-        assert.strictEqual(emptyNames.size, 0);
-    });
-});
-// ============================================================
-// Tier 1: Direct ID match
-// ============================================================
-void describe('resolveCompetitorId — direct ID match', () => {
-    void it('should match by exact competitor_id', () => {
-        const result = resolveCompetitorId({ competitor_id: 'id-linear', competitor_name: 'Whatever' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should ignore invalid competitor_id and fall through to name', () => {
-        const result = resolveCompetitorId({ competitor_id: 'id-nonexistent', competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should handle undefined competitor_id', () => {
-        const result = resolveCompetitorId({ competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should prefer ID over name when both match different competitors', () => {
-        // If AI returns id for Cursor but name "Linear", ID wins
-        const result = resolveCompetitorId({ competitor_id: 'id-cursor', competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-cursor');
-    });
-});
-// ============================================================
-// Tier 2: Exact name match (case-insensitive)
-// ============================================================
-void describe('resolveCompetitorId — exact name match', () => {
-    void it('should match exact name', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match case-insensitively', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'linear' }, idSet, nameToId), 'id-linear');
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'LINEAR' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match multi-word names', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'GitHub Copilot' }, idSet, nameToId), 'id-github-copilot');
-    });
-    void it('should match multi-word names case-insensitively', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'github copilot' }, idSet, nameToId), 'id-github-copilot');
-    });
-});
-// ============================================================
-// Tier 3: Normalized name match (strip suffixes)
-// ============================================================
-void describe('resolveCompetitorId — normalized name match', () => {
-    void it('should match "Vercel" against "Vercel Inc"', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Vercel' }, idSet, nameToId), 'id-vercel');
-    });
-    void it('should match "Linear App" against "Linear"', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear App' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match with ".io" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-render', name: 'Render.io' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Render' }, ids, names), 'id-render');
-    });
-    void it('should match with ".com" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-netlify', name: 'Netlify.com' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Netlify' }, ids, names), 'id-netlify');
-    });
-    void it('should match with "Ltd" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-acme', name: 'Acme Ltd' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Acme' }, ids, names), 'id-acme');
-    });
-});
-// ============================================================
-// Tier 4: Substring match
-// ============================================================
-void describe('resolveCompetitorId — substring match', () => {
-    void it('should match when snapshot name contains competitor name', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Cursor AI Editor' }, idSet, nameToId), 'id-cursor');
-    });
-    void it('should match when competitor name contains snapshot name', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-ghc', name: 'GitHub Copilot Enterprise' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'github copilot' }, ids, names), 'id-ghc');
-    });
-});
-// ============================================================
-// No match
-// ============================================================
-void describe('resolveCompetitorId — no match', () => {
-    void it('should return undefined for unknown competitor', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Completely Unknown Tool' }, idSet, nameToId), undefined);
-    });
-    void it('should return undefined with empty index', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear' }, ids, names), undefined);
-    });
-});

package/dist/phases/intelligence-analysis/__tests__/orchestration.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Integration tests for analyseIntelligence orchestration.
- * Uses dependency injection to mock API calls and AI agent.
- */
-export {};