@avi770/testteam 3.0.0 → 3.2.0

package/agents/__tests__/44-backup-recovery-tester.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-import type { Phase } from '../../core/types';
-
-// ---------------------------------------------------------------------------
-// Stub config helpers
-// ---------------------------------------------------------------------------
-
-function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
-  return {
-    schemaVersion: 1,
-    name: 'test',
-    auth: { loginUrl: 'http://localhost/login', credentials: {} },
-    modules: [],
-    environments: {
-      alpha: { baseUrl: 'http://localhost:3000', seed: false },
-    },
-    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: [44] },
-    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>(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock fs and child_process
-// ---------------------------------------------------------------------------
-
-const mockStat = vi.fn();
-vi.mock('node:fs/promises', () => ({
-  stat: (...args: unknown[]) => mockStat(...args),
-}));
-
-const execFileMock = vi.fn();
-vi.mock('node:util', async (importOriginal) => {
-  const orig = await importOriginal() as Record<string, unknown>;
-  return {
-    ...orig,
-    promisify: () => execFileMock,
-  };
-});
-
-vi.mock('node:child_process', () => ({
-  execFile: vi.fn(),
-}));
-
-// ---------------------------------------------------------------------------
-// Dynamic import AFTER mocks
-// ---------------------------------------------------------------------------
-
-const { BackupRecoveryTesterAgent } = await import('../44-backup-recovery-tester');
-
-function createAgent(
-  config: ValidatedConfig = makeConfig(),
-  phase: Phase = 'beta',
-): InstanceType<typeof BackupRecoveryTesterAgent> {
-  return new BackupRecoveryTesterAgent(config, phase, '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('BackupRecoveryTesterAgent', () => {
-  beforeEach(() => {
-    mockStat.mockReset();
-    execFileMock.mockReset();
-  });
-
-  it('has agentId 44 and correct agentName', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(44);
-    expect(agent.agentName).toBe('Backup Recovery Tester');
-  });
-
-  it('produces low finding when no prisma schema exists', async () => {
-    mockStat.mockRejectedValue(new Error('ENOENT'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noSchema = result.findings.find(f => f.id.includes('no-prisma-schema'));
-    expect(noSchema).toBeDefined();
-    expect(noSchema!.severity).toBe('low');
-  });
-
-  it('detects schema pull errors', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: '', stderr: 'Error: could not connect' })
-      .mockResolvedValueOnce({ stdout: 'all good', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const pullError = result.findings.find(f => f.id.includes('schema-pull-error'));
-    expect(pullError).toBeDefined();
-    expect(pullError!.severity).toBe('medium');
-  });
-
-  it('detects pending migrations', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'schema output', stderr: '' })
-      .mockResolvedValueOnce({ stdout: 'Migration pending and not yet applied', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const pending = result.findings.find(f => f.id.includes('pending-migrations'));
-    expect(pending).toBeDefined();
-    expect(pending!.severity).toBe('high');
-  });
-
-  it('detects schema drift', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'schema output', stderr: '' })
-      .mockResolvedValueOnce({ stdout: 'database drift detected', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const drift = result.findings.find(f => f.id.includes('schema-drift'));
-    expect(drift).toBeDefined();
-    expect(drift!.severity).toBe('high');
-  });
-
-  it('passes when no issues found', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'schema output', stderr: '' })
-      .mockResolvedValueOnce({ stdout: 'Database schema is in sync', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const findings = result.findings.filter(f =>
-      f.id.includes('pending') || f.id.includes('drift') || f.id.includes('pull-error'),
-    );
-    expect(findings.length).toBe(0);
-  });
-
-  it('handles schema pull failure gracefully', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockRejectedValueOnce(new Error('npx not found'))
-      .mockResolvedValueOnce({ stdout: '', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const pullFailed = result.findings.find(f => f.id.includes('schema-pull-failed'));
-    expect(pullFailed).toBeDefined();
-    expect(pullFailed!.severity).toBe('medium');
-  });
-
-  it('handles migration status failure gracefully without crashing', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'ok', stderr: '' })
-      .mockRejectedValueOnce(new Error('prisma not found'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    // The inner catch consumes the error and sets stdout/stderr to empty strings
-    // so the agent doesn't crash — it gracefully handles the failure
-    expect(result.status).toBeDefined();
-    expect(result.status).not.toBe('failed');
-  });
-
-  it('records evidence for schema pull', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'model User { id Int }', stderr: '' })
-      .mockResolvedValueOnce({ stdout: 'all synced', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.evidence.some(e => e.description.includes('prisma db pull'))).toBe(true);
-  });
-
-  it('uses projectRoot from config', async () => {
-    const config = makeConfig({ projectRoot: '/custom/root' });
-    mockStat.mockRejectedValue(new Error('ENOENT'));
-
-    const agent = createAgent(config);
-    await agent.run();
-
-    expect(mockStat).toHaveBeenCalledWith(expect.stringContaining('custom'));
-  });
-
-  it('handles migrate status non-zero exit with stdout', async () => {
-    mockStat.mockResolvedValue({ isFile: () => true });
-    execFileMock
-      .mockResolvedValueOnce({ stdout: 'ok', stderr: '' })
-      .mockRejectedValueOnce({ stdout: 'pending migrations', stderr: '' });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    // Should handle the non-zero exit (which has stdout)
-    expect(result.status).toBeDefined();
-  });
-});

