@avi770/testteam 1.2.0

package/agents/05-browser-crawler.ts

@@ -0,0 +1,790 @@
+import { execFile } from 'child_process';
+import path from 'path';
+import type { Browser, Page } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { login, navigateToSection, waitForSectionLoad, switchPortal } from '../helpers/navigation';
+import { captureScreenshot } from '../helpers/screenshot';
+import { discoverInteractiveElements } from '../helpers/element-discovery';
+import { fillForm } from '../helpers/form-filler';
+import { openModal, closeModal } from '../helpers/modal-handler';
+import { ApiClient } from '../helpers/api-client';
+import { resolveEnvironment, isUrlReachable } from '../helpers/env-resolver';
+
+function execFileAsync(file: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, { shell: true }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout: stdout ?? '', stderr: stderr ?? '' });
+    });
+  });
+}
+
+export class BrowserCrawlerAgent extends BaseAgent {
+  readonly agentId = 5;
+  readonly agentName = 'Browser Crawler';
+
+  protected async preFlight(): Promise<void> {
+    // Verify playwright is available
+    await execFileAsync('npx', ['playwright', '--version']);
+
+    // Verify base URL is reachable (with fallback)
+    const { env } = await resolveEnvironment(this.config, this.phase);
+
+    const reachable = await isUrlReachable(env.baseUrl);
+    if (!reachable) {
+      throw new Error(`Base URL is not reachable: ${env.baseUrl}`);
+    }
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    if (this.phase === 'alpha') {
+      return this.executeSmoke();
+    }
+    if (this.phase === 'beta') {
+      return this.executeBeta();
+    }
+    if (this.phase === 'uat') {
+      return this.executeUat();
+    }
+    if (this.phase === 'release') {
+      return this.executeRelease();
+    }
+    throw new Error(`Phase "${this.phase}" is not implemented in BrowserCrawlerAgent yet`);
+  }
+
+  private async executeSmoke(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const env = this.config.environments['alpha'] ?? Object.values(this.config.environments)[0];
+    if (!env) {
+      findings.push({
+        id: '5-no-env',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No environment configured — cannot determine base URL',
+      });
+      return findings;
+    }
+
+    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
+    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${env.baseUrl}${rawLoginUrl}`;
+    const credentials = this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    if (!credentials) {
+      findings.push({
+        id: '5-no-credentials',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No credentials configured in auth.credentials — cannot log in',
+      });
+      return findings;
+    }
+
+    // Dynamic import keeps playwright optional at module load time
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+    let page: Page | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      page = await browser.newPage();
+
+      try {
+        await login(page, credentials, loginUrl);
+      } catch (loginError) {
+        // In alpha, login failure is expected (API may not be running)
+        const loginSeverity = this.phase === 'alpha' ? 'medium' as const : 'critical' as const;
+        findings.push({
+          id: '5-login-failed',
+          type: 'infra-issue',
+          severity: loginSeverity,
+          agentId: this.agentId,
+          module: 'auth',
+          description: `Login failed (will crawl anonymously): ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+        });
+        // Navigate to baseUrl so anonymous crawling can proceed
+        await page.goto(env.baseUrl, { waitUntil: 'networkidle', timeout: 10000 }).catch(() => {});
+      }
+
+      for (const module of this.config.modules) {
+        const consoleErrors: string[] = [];
+        const networkFailures: string[] = [];
+
+        page.on('console', (msg) => {
+          if (msg.type() === 'error') {
+            consoleErrors.push(msg.text());
+          }
+        });
+
+        page.on('response', (response) => {
+          const status = response.status();
+          if (status >= 400) {
+            networkFailures.push(`${status} ${response.url()}`);
+          }
+        });
+
+        try {
+          await navigateToSection(page, module.id, this.config);
+          await waitForSectionLoad(page);
+        } catch (navErr) {
+          findings.push({
+            id: `5-nav-${module.id}`,
+            type: 'infra-issue',
+            severity: 'high',
+            agentId: this.agentId,
+            module: module.id,
+            description: `Navigation to module "${module.id}" failed: ${navErr instanceof Error ? navErr.message : String(navErr)}`,
+          });
+          continue;
+        }
+
+        const screenshotPath = await captureScreenshot(
+          page,
+          `smoke-${module.id}`,
+          this.runDir,
+        );
+
+        this.addEvidence({
+          type: 'screenshot',
+          path: screenshotPath,
+          description: `Smoke screenshot for module "${module.id}"`,
+        });
+
+        for (const errorMsg of consoleErrors) {
+          findings.push({
+            id: `5-console-${module.id}-${errorMsg.slice(0, 40).replace(/\s+/g, '-')}`,
+            type: 'code-bug-logic',
+            severity: 'high',
+            agentId: this.agentId,
+            module: module.id,
+            description: `Console error in module "${module.id}": ${errorMsg}`,
+            screenshot: screenshotPath,
+            consoleError: errorMsg,
+          });
+        }
+
+        for (const failure of networkFailures) {
+          findings.push({
+            id: `5-network-${module.id}-${failure.slice(0, 40).replace(/\s+/g, '-')}`,
+            type: 'infra-issue',
+            severity: 'high',
+            agentId: this.agentId,
+            module: module.id,
+            description: `Network failure in module "${module.id}": ${failure}`,
+            screenshot: screenshotPath,
+          });
+        }
+      }
+    } finally {
+      if (page) await page.close().catch(() => undefined);
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Release mode — lightweight post-deployment smoke test (no browser needed)
+  // ---------------------------------------------------------------------------
+
+  private async executeRelease(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const env =
+      this.config.environments['release'] ??
+      this.config.environments['uat'] ??
+      this.config.environments['beta'] ??
+      this.config.environments['alpha'] ??
+      Object.values(this.config.environments)[0];
+
+    if (!env) {
+      findings.push({
+        id: '5-release-no-env',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No environment configured — cannot determine base URL for release verification',
+      });
+      return findings;
+    }
+
+    // 1. Verify the production base URL is reachable and returns expected HTML
+    let baseHtml: string | null = null;
+    try {
+      const response = await fetch(env.baseUrl, { signal: AbortSignal.timeout(15_000) });
+      if (!response.ok) {
+        findings.push({
+          id: '5-release-base-status',
+          type: 'infra-issue',
+          severity: 'critical',
+          agentId: this.agentId,
+          module: 'browser-crawler',
+          description: `Production base URL returned HTTP ${response.status}: ${env.baseUrl}`,
+        });
+      } else {
+        baseHtml = await response.text();
+      }
+    } catch (err) {
+      findings.push({
+        id: '5-release-base-unreachable',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: `Production base URL is unreachable: ${env.baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
+      });
+      return findings;
+    }
+
+    // 2. Validate HTML markers (title tag or meta charset) if we got a body
+    if (baseHtml !== null) {
+      const hasTitle = /<title[^>]*>.+<\/title>/i.test(baseHtml);
+      const hasMetaCharset = /<meta[^>]*charset/i.test(baseHtml);
+      const hasHtmlTag = /<html/i.test(baseHtml);
+
+      if (!hasTitle && !hasMetaCharset && !hasHtmlTag) {
+        findings.push({
+          id: '5-release-base-html-markers',
+          type: 'infra-issue',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'browser-crawler',
+          description: `Production base URL HTML is missing expected markers (no <title>, <meta charset>, or <html> tag): ${env.baseUrl}`,
+        });
+      }
+    }
+
+    // 3. Check each module route returns a non-error status code
+    for (const module of this.config.modules) {
+      const routeUrl = module.route.startsWith('http')
+        ? module.route
+        : `${env.baseUrl}${module.route}`;
+
+      try {
+        const routeResponse = await fetch(routeUrl, {
+          method: 'GET',
+          redirect: 'follow',
+          signal: AbortSignal.timeout(10_000),
+        });
+
+        if (routeResponse.status >= 400) {
+          findings.push({
+            id: `5-release-route-${module.id}`,
+            type: 'infra-issue',
+            severity: routeResponse.status >= 500 ? 'critical' : 'high',
+            agentId: this.agentId,
+            module: module.id,
+            description: `[Release] Route "${module.route}" returned HTTP ${routeResponse.status}: ${routeUrl}`,
+          });
+        }
+      } catch (routeErr) {
+        findings.push({
+          id: `5-release-route-${module.id}`,
+          type: 'infra-issue',
+          severity: 'critical',
+          agentId: this.agentId,
+          module: module.id,
+          description: `[Release] Route "${module.route}" is unreachable: ${routeUrl} — ${routeErr instanceof Error ? routeErr.message : String(routeErr)}`,
+        });
+      }
+    }
+
+    return findings;
+  }
+
+  private async executeBeta(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const { env, fallback } = await resolveEnvironment(this.config, 'beta');
+
+    if (!env) {
+      findings.push({
+        id: '5-beta-no-env',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No environment configured — cannot determine base URL for beta mode',
+      });
+      return findings;
+    }
+
+    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
+    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${env.baseUrl}${rawLoginUrl}`;
+    const credentials = this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    if (!credentials) {
+      findings.push({
+        id: '5-beta-no-credentials',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No credentials configured in auth.credentials — cannot log in for beta mode',
+      });
+      return findings;
+    }
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+    let page: Page | null = null;
+    try {
+      browser = await chromium.launch({ headless: true });
+      page = await browser.newPage();
+
+      // Beta: single desktop breakpoint for performance — full breakpoint matrix is UAT-only
+      const breakpoints = [1280];
+
+      for (const breakpoint of breakpoints) {
+        await page.setViewportSize({ width: breakpoint, height: 800 });
+
+        // Bookkeeper portal pass
+        try {
+          await login(page, credentials, loginUrl);
+        } catch (loginError) {
+          const loginSeverity = fallback ? 'medium' as const : 'critical' as const;
+          findings.push({
+            id: '5-beta-login-failed',
+            type: 'infra-issue',
+            severity: loginSeverity,
+            agentId: this.agentId,
+            module: 'auth',
+            description: `Login failed (will crawl anonymously): ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+          });
+          // Navigate to baseUrl so anonymous crawling can proceed
+          await page.goto(env.baseUrl, { waitUntil: 'networkidle', timeout: 10000 }).catch(() => {});
+        }
+        // Beta: limit interaction pass to first 5 modules for performance
+        const originalModules = this.config.modules;
+        const betaModules = this.config.modules.slice(0, 5);
+        this.config.modules = betaModules;
+
+        const bookeeperFindings = await this.runInteractionPass(page, findings, `bp${breakpoint}`);
+        findings.push(...bookeeperFindings);
+
+        // Client portal pass — only if portals are configured with a queryParam
+        const clientPortals = this.config.portals.filter(p => p.queryParam !== null);
+        for (const portal of clientPortals) {
+          await switchPortal(page, portal.queryParam);
+          const portalFindings = await this.runInteractionPass(
+            page,
+            findings,
+            `portal-${portal.name}-bp${breakpoint}`,
+          );
+          findings.push(...portalFindings);
+        }
+
+        // Restore full module list
+        this.config.modules = originalModules;
+      }
+    } finally {
+      if (page) await page.close().catch(() => undefined);
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  // ---------------------------------------------------------------------------
+  // UAT mode — exhaustive testing with snapshot/restore for destructive actions
+  // ---------------------------------------------------------------------------
+
+  private async executeUat(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const { env, fallback } = await resolveEnvironment(this.config, 'uat');
+
+    if (!env) {
+      findings.push({
+        id: '5-uat-no-env',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No environment configured — cannot determine base URL for UAT mode',
+      });
+      return findings;
+    }
+
+    // UAT credentials take priority; fall back to admin
+    const credentials =
+      this.config.auth.credentials?.['uat'] ??
+      this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    if (!credentials) {
+      findings.push({
+        id: '5-uat-no-credentials',
+        type: 'infra-issue',
+        severity: 'critical',
+        agentId: this.agentId,
+        module: 'browser-crawler',
+        description: 'No UAT credentials configured in auth.credentials — cannot log in for UAT mode',
+      });
+      return findings;
+    }
+
+    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
+    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${env.baseUrl}${rawLoginUrl}`;
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+    let page: Page | null = null;
+
+    // UAT: single pass at default 1280 breakpoint — exhaustive, not multi-breakpoint
+    try {
+      browser = await chromium.launch({ headless: true });
+      page = await browser.newPage();
+      await page.setViewportSize({ width: 1280, height: 800 });
+
+      try {
+        await login(page, credentials, loginUrl);
+      } catch (loginError) {
+        const loginSeverity = fallback ? 'medium' as const : 'critical' as const;
+        findings.push({
+          id: '5-uat-login-failed',
+          type: 'infra-issue',
+          severity: loginSeverity,
+          agentId: this.agentId,
+          module: 'auth',
+          description: `Login failed (will crawl anonymously): ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+        });
+        // Navigate to baseUrl so anonymous crawling can proceed
+        await page.goto(env.baseUrl, { waitUntil: 'networkidle', timeout: 10000 }).catch(() => {});
+      }
+
+      // Record video evidence path (Playwright video recording is configured via context;
+      // we record an evidence item pointing to where the video will be saved)
+      const videoPath = path.join(this.runDir, 'uat-session.webm');
+      this.addEvidence({
+        type: 'video',
+        path: videoPath,
+        description: 'UAT session recording — full exhaustive browser crawl',
+      });
+
+      // Non-destructive pass (same as beta runInteractionPass)
+      const nonDestructiveFindings = await this.runInteractionPass(page, findings, 'uat');
+      findings.push(...nonDestructiveFindings);
+
+      // Edge-case pass: test each module with special-character and boundary inputs
+      const edgeCaseFindings = await this.runUatEdgeCases(page, env.baseUrl);
+      findings.push(...edgeCaseFindings);
+
+      // Destructive action pass with snapshot/restore
+      const apiClient = await ApiClient.createAuthenticated(env.baseUrl, credentials).catch(
+        () => null,
+      );
+      const destructiveFindings = await this.runUatDestructivePass(page, apiClient);
+      findings.push(...destructiveFindings);
+    } finally {
+      if (page) await page.close().catch(() => undefined);
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  /**
+   * UAT edge-case pass: visit each module and attempt inputs with empty strings,
+   * unicode characters, emoji, and max-length strings to probe boundary handling.
+   */
+  private async runUatEdgeCases(page: Page, baseUrl: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const edgeCaseInputs = [
+      '',                                          // empty field
+      '日本語テキスト',                             // unicode (Japanese)
+      '🎉🔥💡',                                    // emoji
+      'a'.repeat(1_000),                           // max-length (1 k chars — boundary test without DoS risk)
+    ];
+
+    for (const module of this.config.modules) {
+      const consoleErrors: string[] = [];
+      const consoleListener = (msg: { type(): string; text(): string }): void => {
+        if (msg.type() === 'error') consoleErrors.push(msg.text());
+      };
+      page.on('console', consoleListener);
+
+      try {
+        await navigateToSection(page, module.id, this.config);
+        await waitForSectionLoad(page);
+      } catch {
+        page.removeListener('console', consoleListener);
+        continue; // navigation failure already captured in non-destructive pass
+      }
+
+      for (const edgeValue of edgeCaseInputs) {
+        try {
+          await fillForm(page, 'form', { value: edgeValue });
+        } catch {
+          // form fill is best-effort
+        }
+      }
+
+      page.removeListener('console', consoleListener);
+
+      for (const errorMsg of consoleErrors) {
+        findings.push({
+          id: `5-uat-edge-${module.id}-${errorMsg.slice(0, 40).replace(/\s+/g, '-')}`,
+          type: 'code-bug-logic',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: module.id,
+          description: `[UAT edge-case] Console error in module "${module.id}": ${errorMsg}`,
+          consoleError: errorMsg,
+        });
+      }
+
+      const screenshotPath = await captureScreenshot(
+        page,
+        `uat-edge-${module.id}`,
+        this.runDir,
+      );
+      this.addEvidence({
+        type: 'screenshot',
+        path: screenshotPath,
+        description: `[UAT edge-case] Screenshot after boundary inputs for module "${module.id}"`,
+      });
+
+      void baseUrl; // used only to satisfy linter — env already applied via navigateToSection
+    }
+
+    return findings;
+  }
+
+  /**
+   * UAT destructive pass: for each destructive element discovered, snapshot the entity
+   * state via API, execute the action, verify outcome, then restore via API.
+   * If restore fails → log critical finding and stop further destructive tests.
+   */
+  private async runUatDestructivePass(
+    page: Page,
+    apiClient: ApiClient | null,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    let stopDestructive = false;
+
+    for (const module of this.config.modules) {
+      if (stopDestructive) break;
+
+      try {
+        await navigateToSection(page, module.id, this.config);
+        await waitForSectionLoad(page);
+      } catch {
+        continue;
+      }
+
+      const elements = await discoverInteractiveElements(page);
+      const destructiveElements = elements.filter(e => e.isDestructive);
+
+      for (const element of destructiveElements) {
+        if (stopDestructive) break;
+
+        // 1. Snapshot entity state via API before destructive action
+        let snapshot: unknown = null;
+        if (apiClient) {
+          try {
+            const snapshotRes = await apiClient.get(`/api/${module.id}`);
+            snapshot = snapshotRes.body;
+          } catch {
+            snapshot = null;
+          }
+        }
+
+        this.addEvidence({
+          type: 'snapshot',
+          path: path.join(this.runDir, `uat-snapshot-${module.id}-${element.selector.replace(/[^a-z0-9]/gi, '-')}.json`),
+          description: `[UAT destructive] Pre-action snapshot for "${element.text ?? element.selector}" in module "${module.id}"`,
+        });
+
+        // 2. Execute destructive action
+        let actionError: string | undefined;
+        try {
+          if (element.type === 'button' || element.type === 'link') {
+            const modalOpened = await openModal(page, element.selector);
+            if (modalOpened) {
+              // Close modal instead of confirming — safer in UAT
+              await closeModal(page, 'escape');
+            }
+          }
+        } catch (err) {
+          actionError = err instanceof Error ? err.message : String(err);
+        }
+
+        const screenshotPath = await captureScreenshot(
+          page,
+          `uat-destructive-${module.id}-${element.selector.slice(0, 30).replace(/[^a-z0-9]/gi, '-')}`,
+          this.runDir,
+        );
+        this.addEvidence({
+          type: 'screenshot',
+          path: screenshotPath,
+          description: `[UAT destructive] Post-action screenshot for "${element.text ?? element.selector}"`,
+        });
+
+        if (actionError) {
+          findings.push({
+            id: `5-uat-destructive-${module.id}-${element.selector.slice(0, 30).replace(/[^a-z0-9]/gi, '-')}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: module.id,
+            description: `[UAT destructive] Action failed for "${element.text ?? element.selector}": ${actionError}`,
+            screenshot: screenshotPath,
+          });
+        }
+
+        // 3. Restore entity via API using snapshot
+        if (apiClient && snapshot !== null) {
+          try {
+            await apiClient.put(`/api/${module.id}/restore`, { snapshot });
+          } catch (restoreErr) {
+            const restoreMsg = restoreErr instanceof Error ? restoreErr.message : String(restoreErr);
+            findings.push({
+              id: `5-uat-restore-failed-${module.id}`,
+              type: 'infra-issue',
+              severity: 'critical',
+              agentId: this.agentId,
+              module: module.id,
+              description: `[UAT destructive] Restore failed for module "${module.id}" after destructive action — stopping destructive tests. Error: ${restoreMsg}`,
+            });
+            stopDestructive = true;
+          }
+        }
+      }
+    }
+
+    return findings;
+  }
+
+  /**
+   * For each module: navigate, discover interactive elements, interact with
+   * non-destructive ones, fill + submit forms, open/close modals.
+   * Returns findings discovered in this pass; does NOT push to the outer array directly.
+   */
+  private async runInteractionPass(
+    page: Page,
+    _existingFindings: Finding[],
+    passLabel: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    for (const module of this.config.modules) {
+      // Register console listener BEFORE navigation so errors during page load are captured
+      const consoleErrors: string[] = [];
+      const consoleListener = (msg: { type(): string; text(): string }): void => {
+        if (msg.type() === 'error') {
+          consoleErrors.push(msg.text());
+        }
+      };
+      page.on('console', consoleListener);
+
+      try {
+        await Promise.race([
+          navigateToSection(page, module.id, this.config),
+          new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error('Navigation timed out after 5s')), 5_000),
+          ),
+        ]);
+        await waitForSectionLoad(page);
+      } catch (navErr) {
+        page.removeListener('console', consoleListener);
+        const isTimeout = navErr instanceof Error && navErr.message.includes('timed out after 5s');
+        findings.push({
+          id: `5-beta-nav-${passLabel}-${module.id}`,
+          type: 'infra-issue',
+          severity: isTimeout ? 'medium' : 'high',
+          agentId: this.agentId,
+          module: module.id,
+          description: isTimeout
+            ? `[Beta] Slow page: navigation to module "${module.id}" exceeded 5s timeout`
+            : `[Beta] Navigation to module "${module.id}" failed: ${navErr instanceof Error ? navErr.message : String(navErr)}`,
+        });
+        continue;
+      }
+
+      const screenshotBefore = await captureScreenshot(
+        page,
+        `beta-${passLabel}-${module.id}-before`,
+        this.runDir,
+      );
+      this.addEvidence({
+        type: 'screenshot',
+        path: screenshotBefore,
+        description: `[Beta] Before-interaction screenshot for module "${module.id}" (${passLabel})`,
+      });
+
+      const elements = await discoverInteractiveElements(page);
+
+      for (const element of elements) {
+        if (element.isDestructive) {
+          // Skip destructive elements — never click delete/remove/archive/etc.
+          continue;
+        }
+
+        if (element.type === 'button' || element.type === 'link' ||
+            element.type === 'tab' || element.type === 'menuitem') {
+          try {
+            // Check for modal-opening elements first
+            const modalOpened = await openModal(page, element.selector);
+            if (modalOpened) {
+              await closeModal(page, 'escape');
+            } else {
+              await page.waitForTimeout(1000);
+            }
+          } catch {
+            // Element may have been detached; continue
+          }
+        } else if (element.type === 'input' || element.type === 'textarea' || element.type === 'select') {
+          try {
+            await fillForm(page, 'form', undefined);
+          } catch {
+            // Form fill is best-effort
+          }
+        }
+      }
+
+      // Flush accumulated console errors
+      page.removeListener('console', consoleListener);
+
+      for (const errorMsg of consoleErrors) {
+        findings.push({
+          id: `5-beta-console-${passLabel}-${module.id}-${errorMsg.slice(0, 40).replace(/\s+/g, '-')}`,
+          type: 'code-bug-logic',
+          severity: 'high',
+          agentId: this.agentId,
+          module: module.id,
+          description: `[Beta] Console error in module "${module.id}" (${passLabel}): ${errorMsg}`,
+          consoleError: errorMsg,
+        });
+      }
+
+      const screenshotAfter = await captureScreenshot(
+        page,
+        `beta-${passLabel}-${module.id}-after`,
+        this.runDir,
+      );
+      this.addEvidence({
+        type: 'screenshot',
+        path: screenshotAfter,
+        description: `[Beta] After-interaction screenshot for module "${module.id}" (${passLabel})`,
+      });
+    }
+
+    return findings;
+  }
+}