@avi770/testteam 3.0.0 → 3.2.0

package/agents/69-type-safety-auditor.ts

@@ -1,164 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-
-/** Find all .ts files under a directory (excluding tests and node_modules). */
-function findTsFiles(dir: string, results: string[] = []): string[] {
-  if (!fs.existsSync(dir)) return results;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'dist') {
-      findTsFiles(fullPath, results);
-    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-export class TypeSafetyAuditorAgent extends BaseAgent {
-  readonly agentId = 69;
-  readonly agentName = 'Type Safety Auditor';
-
-  protected async preFlight(): Promise<void> {
-    // File-based agent
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const projectRoot = this.config.projectRoot ?? process.cwd();
-    const srcDir = path.join(projectRoot, 'src');
-
-    if (!fs.existsSync(srcDir)) {
-      findings.push({
-        id: `${this.agentId}-no-src-dir`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'type-safety-auditor',
-        description: 'No src/ directory found in project root',
-      });
-      return findings;
-    }
-
-    const tsFiles = findTsFiles(srcDir);
-    let anyCount = 0;
-    let tsIgnoreCount = 0;
-    let asAnyCount = 0;
-    let missingReturnTypeCount = 0;
-
-    for (const filePath of tsFiles) {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const lines = content.split('\n');
-      const relPath = path.relative(projectRoot, filePath);
-
-      for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-        const line = lines[lineNum];
-
-        // Check for : any (type annotation)
-        if (/:\s*any[^a-zA-Z]/.test(line) || /:\s*any\s*$/.test(line)) {
-          anyCount++;
-          if (anyCount <= 5) {
-            findings.push({
-              id: `${this.agentId}-any-type-${anyCount}`,
-              type: 'test-bug',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'type-safety-auditor',
-              file: filePath,
-              line: lineNum + 1,
-              description: `"any" type annotation in ${relPath}:${lineNum + 1}`,
-            });
-          }
-        }
-
-        // Check for @ts-ignore
-        if (/@ts-ignore/.test(line)) {
-          tsIgnoreCount++;
-          if (tsIgnoreCount <= 3) {
-            findings.push({
-              id: `${this.agentId}-ts-ignore-${tsIgnoreCount}`,
-              type: 'test-bug',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'type-safety-auditor',
-              file: filePath,
-              line: lineNum + 1,
-              description: `@ts-ignore comment in ${relPath}:${lineNum + 1}`,
-            });
-          }
-        }
-
-        // Check for "as any"
-        if (/as\s+any\b/.test(line)) {
-          asAnyCount++;
-          if (asAnyCount <= 3) {
-            findings.push({
-              id: `${this.agentId}-as-any-${asAnyCount}`,
-              type: 'test-bug',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'type-safety-auditor',
-              file: filePath,
-              line: lineNum + 1,
-              description: `"as any" assertion in ${relPath}:${lineNum + 1}`,
-            });
-          }
-        }
-
-        // Check for missing return types on exported functions
-        if (/^export\s+(async\s+)?function\s+\w+\s*\([^)]*\)\s*\{/.test(line.trim())) {
-          // No return type annotation before {
-          missingReturnTypeCount++;
-          if (missingReturnTypeCount <= 3) {
-            findings.push({
-              id: `${this.agentId}-missing-return-type-${missingReturnTypeCount}`,
-              type: 'test-bug',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'type-safety-auditor',
-              file: filePath,
-              line: lineNum + 1,
-              description: `Exported function missing return type in ${relPath}:${lineNum + 1}`,
-            });
-          }
-        }
-      }
-    }
-
-    // Summary findings
-    if (anyCount > 5) {
-      findings.push({
-        id: `${this.agentId}-any-summary`,
-        type: 'test-bug',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'type-safety-auditor',
-        description: `${anyCount} total "any" type annotations found (showing first 5)`,
-      });
-    }
-
-    if (tsIgnoreCount > 3) {
-      findings.push({
-        id: `${this.agentId}-ts-ignore-summary`,
-        type: 'test-bug',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'type-safety-auditor',
-        description: `${tsIgnoreCount} total @ts-ignore comments found (showing first 3)`,
-      });
-    }
-
-    this.addEvidence({
-      type: 'log',
-      path: '',
-      description: `Scanned ${tsFiles.length} files: ${anyCount} any, ${tsIgnoreCount} @ts-ignore, ${asAnyCount} as any, ${missingReturnTypeCount} missing return types`,
-    });
-
-    return findings;
-  }
-}