package/agents/__tests__/45-data-privacy-scanner.test.ts

@@ -1,223 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-import type { Phase } from '../../core/types';
-
-// ---------------------------------------------------------------------------
-// Stub config helpers
-// ---------------------------------------------------------------------------
-
-function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
-  return {
-    schemaVersion: 1,
-    name: 'test',
-    auth: {
-      loginUrl: 'http://localhost/login',
-      credentials: {
-        admin: { email: 'admin@test.com', password: 'secret' },
-      },
-    },
-    modules: [{ id: 'clients', route: '/clients', sidebarIcon: true }],
-    environments: {
-      alpha: { baseUrl: 'http://localhost:3000', seed: false },
-    },
-    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: [45] },
-    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>(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock fetch
-// ---------------------------------------------------------------------------
-
-const fetchMock = vi.fn();
-vi.stubGlobal('fetch', fetchMock);
-
-// ---------------------------------------------------------------------------
-// Mock ApiClient
-// ---------------------------------------------------------------------------
-
-const mockGet = vi.fn();
-
-vi.mock('../../helpers/api-client', () => ({
-  ApiClient: {
-    createAuthenticated: vi.fn().mockImplementation(async () => ({
-      get: mockGet,
-      post: vi.fn(),
-      put: vi.fn(),
-      delete: vi.fn(),
-    })),
-  },
-}));
-
-// ---------------------------------------------------------------------------
-// Dynamic import AFTER mocks
-// ---------------------------------------------------------------------------
-
-const { DataPrivacyScannerAgent } = await import('../45-data-privacy-scanner');
-
-function createAgent(
-  config: ValidatedConfig = makeConfig(),
-  phase: Phase = 'beta',
-): InstanceType<typeof DataPrivacyScannerAgent> {
-  return new DataPrivacyScannerAgent(config, phase, '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('DataPrivacyScannerAgent', () => {
-  beforeEach(() => {
-    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
-    mockGet.mockReset();
-  });
-
-  it('has agentId 45 and correct agentName', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(45);
-    expect(agent.agentName).toBe('Data Privacy Scanner');
-  });
-
-  it('throws when modules array is empty', async () => {
-    const config = makeConfig({ modules: [] });
-    const agent = createAgent(config);
-    const result = await agent.run();
-    expect(result.status).toBe('failed');
-  });
-
-  it('detects unmasked email addresses', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ name: 'John', email: 'john@example.com' }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const emailFinding = result.findings.find(f => f.description.includes('Email'));
-    expect(emailFinding).toBeDefined();
-    expect(emailFinding!.severity).toBe('high');
-  });
-
-  it('detects unmasked SSN patterns', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ name: 'John', ssn: '123-45-6789' }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const ssnFinding = result.findings.find(f => f.description.includes('SSN'));
-    expect(ssnFinding).toBeDefined();
-    expect(ssnFinding!.severity).toBe('high');
-  });
-
-  it('detects unmasked credit card numbers', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ name: 'John', card: '4111-1111-1111-1111' }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const ccFinding = result.findings.find(f => f.description.includes('Credit Card'));
-    expect(ccFinding).toBeDefined();
-  });
-
-  it('detects unmasked phone numbers', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ name: 'John', phone: '(555) 123-4567' }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const phoneFinding = result.findings.find(f => f.description.includes('Phone'));
-    expect(phoneFinding).toBeDefined();
-  });
-
-  it('does not flag when no PII present', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ id: 1, status: 'active', count: 42 }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const piiFindings = result.findings.filter(f => f.id.includes('unmasked'));
-    expect(piiFindings.length).toBe(0);
-  });
-
-  it('handles non-200 responses', async () => {
-    mockGet.mockResolvedValue({ status: 404, body: {} });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const piiFindings = result.findings.filter(f => f.id.includes('unmasked'));
-    expect(piiFindings.length).toBe(0);
-  });
-
-  it('handles request errors gracefully', async () => {
-    mockGet.mockRejectedValue(new Error('Connection refused'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const scanError = result.findings.find(f => f.id.includes('scan-error'));
-    expect(scanError).toBeDefined();
-  });
-
-  it('handles auth failure gracefully', async () => {
-    const { ApiClient } = await import('../../helpers/api-client');
-    (ApiClient.createAuthenticated as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
-      new Error('Auth failed'),
-    );
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const authFailed = result.findings.find(f => f.id.includes('auth-failed'));
-    expect(authFailed).toBeDefined();
-  });
-
-  it('records evidence with scan summary', async () => {
-    mockGet.mockResolvedValue({
-      status: 200,
-      body: [{ id: 1, name: 'Test' }],
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.evidence.some(e => e.description.includes('PII scan'))).toBe(true);
-  });
-
-  it('resolves environment in preFlight', async () => {
-    mockGet.mockResolvedValue({ status: 200, body: [] });
-    const agent = createAgent();
-    const result = await agent.run();
-    expect(result.findings.every(f => !f.description.includes('preFlight'))).toBe(true);
-  });
-});

package/agents/__tests__/46-seo-auditor.test.ts

@@ -1,261 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-import type { Phase } from '../../core/types';
-
-// ---------------------------------------------------------------------------
-// Stub config helpers
-// ---------------------------------------------------------------------------
-
-function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
-  return {
-    schemaVersion: 1,
-    name: 'test',
-    auth: {
-      loginUrl: 'http://localhost/login',
-      credentials: {
-        admin: { email: 'admin@test.com', password: 'secret' },
-      },
-    },
-    modules: [{ id: 'home', route: '/', sidebarIcon: true }],
-    environments: {
-      alpha: { baseUrl: 'http://localhost:3000', seed: false },
-    },
-    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: [46] },
-    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>(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock fetch
-// ---------------------------------------------------------------------------
-
-const fetchMock = vi.fn();
-vi.stubGlobal('fetch', fetchMock);
-
-// ---------------------------------------------------------------------------
-// Mock helpers
-// ---------------------------------------------------------------------------
-
-const loginMock = vi.fn().mockResolvedValue(undefined);
-
-vi.mock('../../helpers/navigation', () => ({
-  login: (...args: unknown[]) => loginMock(...args),
-  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
-  navigateToSection: vi.fn().mockResolvedValue(undefined),
-  switchPortal: vi.fn().mockResolvedValue(undefined),
-}));
-
-// ---------------------------------------------------------------------------
-// Mock Playwright
-// ---------------------------------------------------------------------------
-
-interface MockLocator {
-  count: ReturnType<typeof vi.fn>;
-}
-
-function makeMockLocator(countVal = 0): MockLocator {
-  return { count: vi.fn().mockResolvedValue(countVal) };
-}
-
-interface MockPage {
-  close: ReturnType<typeof vi.fn>;
-  goto: ReturnType<typeof vi.fn>;
-  evaluate: ReturnType<typeof vi.fn>;
-  locator: ReturnType<typeof vi.fn>;
-}
-
-function makeMockPage(): MockPage {
-  return {
-    close: vi.fn().mockResolvedValue(undefined),
-    goto: vi.fn().mockResolvedValue(undefined),
-    evaluate: vi.fn().mockResolvedValue(null),
-    locator: vi.fn().mockReturnValue(makeMockLocator(1)),
-  };
-}
-
-let currentMockPage: MockPage;
-let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
-
-vi.mock('playwright', async () => ({
-  chromium: {
-    launch: vi.fn().mockImplementation(async () => mockBrowser),
-  },
-}));
-
-// ---------------------------------------------------------------------------
-// Dynamic import AFTER mocks
-// ---------------------------------------------------------------------------
-
-const { SeoAuditorAgent } = await import('../46-seo-auditor');
-
-function createAgent(
-  config: ValidatedConfig = makeConfig(),
-  phase: Phase = 'beta',
-): InstanceType<typeof SeoAuditorAgent> {
-  return new SeoAuditorAgent(config, phase, '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('SeoAuditorAgent', () => {
-  beforeEach(() => {
-    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
-    loginMock.mockReset().mockResolvedValue(undefined);
-
-    currentMockPage = makeMockPage();
-    mockBrowser = {
-      newPage: vi.fn().mockResolvedValue(currentMockPage),
-      close: vi.fn().mockResolvedValue(undefined),
-    };
-  });
-
-  it('has agentId 46 and correct agentName', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(46);
-    expect(agent.agentName).toBe('SEO Auditor');
-  });
-
-  it('throws when modules array is empty', async () => {
-    const config = makeConfig({ modules: [] });
-    const agent = createAgent(config);
-    const result = await agent.run();
-    expect(result.status).toBe('failed');
-  });
-
-  it('detects missing title', async () => {
-    currentMockPage.evaluate.mockImplementation((fn: unknown) => {
-      const fnStr = String(fn);
-      if (fnStr.includes('document.title')) return Promise.resolve('');
-      return Promise.resolve(null);
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noTitle = result.findings.find(f => f.id.includes('no-title'));
-    expect(noTitle).toBeDefined();
-  });
-
-  it('detects missing meta description', async () => {
-    currentMockPage.evaluate.mockImplementation((fn: unknown) => {
-      const fnStr = String(fn);
-      if (fnStr.includes('document.title')) return Promise.resolve('My Page');
-      if (fnStr.includes('meta[name="description"]')) return Promise.resolve(null);
-      return Promise.resolve(null);
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noMeta = result.findings.find(f => f.id.includes('no-meta-desc'));
-    expect(noMeta).toBeDefined();
-  });
-
-  it('detects missing h1', async () => {
-    currentMockPage.evaluate.mockResolvedValue('Page Title');
-    currentMockPage.locator.mockReturnValue(makeMockLocator(0));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noH1 = result.findings.find(f => f.id.includes('no-h1'));
-    expect(noH1).toBeDefined();
-  });
-
-  it('detects multiple h1 tags', async () => {
-    currentMockPage.evaluate.mockResolvedValue('Page Title');
-    currentMockPage.locator.mockReturnValue(makeMockLocator(3));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const multiH1 = result.findings.find(f => f.id.includes('multiple-h1'));
-    expect(multiH1).toBeDefined();
-  });
-
-  it('checks robots.txt', async () => {
-    fetchMock.mockImplementation((url: string) => {
-      if (typeof url === 'string' && url.includes('robots.txt')) {
-        return Promise.resolve({ ok: false, status: 404 });
-      }
-      return Promise.resolve({ ok: true, status: 200 });
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noRobots = result.findings.find(f => f.id.includes('no-robots-txt'));
-    expect(noRobots).toBeDefined();
-  });
-
-  it('checks sitemap.xml', async () => {
-    fetchMock.mockImplementation((url: string) => {
-      if (typeof url === 'string' && url.includes('sitemap.xml')) {
-        return Promise.resolve({ ok: false, status: 404 });
-      }
-      return Promise.resolve({ ok: true, status: 200 });
-    });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const noSitemap = result.findings.find(f => f.id.includes('no-sitemap-xml'));
-    expect(noSitemap).toBeDefined();
-  });
-
-  it('produces medium finding when login fails', async () => {
-    loginMock.mockRejectedValue(new Error('Auth failed'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
-    expect(loginFinding).toBeDefined();
-  });
-
-  it('produces medium finding when Playwright crashes', async () => {
-    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
-    expect(pwFinding).toBeDefined();
-  });
-
-  it('closes browser even when an error occurs', async () => {
-    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
-    const agent = createAgent();
-    await agent.run();
-    expect(mockBrowser.close).toHaveBeenCalled();
-  });
-
-  it('produces medium finding when navigation fails', async () => {
-    currentMockPage.goto.mockRejectedValue(new Error('Navigation failed'));
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    const navFinding = result.findings.find(f => f.id.includes('nav-failed'));
-    expect(navFinding).toBeDefined();
-  });
-});