@avi770/testteam 1.2.0

package/agents/22-email-notification-verifier.ts

@@ -0,0 +1,244 @@
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { ApiClient } from '../helpers/api-client';
+
+const MAILHOG_API_URL = 'http://localhost:8025/api/v2/messages?limit=10';
+const MAILHOG_HEALTH_URL = 'http://localhost:8025';
+
+interface MailhogMessage {
+  ID: string;
+  Content: {
+    Headers: Record<string, string[]>;
+    Body: string;
+  };
+  Created: string;
+}
+
+interface MailhogResponse {
+  items: MailhogMessage[];
+  total: number;
+  count: number;
+  start: number;
+}
+
+async function isMailhogReachable(): Promise<boolean> {
+  try {
+    const response = await fetch(MAILHOG_HEALTH_URL, {
+      method: 'HEAD',
+      signal: AbortSignal.timeout(5_000),
+    });
+    return response.ok || response.status < 500;
+  } catch {
+    return false;
+  }
+}
+
+async function fetchMailhogMessages(): Promise<MailhogMessage[]> {
+  const response = await fetch(MAILHOG_API_URL, {
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!response.ok) {
+    throw new Error(`Mailhog API returned ${response.status}`);
+  }
+  const data = (await response.json()) as MailhogResponse;
+  return data.items ?? [];
+}
+
+export class EmailNotificationVerifierAgent extends BaseAgent {
+  readonly agentId = 22;
+  readonly agentName = 'Email & Notification Verifier';
+
+  /** Set during preFlight so execute() knows whether Mailhog is available. */
+  private mailhogAvailable = false;
+
+  protected async preFlight(): Promise<void> {
+    this.mailhogAvailable = await isMailhogReachable();
+    // Advisory only — Mailhog is optional in non-local environments
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const env =
+      this.config.environments['beta'] ??
+      this.config.environments['alpha'] ??
+      Object.values(this.config.environments)[0];
+
+    if (!env) {
+      findings.push({
+        id: `${this.agentId}-no-env`,
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'email',
+        description: 'No environment configured — cannot run email/notification checks',
+      });
+      return findings;
+    }
+
+    // -----------------------------------------------------------------------
+    // Advisory finding when Mailhog is unavailable
+    // -----------------------------------------------------------------------
+    if (!this.mailhogAvailable) {
+      findings.push({
+        id: `${this.agentId}-mailhog-unavailable`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'email',
+        description:
+          'Advisory: Mailhog is not reachable at localhost:8025. ' +
+          'Email delivery verification will be skipped. ' +
+          'Start Mailhog locally to enable full email testing.',
+        suggestedFix: 'Run `docker run -p 1025:1025 -p 8025:8025 mailhog/mailhog` before the test suite.',
+      });
+      return findings;
+    }
+
+    // -----------------------------------------------------------------------
+    // Step 1: Trigger a password reset to generate an email
+    // -----------------------------------------------------------------------
+    const testEmail =
+      this.config.auth.credentials?.['admin']?.email ??
+      Object.values(this.config.auth.credentials ?? {})[0]?.email ??
+      'test@example.com';
+
+    const apiClient = new ApiClient(env.baseUrl);
+    let passwordResetTriggered = false;
+
+    try {
+      const response = await apiClient.post('/api/auth/forgot-password', { email: testEmail });
+      if (response.status === 200 || response.status === 202 || response.status === 204) {
+        passwordResetTriggered = true;
+      } else {
+        findings.push({
+          id: `${this.agentId}-password-reset-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'email',
+          description:
+            `Password reset endpoint POST /api/auth/forgot-password returned ${response.status}. ` +
+            `Expected 200/202/204.`,
+          suggestedFix: 'Verify the forgot-password endpoint is implemented and returns a 2xx status.',
+        });
+      }
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-password-reset-error`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'email',
+        description: `Password reset trigger failed: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+
+    if (!passwordResetTriggered) {
+      return findings;
+    }
+
+    // -----------------------------------------------------------------------
+    // Step 2: Poll Mailhog for the delivered email (up to 5 seconds)
+    // -----------------------------------------------------------------------
+    let messages: MailhogMessage[] = [];
+    const backoffDelays = [200, 400, 800, 1600, 3200];
+
+    for (const delay of backoffDelays) {
+      try {
+        messages = await fetchMailhogMessages();
+        if (messages.length > 0) break;
+      } catch {
+        // Retry on transient errors
+      }
+      await new Promise<void>((resolve) => setTimeout(resolve, delay));
+    }
+
+    if (messages.length === 0) {
+      findings.push({
+        id: `${this.agentId}-email-not-delivered`,
+        type: 'code-bug-logic',
+        severity: 'high',
+        agentId: this.agentId,
+        module: 'email',
+        description:
+          `Email delivery failure: no messages received in Mailhog within 5 seconds of ` +
+          `triggering password reset for "${testEmail}".`,
+        suggestedFix:
+          'Verify the mailer service is configured correctly and Mailhog SMTP port (1025) is reachable.',
+      });
+      return findings;
+    }
+
+    // -----------------------------------------------------------------------
+    // Step 3: Inspect email bodies for raw template variables like {{variable}}
+    // -----------------------------------------------------------------------
+    const templateVarPattern = /\{\{[^}]+\}\}/g;
+
+    for (const message of messages) {
+      const body = message.Content.Body;
+      const rawVars = body.match(templateVarPattern);
+
+      if (rawVars && rawVars.length > 0) {
+        findings.push({
+          id: `${this.agentId}-template-vars-${message.ID.slice(0, 8)}`,
+          type: 'code-bug-logic',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'email',
+          description:
+            `Email template variable(s) not substituted: found ${rawVars.join(', ')} in email body (message ID: ${message.ID}).`,
+          suggestedFix:
+            'Check the email template renderer and ensure all variables are provided at send time.',
+        });
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Step 4: Check that all links in the email body resolve (HTTP HEAD → 200)
+    // -----------------------------------------------------------------------
+    const urlPattern = /https?:\/\/[^\s"'<>)]+/g;
+
+    for (const message of messages) {
+      const body = message.Content.Body;
+      const urls = body.match(urlPattern) ?? [];
+      const uniqueUrls = [...new Set(urls)];
+
+      for (const url of uniqueUrls) {
+        try {
+          const response = await fetch(url, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(10_000),
+            redirect: 'follow',
+          });
+
+          if (response.status >= 400) {
+            findings.push({
+              id: `${this.agentId}-broken-link-${url.slice(0, 40).replace(/[^a-zA-Z0-9]/g, '-')}`,
+              type: 'code-bug-logic',
+              severity: 'medium',
+              agentId: this.agentId,
+              module: 'email',
+              description:
+                `Broken link in email body: HEAD ${url} returned ${response.status}.`,
+              suggestedFix: `Update the email template to use a valid URL for: ${url}`,
+            });
+          }
+        } catch (error) {
+          findings.push({
+            id: `${this.agentId}-link-error-${url.slice(0, 40).replace(/[^a-zA-Z0-9]/g, '-')}`,
+            type: 'infra-issue',
+            severity: 'low',
+            agentId: this.agentId,
+            module: 'email',
+            description:
+              `Could not verify link in email body: ${url}. ` +
+              `Error: ${error instanceof Error ? error.message : String(error)}`,
+          });
+        }
+      }
+    }
+
+    return findings;
+  }
+}

package/agents/23-migration-tester.ts

@@ -0,0 +1,80 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { BaseAgent } from './base-agent';
+import type { Finding } from '../core/types';
+
+const execFileAsync = promisify(execFile);
+
+export class MigrationTesterAgent extends BaseAgent {
+  readonly agentId = 23;
+  readonly agentName = 'Migration Tester';
+
+  private get projectRoot(): string {
+    return this.config.projectRoot ?? process.cwd();
+  }
+
+  protected async preFlight(): Promise<void> {
+    await execFileAsync('npx', ['prisma', '--version'], { shell: true, cwd: this.projectRoot });
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const cwd = this.projectRoot;
+
+    try {
+      await execFileAsync('npx', ['prisma', 'migrate', 'status'], { shell: true, cwd });
+    } catch (error) {
+      const stderr = error instanceof Error && 'stderr' in error
+        ? String((error as NodeJS.ErrnoException & { stderr?: string }).stderr)
+        : String(error);
+      // In alpha phase, DB connectivity issues are medium (dev env may lack DB)
+      // In beta/uat, they're critical (DB must be available)
+      const severity = this.phase === 'alpha' ? 'medium' as const : 'critical' as const;
+      findings.push({
+        id: `${this.agentId}-migrate-status`,
+        type: 'infra-issue',
+        severity,
+        agentId: this.agentId,
+        module: 'database',
+        description: `prisma migrate status failed: ${stderr}`,
+      });
+      return findings;
+    }
+
+    try {
+      await execFileAsync('npx', ['prisma', 'migrate', 'deploy'], { shell: true, cwd });
+    } catch (error) {
+      const stderr = error instanceof Error && 'stderr' in error
+        ? String((error as NodeJS.ErrnoException & { stderr?: string }).stderr)
+        : String(error);
+      findings.push({
+        id: `${this.agentId}-migrate-deploy`,
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'database',
+        description: `prisma migrate deploy failed: ${stderr}`,
+      });
+      return findings;
+    }
+
+    try {
+      await execFileAsync('npx', ['prisma', 'db', 'seed'], { shell: true, cwd });
+    } catch (error) {
+      const stderr = error instanceof Error && 'stderr' in error
+        ? String((error as NodeJS.ErrnoException & { stderr?: string }).stderr)
+        : String(error);
+      findings.push({
+        id: `${this.agentId}-db-seed`,
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'database',
+        description: `prisma db seed failed: ${stderr}`,
+      });
+      return findings;
+    }
+
+    return findings;
+  }
+}

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

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

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