package/agents/70-complexity-analyzer.ts

@@ -1,179 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-
-/** Find all .ts files under a directory (excluding tests and node_modules). */
-function findTsFiles(dir: string, results: string[] = []): string[] {
-  if (!fs.existsSync(dir)) return results;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'dist') {
-      findTsFiles(fullPath, results);
-    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts') && !entry.name.endsWith('.spec.ts') && !entry.name.endsWith('.d.ts')) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-/** Branch keywords for rough cyclomatic complexity. */
-const BRANCH_KEYWORDS = /\b(if|else\s+if|else|switch|case|for|while|do|catch|&&|\|\||\?\?)\b/g;
-
-interface FunctionInfo {
-  name: string;
-  startLine: number;
-  branchCount: number;
-}
-
-export class ComplexityAnalyzerAgent extends BaseAgent {
-  readonly agentId = 70;
-  readonly agentName = 'Complexity Analyzer';
-
-  protected async preFlight(): Promise<void> {
-    // File-based agent
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const projectRoot = this.config.projectRoot ?? process.cwd();
-    const srcDir = path.join(projectRoot, 'src');
-
-    if (!fs.existsSync(srcDir)) {
-      findings.push({
-        id: `${this.agentId}-no-src-dir`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'complexity-analyzer',
-        description: 'No src/ directory found in project root',
-      });
-      return findings;
-    }
-
-    const tsFiles = findTsFiles(srcDir);
-    let complexFunctionCount = 0;
-    let longFileCount = 0;
-
-    for (const filePath of tsFiles) {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const lines = content.split('\n');
-      const relPath = path.relative(projectRoot, filePath);
-
-      // Check file length
-      if (lines.length > 1000) {
-        findings.push({
-          id: `${this.agentId}-very-long-file-${longFileCount}`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: 'complexity-analyzer',
-          file: filePath,
-          description: `File ${relPath} has ${lines.length} lines (>1000) — consider splitting`,
-        });
-        longFileCount++;
-      } else if (lines.length > 500) {
-        findings.push({
-          id: `${this.agentId}-long-file-${longFileCount}`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'complexity-analyzer',
-          file: filePath,
-          description: `File ${relPath} has ${lines.length} lines (>500) — consider refactoring`,
-        });
-        longFileCount++;
-      }
-
-      // Analyze function complexity
-      const functions = this.extractFunctions(lines);
-      for (const fn of functions) {
-        if (fn.branchCount > 15) {
-          complexFunctionCount++;
-          if (complexFunctionCount <= 10) {
-            findings.push({
-              id: `${this.agentId}-complex-function-${complexFunctionCount}`,
-              type: 'test-bug',
-              severity: 'medium',
-              agentId: this.agentId,
-              module: 'complexity-analyzer',
-              file: filePath,
-              line: fn.startLine,
-              description: `Function "${fn.name}" in ${relPath}:${fn.startLine} has ${fn.branchCount} branches (>15) — high cyclomatic complexity`,
-              suggestedFix: 'Refactor into smaller functions with single responsibilities',
-            });
-          }
-        }
-      }
-    }
-
-    if (complexFunctionCount > 10) {
-      findings.push({
-        id: `${this.agentId}-complex-functions-summary`,
-        type: 'test-bug',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'complexity-analyzer',
-        description: `${complexFunctionCount} functions with high complexity found (showing first 10)`,
-      });
-    }
-
-    this.addEvidence({
-      type: 'log',
-      path: '',
-      description: `Scanned ${tsFiles.length} files: ${complexFunctionCount} complex functions, ${longFileCount} long files`,
-    });
-
-    return findings;
-  }
-
-  private extractFunctions(lines: string[]): FunctionInfo[] {
-    const functions: FunctionInfo[] = [];
-    let currentFunction: FunctionInfo | null = null;
-    let braceDepth = 0;
-    let functionBraceStart = 0;
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Detect function start
-      const funcMatch = trimmed.match(/(?:async\s+)?(?:function\s+(\w+)|(\w+)\s*(?:=|:)\s*(?:async\s+)?(?:\([^)]*\)|[^=]*)=>|(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{)/);
-
-      if (funcMatch && !currentFunction) {
-        const name = funcMatch[1] ?? funcMatch[2] ?? funcMatch[3] ?? 'anonymous';
-        currentFunction = { name, startLine: i + 1, branchCount: 0 };
-        functionBraceStart = braceDepth;
-      }
-
-      // Count braces
-      for (const ch of line) {
-        if (ch === '{') braceDepth++;
-        if (ch === '}') braceDepth--;
-      }
-
-      // Count branches in current function
-      if (currentFunction) {
-        const matches = trimmed.match(BRANCH_KEYWORDS);
-        if (matches) {
-          currentFunction.branchCount += matches.length;
-        }
-      }
-
-      // Function ended
-      if (currentFunction && braceDepth <= functionBraceStart) {
-        functions.push(currentFunction);
-        currentFunction = null;
-      }
-    }
-
-    if (currentFunction) {
-      functions.push(currentFunction);
-    }
-
-    return functions;
-  }
-}

package/agents/__tests__/01-analyst.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readFileSync } from 'node:fs';
-import type { ValidatedConfig } from '../../core/config';
-
-// Mock node:child_process before importing the agent
-vi.mock('node:child_process', () => ({
-  execFile: vi.fn(),
-}));
-
-// Use real node:fs/promises so writeFile actually writes to the temp runDir
-
-import { execFile } from 'node:child_process';
-import { AnalystAgent } from '../01-analyst';
-
-const mockedExecFile = vi.mocked(execFile);
-
-function makeExecFileCallback(stdout: string, stderr = '', error: Error | null = null) {
-  return (...args: unknown[]) => {
-    // execFile may be called with or without an options object:
-    //   execFile(file, args, cb)  OR  execFile(file, args, options, cb)
-    const cb = args[args.length - 1] as (err: Error | null, result: { stdout: string; stderr: string }) => void;
-    cb(error, { stdout, stderr });
-  };
-}
-
-const stubConfig: ValidatedConfig = {
-  schemaVersion: 1,
-  name: 'test',
-  auth: { loginUrl: 'http://localhost' },
-  modules: [
-    { id: 'triage', route: '/triage', sidebarIcon: true },
-    { id: 'clients', route: '/clients', sidebarIcon: true },
-    { id: 'dashboard', route: '/dashboard', sidebarIcon: false },
-  ],
-  environments: {},
-  portals: [],
-  breakpoints: [],
-  integrations: [],
-  workers: [],
-  workflows: [],
-  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
-  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
-  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
-  agentClassification: { blocking: [], advisory: [] },
-  thresholds: {
-    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
-    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
-    apiResponseTime: 2000,
-    bundleSizeLimit: 500000,
-    maxConsoleErrors: 0,
-  },
-  disabledAgents: [],
-  disabledAgentSet: new Set<number>(),
-};
-
-function createAgent(runDir: string): AnalystAgent {
-  return new AnalystAgent(stubConfig, 'alpha', runDir);
-}
-
-describe('AnalystAgent', () => {
-  let runDir: string;
-
-  beforeEach(() => {
-    runDir = mkdtempSync(join(tmpdir(), 'analyst-test-'));
-    vi.resetAllMocks();
-  });
-
-  it('identifies correct modules from 2 changed files', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)  // preFlight
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)               // detectDefaultBranch: git rev-parse --verify main
-      .mockImplementationOnce(makeExecFileCallback('src/pages/triage/TriagePage.tsx\nsrc/pages/clients/ClientList.tsx\n') as never); // git diff
-
-    const agent = createAgent(runDir);
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed');
-    expect(result.findings).toHaveLength(0);
-
-    const testPlan = JSON.parse(readFileSync(join(runDir, 'test-plan.json'), 'utf-8'));
-    const triageModule = testPlan.modules.find((m: { id: string }) => m.id === 'triage');
-    const clientsModule = testPlan.modules.find((m: { id: string }) => m.id === 'clients');
-    const dashboardModule = testPlan.modules.find((m: { id: string }) => m.id === 'dashboard');
-
-    expect(triageModule.risk).toBe('high');
-    expect(triageModule.changedFiles).toContain('src/pages/triage/TriagePage.tsx');
-
-    expect(clientsModule.risk).toBe('high');
-    expect(clientsModule.changedFiles).toContain('src/pages/clients/ClientList.tsx');
-
-    expect(dashboardModule.risk).toBe('low');
-    expect(dashboardModule.changedFiles).toHaveLength(0);
-  });
-
-  it('marks all modules critical when AuthContext is changed', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)
-      .mockImplementationOnce(makeExecFileCallback('src/context/AuthContext.tsx\n') as never);
-
-    const agent = createAgent(runDir);
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed');
-
-    const testPlan = JSON.parse(readFileSync(join(runDir, 'test-plan.json'), 'utf-8'));
-    for (const module of testPlan.modules) {
-      expect(module.risk).toBe('critical');
-    }
-  });
-
-  it('marks all modules critical when App.tsx is changed', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)
-      .mockImplementationOnce(makeExecFileCallback('src/App.tsx\n') as never);
-
-    const agent = createAgent(runDir);
-    await agent.run();
-
-    const testPlan = JSON.parse(readFileSync(join(runDir, 'test-plan.json'), 'utf-8'));
-    for (const module of testPlan.modules) {
-      expect(module.risk).toBe('critical');
-    }
-  });
-
-  it('marks all modules critical when router file is changed', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)
-      .mockImplementationOnce(makeExecFileCallback('src/router/index.ts\n') as never);
-
-    const agent = createAgent(runDir);
-    await agent.run();
-
-    const testPlan = JSON.parse(readFileSync(join(runDir, 'test-plan.json'), 'utf-8'));
-    for (const module of testPlan.modules) {
-      expect(module.risk).toBe('critical');
-    }
-  });
-
-  it('produces infra-issue finding when git fails', async () => {
-    const gitError = new Error('git: command not found');
-    const failImpl = makeExecFileCallback('', 'git: command not found', gitError);
-    mockedExecFile.mockImplementationOnce(failImpl as never);
-
-    const agent = createAgent(runDir);
-    const result = await agent.run();
-
-    expect(result.status).toBe('failed');
-    expect(result.findings).toHaveLength(1);
-    expect(result.findings[0].type).toBe('infra-issue');
-    expect(result.findings[0].severity).toBe('critical');
-  });
-
-  it('assigns low risk to modules with no changed files and no shared dependency changes', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)
-      .mockImplementationOnce(makeExecFileCallback('src/utils/formatDate.ts\n') as never);
-
-    const agent = createAgent(runDir);
-    await agent.run();
-
-    const testPlan = JSON.parse(readFileSync(join(runDir, 'test-plan.json'), 'utf-8'));
-    for (const module of testPlan.modules) {
-      expect(module.risk).toBe('low');
-    }
-  });
-
-  it('writes test-plan.json to the run directory', async () => {
-    mockedExecFile
-      .mockImplementationOnce(makeExecFileCallback('git version 2.40.0') as never)
-      .mockImplementationOnce(makeExecFileCallback('main\n') as never)
-      .mockImplementationOnce(makeExecFileCallback('') as never);
-
-    const agent = createAgent(runDir);
-    await agent.run();
-
-    const testPlanPath = join(runDir, 'test-plan.json');
-    const testPlan = JSON.parse(readFileSync(testPlanPath, 'utf-8'));
-    expect(testPlan).toHaveProperty('modules');
-    expect(Array.isArray(testPlan.modules)).toBe(true);
-  });
-});

