@avi770/testteam 1.2.0 → 2.0.0

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

@@ -0,0 +1,222 @@
+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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,261 @@
+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();
+  });
+});