package/agents/__tests__/02-seed-architect.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-
-vi.mock('node:fs', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:fs')>();
-  return {
-    ...actual,
-    existsSync: vi.fn(),
-  };
-});
-
-vi.mock('../../helpers/seed-validator', () => ({
-  validateSeedCompleteness: vi.fn(),
-}));
-
-import { existsSync } from 'node:fs';
-import { validateSeedCompleteness } from '../../helpers/seed-validator';
-import { SeedArchitectAgent } from '../02-seed-architect';
-
-const mockedExistsSync = vi.mocked(existsSync);
-const mockedValidateSeedCompleteness = vi.mocked(validateSeedCompleteness);
-
-const stubConfig: ValidatedConfig = {
-  schemaVersion: 1,
-  name: 'test',
-  auth: { loginUrl: 'http://localhost' },
-  modules: [
-    { id: 'triage', route: '/triage', sidebarIcon: true },
-    { id: 'clients', route: '/clients', sidebarIcon: true },
-    { id: 'dashboard', route: '/dashboard', sidebarIcon: false },
-    { id: 'reports', route: '/reports', sidebarIcon: true },
-  ],
-  environments: {},
-  portals: [],
-  breakpoints: [],
-  integrations: [],
-  workers: [],
-  workflows: [],
-  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
-  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
-  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
-  agentClassification: { blocking: [], advisory: [] },
-  thresholds: {
-    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
-    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
-    apiResponseTime: 2000,
-    bundleSizeLimit: 500000,
-    maxConsoleErrors: 0,
-  },
-  disabledAgents: [],
-  disabledAgentSet: new Set<number>(),
-};
-
-function createAgent(): SeedArchitectAgent {
-  return new SeedArchitectAgent(stubConfig, 'alpha', '/tmp/test-run');
-}
-
-describe('SeedArchitectAgent', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it('has agentId 2 and agentName Seed Architect', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(2);
-    expect(agent.agentName).toBe('Seed Architect');
-  });
-
-  it('returns 3 medium findings when seed validator reports 3 missing modules', async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedValidateSeedCompleteness.mockResolvedValue({
-      covered: ['triage'],
-      missing: ['clients', 'dashboard', 'reports'],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed'); // medium severity does not fail
-    expect(result.findings).toHaveLength(3);
-
-    for (const finding of result.findings) {
-      expect(finding.type).toBe('code-bug-logic');
-      expect(finding.severity).toBe('medium');
-      expect(finding.agentId).toBe(2);
-    }
-
-    const missingModules = result.findings.map(f => f.module);
-    expect(missingModules).toContain('clients');
-    expect(missingModules).toContain('dashboard');
-    expect(missingModules).toContain('reports');
-  });
-
-  it('returns no findings when all modules have seed coverage', async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedValidateSeedCompleteness.mockResolvedValue({
-      covered: ['triage', 'clients', 'dashboard', 'reports'],
-      missing: [],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed');
-    expect(result.findings).toHaveLength(0);
-  });
-
-  it('returns warning finding when seed file does not exist', async () => {
-    mockedExistsSync.mockReturnValue(false);
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed'); // medium severity does not fail
-    expect(result.findings).toHaveLength(1);
-    expect(result.findings[0].type).toBe('infra-issue');
-    expect(result.findings[0].severity).toBe('medium');
-    expect(result.findings[0].description).toContain('Seed file not found');
-  });
-
-  it('passes module IDs from config to seed validator', async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedValidateSeedCompleteness.mockResolvedValue({
-      covered: ['triage', 'clients', 'dashboard', 'reports'],
-      missing: [],
-    });
-
-    const agent = createAgent();
-    await agent.run();
-
-    expect(mockedValidateSeedCompleteness).toHaveBeenCalledOnce();
-    const [, moduleIds] = mockedValidateSeedCompleteness.mock.calls[0];
-    expect(moduleIds).toContain('triage');
-    expect(moduleIds).toContain('clients');
-    expect(moduleIds).toContain('dashboard');
-    expect(moduleIds).toContain('reports');
-  });
-
-  it('includes suggestedFix in each finding for missing modules', async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedValidateSeedCompleteness.mockResolvedValue({
-      covered: [],
-      missing: ['triage'],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.findings[0].suggestedFix).toBeTruthy();
-    expect(result.findings[0].suggestedFix).toContain('triage');
-  });
-});