@matware/e2e-runner 1.3.0 → 1.3.1

package/src/dashboard.js

@@ -20,7 +20,8 @@ import { generateReport, generateJUnitXML, saveReport, persistRun, loadHistory,
 import { listProjects as dbListProjects, listProjectsWithSparklines as dbListProjectsWithSparklines, getProjectRuns as dbGetProjectRuns, getRunDetail as dbGetRunDetail, getAllRuns as dbGetAllRuns, getRunCount as dbGetRunCount, getProjectScreenshotsDir as dbGetProjectScreenshotsDir, getProjectTestsDir as dbGetProjectTestsDir, getProjectCwd as dbGetProjectCwd, lookupScreenshotHash as dbLookupScreenshotHash, ensureProject as dbEnsureProject, getNetworkLogs as dbGetNetworkLogs, listVariables as dbListVariables, setVariable as dbSetVariable, deleteVariable as dbDeleteVariable, closeDb } from './db.js';
 import { loadConfig } from './config.js';
 import { log, colors as C } from './logger.js';
-import { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getHealthSnapshot } from './learner-sqlite.js';
+import { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getHealthSnapshot, getActionHealthScores } from './learner-sqlite.js';
+import { compareImages } from './visual-diff.js';
 import { handleSyncRoutes } from './sync/hub-routes.js';
 import { migrateSyncSchema } from './sync/schema.js';
 
@@ -120,7 +121,7 @@ export async function startDashboard(config) {
       // API: pool status + dashboard state
       if (pathname === '/api/status') {
         const poolUrls = getPoolUrls(config);
-        const aggregated = await getAggregatedPoolStatus(poolUrls);
+        const aggregated = await getAggregatedPoolStatus(poolUrls, { poolDriver: config.poolDriver, maxSessions: config.maxSessions });
         jsonResponse(res, {
           pool: aggregated,
           poolUrls,
@@ -305,6 +306,38 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — project config warnings (Docker hostname detection)
+      const configWarningsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/config-warnings$/);
+      if (configWarningsMatch) {
+        try {
+          const projectId = parseInt(configWarningsMatch[1], 10);
+          const projectCwd = dbGetProjectCwd(projectId);
+          if (!projectCwd) { jsonResponse(res, { warnings: [] }); return; }
+          const cfg = await loadConfig({}, projectCwd);
+          const warnings = [];
+          const checkDockerHostname = (url, label) => {
+            try {
+              const parsed = new URL(url);
+              if (!parsed.hostname.includes('.') && parsed.hostname !== 'localhost' && parsed.hostname !== '127') {
+                warnings.push({
+                  type: 'docker-hostname',
+                  field: label,
+                  hostname: parsed.hostname,
+                  url,
+                  message: `"${parsed.hostname}" looks like a Docker-internal hostname. The runner will auto-fallback to localhost for auth, but baseUrl requests go through Chrome in Docker (which can resolve it). If tests fail with ENOTFOUND, ensure Chrome pool is on the same Docker network.`,
+                });
+              }
+            } catch {}
+          };
+          if (cfg.baseUrl) checkDockerHostname(cfg.baseUrl, 'baseUrl');
+          if (cfg.authLoginEndpoint) checkDockerHostname(cfg.authLoginEndpoint, 'authLoginEndpoint');
+          jsonResponse(res, { warnings });
+        } catch (error) {
+          jsonResponse(res, { warnings: [], error: error.message });
+        }
+        return;
+      }
+
       // API: DB — project screenshots list
       const projectScreenshotsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/screenshots$/);
       if (projectScreenshotsMatch) {
@@ -498,6 +531,9 @@ export async function startDashboard(config) {
             case 'trends':
               data = getTestTrends(projectId, days);
               break;
+            case 'actions':
+              data = getActionHealthScores(projectId, days);
+              break;
             default:
               jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
               return;
@@ -509,6 +545,30 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: visual diff — compare two screenshots on demand
+      if (pathname === '/api/visual-diff') {
+        try {
+          const baseline = url.searchParams.get('baseline');
+          const current = url.searchParams.get('current');
+          const thresholdParam = url.searchParams.get('threshold');
+          if (!baseline || !current) {
+            jsonResponse(res, { error: 'Missing baseline or current parameter' }, 400); return;
+          }
+          if (!fs.existsSync(baseline)) { jsonResponse(res, { error: `Baseline not found: ${baseline}` }, 404); return; }
+          if (!fs.existsSync(current)) { jsonResponse(res, { error: `Current not found: ${current}` }, 404); return; }
+
+          const diffPath = path.join(config.screenshotsDir, `api-diff-${Date.now()}.png`);
+          const result = compareImages(baseline, current, {
+            threshold: thresholdParam ? parseFloat(thresholdParam) : 0.1,
+            diffOutputPath: diffPath,
+          });
+          jsonResponse(res, { ...result, diffImagePath: diffPath });
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: serve screenshot by hash (e.g. /api/screenshot-hash/a3f2b1c9)
       const ssHashMatch = pathname.match(/^\/api\/screenshot-hash\/([a-f0-9]{8})$/);
       if (ssHashMatch) {
@@ -663,7 +723,9 @@ export async function startDashboard(config) {
           if (oversize) { jsonResponse(res, { error: 'Payload too large' }, 413); return; }
           try {
             const data = JSON.parse(body);
-            bufferLiveEvent(data);
+            if (data.event !== 'test:frame') {
+              bufferLiveEvent(data);
+            }
             wss.broadcast(JSON.stringify(data));
           } catch { /* */ }
           jsonResponse(res, { ok: true });
@@ -711,8 +773,9 @@ export async function startDashboard(config) {
     }
   }, 30000);
 
+  const devOrigins = process.env.NODE_ENV === 'production' ? [] : ['http://localhost:5173', 'http://127.0.0.1:5173'];
   const wss = createWebSocketServer(server, {
-    allowedOrigins: [`http://localhost:${port}`, `http://127.0.0.1:${port}`],
+    allowedOrigins: [`http://localhost:${port}`, `http://127.0.0.1:${port}`, ...devOrigins],
     onConnect(socket) {
       // Replay live state for new/reconnected clients
       for (const rid of Object.keys(liveEventBuffers)) {
@@ -727,7 +790,7 @@ export async function startDashboard(config) {
   const poolUrls = getPoolUrls(config);
   const pollInterval = setInterval(async () => {
     try {
-      const aggregated = await getAggregatedPoolStatus(poolUrls);
+      const aggregated = await getAggregatedPoolStatus(poolUrls, { poolDriver: config.poolDriver, maxSessions: config.maxSessions });
       wss.broadcast(JSON.stringify({ event: 'pool:status', data: aggregated }));
     } catch { /* */ }
   }, 5000);
@@ -765,21 +828,25 @@ export async function startDashboard(config) {
       runConfig.triggeredBy = 'dashboard';
       if (params.concurrency) runConfig.concurrency = params.concurrency;
       if (params.baseUrl) runConfig.baseUrl = params.baseUrl;
+      if (params.screencast !== undefined) runConfig.screencast = params.screencast;
 
       // Wire up onProgress to broadcast WS events
       runConfig.onProgress = (data) => {
-        bufferLiveEvent(data);
+        // Don't buffer screencast frames — they're ephemeral and high volume
+        if (data.event !== 'test:frame') {
+          bufferLiveEvent(data);
+        }
         wss.broadcast(JSON.stringify(data));
       };
 
       let tests, hooks;
       if (params.suite) {
-        ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir));
+        ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir, runConfig.modulesDir));
       } else {
         ({ tests, hooks } = loadAllSuites(runConfig.testsDir, runConfig.modulesDir, runConfig.exclude));
       }
 
-      await waitForAnyPool(getPoolUrls(runConfig));
+      await waitForAnyPool(getPoolUrls(runConfig), 30000, { poolDriver: runConfig.poolDriver, maxSessions: runConfig.maxSessions });
       const results = await runTestsParallel(tests, runConfig, hooks || {});
       const report = generateReport(results);
       const suiteName = params.suite || null;

package/src/db.js

@@ -199,6 +199,24 @@ function migrate(db) {
     CREATE INDEX IF NOT EXISTS idx_al_project  ON api_learnings(project_id);
     CREATE INDEX IF NOT EXISTS idx_al_endpoint ON api_learnings(endpoint);
 
+    CREATE TABLE IF NOT EXISTS action_health (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id      INTEGER NOT NULL REFERENCES projects(id),
+      run_id          INTEGER REFERENCES runs(id) ON DELETE CASCADE,
+      test_name       TEXT NOT NULL,
+      action_index    INTEGER NOT NULL,
+      action_type     TEXT NOT NULL,
+      selector        TEXT,
+      success         INTEGER NOT NULL,
+      duration_ms     INTEGER,
+      console_errors_after INTEGER DEFAULT 0,
+      network_errors_after INTEGER DEFAULT 0,
+      page_url        TEXT,
+      created_at      TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_ah_project  ON action_health(project_id);
+    CREATE INDEX IF NOT EXISTS idx_ah_selector ON action_health(selector);
+
     CREATE TABLE IF NOT EXISTS error_patterns (
       id              INTEGER PRIMARY KEY AUTOINCREMENT,
       project_id      INTEGER NOT NULL REFERENCES projects(id),
@@ -255,6 +273,28 @@ function migrate(db) {
     db.exec('ALTER TABLE test_results ADD COLUMN pool_url TEXT');
   }
 
+  // Add pool_driver column to runs for driver visibility
+  try {
+    db.prepare('SELECT pool_driver FROM runs LIMIT 0').run();
+  } catch {
+    db.exec('ALTER TABLE runs ADD COLUMN pool_driver TEXT');
+  }
+
+  // Add visual diff columns to test_results
+  const trCols = db.pragma('table_info(test_results)').map(c => c.name);
+  if (!trCols.includes('baseline_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN baseline_screenshot TEXT');
+  }
+  if (!trCols.includes('verification_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN verification_screenshot TEXT');
+  }
+  if (!trCols.includes('diff_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN diff_screenshot TEXT');
+  }
+  if (!trCols.includes('visual_diff_json')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN visual_diff_json TEXT');
+  }
+
   // Migrations: add metadata columns to screenshot_hashes
   const ssColumns = db.pragma('table_info(screenshot_hashes)').map(c => c.name);
   if (!ssColumns.includes('test_name')) {
@@ -336,18 +376,18 @@ export function getScreenshotHashes(filePaths) {
 }
 
 /** Save a run + its test results in a single transaction. Returns the run's DB id. */
-export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
+export function saveRun(projectId, report, runId, suiteName, triggeredBy, poolDriver) {
   const d = getDb();
   const { summary, results, generatedAt } = report;
 
   const insertRun = d.prepare(`
-    INSERT INTO runs (project_id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO runs (project_id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by, pool_driver)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
   const insertTest = d.prepare(`
-    INSERT INTO test_results (run_id, name, success, error, start_time, end_time, duration_ms, attempt, max_attempts, error_screenshot, console_logs, network_errors, screenshots, network_logs, actions_json, pool_url)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO test_results (run_id, name, success, error, start_time, end_time, duration_ms, attempt, max_attempts, error_screenshot, console_logs, network_errors, screenshots, network_logs, actions_json, pool_url, baseline_screenshot, verification_screenshot, diff_screenshot, visual_diff_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
   const insertHash = d.prepare('INSERT OR IGNORE INTO screenshot_hashes (hash, file_path, project_id, run_id, test_name, step_index, page_url, screenshot_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
@@ -364,6 +404,7 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
       generatedAt,
       suiteName || null,
       triggeredBy || null,
+      poolDriver || null,
     );
     const runDbId = runInfo.lastInsertRowid;
 
@@ -407,6 +448,10 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
         r.networkLogs?.length ? JSON.stringify(r.networkLogs) : null,
         actionsCondensed.length ? JSON.stringify(actionsCondensed) : null,
         r.poolUrl || null,
+        r.baselineScreenshot || null,
+        r.verificationScreenshot || null,
+        r.diffScreenshot || null,
+        r.visualDiff ? JSON.stringify(r.visualDiff) : null,
       );
 
       // Register screenshot hashes with metadata
@@ -425,6 +470,9 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
       if (r.baselineScreenshot) {
         insertHash.run(computeScreenshotHash(r.baselineScreenshot), r.baselineScreenshot, projectId, runDbId, r.name, null, null, 'baseline');
       }
+      if (r.diffScreenshot) {
+        insertHash.run(computeScreenshotHash(r.diffScreenshot), r.diffScreenshot, projectId, runDbId, r.name, null, null, 'diff');
+      }
     }
 
     return runDbId;
@@ -480,7 +528,7 @@ export function listProjects() {
 export function getProjectRuns(projectId, limit = 50, offset = 0) {
   const d = getDb();
   return d.prepare(`
-    SELECT id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by
+    SELECT id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by, pool_driver
     FROM runs
     WHERE project_id = ?
     ORDER BY generated_at DESC
@@ -503,6 +551,9 @@ export function getRunDetail(runDbId) {
     const ss = t.screenshots ? JSON.parse(t.screenshots) : [];
     allPaths.push(...ss);
     if (t.error_screenshot) allPaths.push(t.error_screenshot);
+    if (t.baseline_screenshot) allPaths.push(t.baseline_screenshot);
+    if (t.verification_screenshot) allPaths.push(t.verification_screenshot);
+    if (t.diff_screenshot) allPaths.push(t.diff_screenshot);
   }
   const hashMap = getScreenshotHashes(allPaths);
 
@@ -518,6 +569,7 @@ export function getRunDetail(runDbId) {
     generatedAt: run.generated_at,
     suiteName: run.suite_name,
     triggeredBy: run.triggered_by || null,
+    poolDriver: run.pool_driver || null,
     results: tests.map(t => {
       const screenshots = t.screenshots ? JSON.parse(t.screenshots) : [];
       const testPaths = [...screenshots];
@@ -543,6 +595,10 @@ export function getRunDetail(runDbId) {
         actions: t.actions_json ? JSON.parse(t.actions_json) : [],
         screenshotHashes,
         poolUrl: t.pool_url || null,
+        baselineScreenshot: t.baseline_screenshot || null,
+        verificationScreenshot: t.verification_screenshot || null,
+        diffScreenshot: t.diff_screenshot || null,
+        visualDiff: t.visual_diff_json ? JSON.parse(t.visual_diff_json) : null,
       };
     }),
   };
@@ -553,7 +609,7 @@ export function getAllRuns(limit = 50, offset = 0) {
   const d = getDb();
   return d.prepare(`
     SELECT r.id, r.run_id, r.total, r.passed, r.failed, r.pass_rate, r.duration,
-           r.generated_at, r.suite_name, r.triggered_by, p.name AS project_name, p.id AS project_id
+           r.generated_at, r.suite_name, r.triggered_by, r.pool_driver, p.name AS project_name, p.id AS project_id
     FROM runs r
     JOIN projects p ON p.id = r.project_id
     ORDER BY r.generated_at DESC

package/src/index.js

@@ -8,21 +8,23 @@
  */
 
 export { loadConfig } from './config.js';
-export { waitForPool, connectToPool, startPool, stopPool, restartPool, getPoolStatus } from './pool.js';
+export { waitForPool, connectToPool, disconnectFromPool, startPool, stopPool, restartPool, getPoolStatus, clearDriverCache, getCachedDriver, trackCdpSession, releaseCdpSession, releaseSteelSession } from './pool.js';
 export { getPoolUrls, getAllPoolStatuses, getAggregatedPoolStatus, waitForAnyPool, selectPool, selectAndConnect } from './pool-manager.js';
 export { executeAction } from './actions.js';
-export { runTest, runTestsParallel, loadTestFile, loadTestSuite, loadAllSuites, listSuites } from './runner.js';
+export { runTest, runTestsParallel, loadTestFile, loadTestSuite, loadAllSuites, listSuites, fetchAuthToken } from './runner.js';
 export { generateReport, generateJUnitXML, saveReport, printReport, saveHistory, loadHistory, loadHistoryRun } from './reporter.js';
 export { startDashboard, stopDashboard } from './dashboard.js';
 export { fetchIssue, parseIssueUrl, detectProvider, checkCliAuth } from './issues.js';
 export { buildPrompt, generateTests, hasApiKey } from './ai-generate.js';
 export { verifyIssue } from './verify.js';
 export { resolveTestData, loadModuleRegistry, listModules } from './module-resolver.js';
-export { learnFromRun, categorizeError } from './learner.js';
-export { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getTestCreationContext, generateImprovements } from './learner-sqlite.js';
+export { learnFromRun, categorizeError, isInfraError, INFRA_CATEGORIES } from './learner.js';
+export { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getTestCreationContext, generateImprovements, getActionHealthScores } from './learner-sqlite.js';
 export { generateLearningsMarkdown } from './learner-markdown.js';
 export { writeToGraph, queryGraph, closeNeo4j } from './learner-neo4j.js';
 export { startNeo4j, stopNeo4j, getNeo4jStatus } from './neo4j-pool.js';
+export { forkAppInstance, destroyFork, destroyAllForks, getAppPoolStatus, isAppPoolEnabled } from './app-pool.js';
+export { compareImages, assertVisualMatch } from './visual-diff.js';
 
 import { loadConfig } from './config.js';
 import { waitForAnyPool, getPoolUrls } from './pool-manager.js';

package/src/learner-sqlite.js

@@ -293,6 +293,117 @@ export function getRunInsights(projectId, report) {
     }
   }
 
+  // ── At-Least-One Guarantee: generate positive insights if none exist ──
+  if (insights.length === 0 && report.results.length > 0) {
+    const allPassed = report.results.every(r => r.success);
+
+    // Green streak detection
+    if (allPassed) {
+      const recentRuns = d.prepare(`
+        SELECT run_id, MIN(success) AS all_passed
+        FROM test_learnings
+        WHERE project_id = ?
+        GROUP BY run_id
+        ORDER BY created_at DESC
+        LIMIT 10
+      `).all(projectId);
+      const streak = recentRuns.findIndex(r => r.all_passed === 0);
+      const streakCount = streak === -1 ? recentRuns.length : streak;
+      if (streakCount >= 3) {
+        insights.push({
+          type: 'green-streak',
+          streak: streakCount,
+          message: `${streakCount}-run green streak — suite is stable.`,
+        });
+      }
+    }
+
+    // New tests (no historical data)
+    const newTests = report.results.filter(r => {
+      const h = d.prepare('SELECT COUNT(*) AS c FROM test_learnings WHERE project_id = ? AND test_name = ?').get(projectId, r.name);
+      return !h || h.c <= 1; // <= 1 because current run may already be written
+    });
+    if (newTests.length > 0) {
+      insights.push({
+        type: 'new-tests',
+        tests: newTests.map(t => t.name),
+        message: `${newTests.length} new test(s): ${newTests.map(t => t.name).slice(0, 3).join(', ')}${newTests.length > 3 ? '...' : ''}`,
+      });
+    }
+
+    // Pass rate improvement vs 7-day average
+    const avg7d = d.prepare(`
+      SELECT ROUND(AVG(CASE WHEN success = 1 THEN 100.0 ELSE 0.0 END), 1) AS pass_rate
+      FROM test_learnings
+      WHERE project_id = ? AND created_at >= datetime('now', '-7 days')
+    `).get(projectId);
+    const thisRunPassRate = Math.round((report.results.filter(r => r.success).length / report.results.length) * 1000) / 10;
+    if (avg7d?.pass_rate && thisRunPassRate > avg7d.pass_rate + 5) {
+      insights.push({
+        type: 'improved-pass-rate',
+        message: `Pass rate improved: ${thisRunPassRate}% this run vs ${avg7d.pass_rate}% 7-day average.`,
+      });
+    }
+
+    // Performance comparison
+    const avgDuration = d.prepare(`
+      SELECT ROUND(AVG(duration_ms)) AS avg_ms
+      FROM test_learnings
+      WHERE project_id = ? AND duration_ms IS NOT NULL AND created_at >= datetime('now', '-30 days')
+    `).get(projectId);
+    if (avgDuration?.avg_ms && report.results.length > 0) {
+      const thisAvg = report.results.reduce((s, r) => {
+        const ms = (r.endTime && r.startTime) ? new Date(r.endTime) - new Date(r.startTime) : 0;
+        return s + ms;
+      }, 0) / report.results.length;
+      const delta = Math.round(((thisAvg - avgDuration.avg_ms) / avgDuration.avg_ms) * 100);
+      if (Math.abs(delta) > 15) {
+        insights.push({
+          type: 'performance',
+          message: delta < 0
+            ? `This run was ${Math.abs(delta)}% faster than the 30-day average.`
+            : `This run was ${delta}% slower than the 30-day average — check for new slow pages.`,
+        });
+      }
+    }
+
+    // Stable selectors confirmed
+    if (allPassed) {
+      const usedSelectors = new Set();
+      for (const r of report.results) {
+        if (!r.actions) continue;
+        for (const a of r.actions) {
+          if (a.selector) usedSelectors.add(a.selector);
+        }
+      }
+      if (usedSelectors.size > 0) {
+        const stableCount = d.prepare(`
+          SELECT COUNT(DISTINCT selector) AS c
+          FROM selector_learnings
+          WHERE project_id = ? AND selector IN (${[...usedSelectors].map(() => '?').join(',')})
+          GROUP BY selector
+          HAVING SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) = 0 AND COUNT(*) > 3
+        `).all(projectId, ...usedSelectors).length;
+        if (stableCount > 0) {
+          insights.push({
+            type: 'stable-selectors',
+            count: stableCount,
+            message: `${stableCount} selector(s) confirmed stable across multiple runs.`,
+          });
+        }
+      }
+    }
+
+    // Fallback: if still no insights, report basic run stats
+    if (insights.length === 0) {
+      const passed = report.results.filter(r => r.success).length;
+      insights.push({
+        type: 'run-summary',
+        message: `${passed}/${report.results.length} tests passed (${thisRunPassRate}%).`,
+      });
+    }
+  }
+
   return insights;
 }
 
@@ -397,6 +508,49 @@ export function getSelectorHistory(projectId, selector, days = 30) {
  * Aggregated context for test authoring — curates the most actionable learnings
  * into a compact object that AI agents can use to write better tests.
  */
+/**
+ * Action health scores — composite per-action metrics aggregated by (action_type, selector).
+ * Score = (success_rate * 0.5) + (speed_score * 0.3) + (collateral_score * 0.2)
+ */
+export function getActionHealthScores(projectId, days = 30) {
+  const d = getDb();
+  const rows = d.prepare(`
+    SELECT
+      action_type,
+      selector,
+      page_url,
+      COUNT(*) AS total_uses,
+      ROUND(AVG(CASE WHEN success = 1 THEN 100.0 ELSE 0.0 END), 1) AS success_rate,
+      ROUND(AVG(duration_ms)) AS avg_duration_ms,
+      MAX(duration_ms) AS max_duration_ms,
+      ROUND(AVG(console_errors_after + network_errors_after), 1) AS avg_collateral_errors,
+      COUNT(DISTINCT test_name) AS used_by_tests
+    FROM action_health
+    WHERE project_id = ? AND created_at >= datetime('now', '-' || ? || ' days')
+    GROUP BY action_type, selector
+    HAVING total_uses >= 2
+    ORDER BY success_rate ASC, total_uses DESC
+  `).all(projectId, days);
+
+  return rows.map(r => {
+    const speedScore = 100 - Math.min(100, ((r.avg_duration_ms || 0) / 5000) * 100);
+    const collateralScore = 100 - Math.min(100, (r.avg_collateral_errors || 0) * 20);
+    const healthScore = Math.round(r.success_rate * 0.5 + speedScore * 0.3 + collateralScore * 0.2);
+    return {
+      actionType: r.action_type,
+      selector: r.selector,
+      pageUrl: r.page_url,
+      totalUses: r.total_uses,
+      successRate: r.success_rate,
+      avgDurationMs: r.avg_duration_ms,
+      maxDurationMs: r.max_duration_ms,
+      avgCollateralErrors: r.avg_collateral_errors,
+      usedByTests: r.used_by_tests,
+      healthScore,
+    };
+  });
+}
+
 export function getTestCreationContext(projectId) {
   const d = getDb();
   const ctx = {};

package/src/learner.js

@@ -17,8 +17,12 @@ const ERROR_CATEGORIES = [
   { pattern: /waitForSelector/i, category: 'selector-not-found' },
   { pattern: /not visible/i, category: 'selector-not-found' },
   { pattern: /navigation/i, category: 'navigation-error' },
-  { pattern: /net::ERR_/i, category: 'connection-refused' },
+  { pattern: /ERR_NAME_NOT_RESOLVED/i, category: 'dns-resolution' },
   { pattern: /ERR_CONNECTION_REFUSED/i, category: 'connection-refused' },
+  { pattern: /ECONNREFUSED/i, category: 'connection-refused' },
+  { pattern: /Chrome Pool unavailable/i, category: 'pool-unavailable' },
+  { pattern: /Failed to connect to pool/i, category: 'pool-connect-failed' },
+  { pattern: /net::ERR_/i, category: 'network-error' },
   { pattern: /assert_text/i, category: 'assert-text-failed' },
   { pattern: /assert_url/i, category: 'assert-url-failed' },
   { pattern: /assert_visible/i, category: 'assert-visible-failed' },
@@ -35,6 +39,18 @@ const ERROR_CATEGORIES = [
   { pattern: /evaluate.*ERROR/i, category: 'evaluate-error' },
 ];
 
+/** Categories that indicate infrastructure failures — not test/app issues. */
+export const INFRA_CATEGORIES = new Set([
+  'connection-refused', 'dns-resolution', 'pool-unavailable', 'pool-connect-failed', 'network-error',
+]);
+
+/** Returns true if the error is an infrastructure issue (pool down, DNS, connection refused). */
+export function isInfraError(errorMsg) {
+  if (!errorMsg) return false;
+  const { category } = categorizeError(errorMsg);
+  return INFRA_CATEGORIES.has(category);
+}
+
 export function categorizeError(errorMsg) {
   if (!errorMsg) return { category: 'unknown', pattern: 'unknown' };
 
@@ -204,6 +220,11 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
+  const insertActionHealth = d.prepare(`
+    INSERT INTO action_health (project_id, run_id, test_name, action_index, action_type, selector, success, duration_ms, console_errors_after, network_errors_after, page_url)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
   const upsertErrorPattern = d.prepare(`
     INSERT INTO error_patterns (project_id, pattern, category, occurrence_count, first_seen, last_seen, example_error, example_test)
     VALUES (?, ?, ?, 1, datetime('now'), datetime('now'), ?, ?)
@@ -214,23 +235,40 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
       example_test = excluded.example_test
   `);
 
+  let infraCount = 0;
+
   const tx = d.transaction(() => {
     for (const result of results) {
       const durationMs = (result.endTime && result.startTime)
         ? new Date(result.endTime) - new Date(result.startTime)
         : null;
-      const isFlaky = result.success && (result.attempt || 1) > 1 ? 1 : 0;
+      const isFlaky = result.flaky ? 1 : (result.success && (result.attempt || 1) > 1 ? 1 : 0);
 
       // Categorize error
       let errorPattern = null;
+      let infraFailure = false;
       if (result.error) {
         const { category, pattern } = categorizeError(result.error);
         errorPattern = category;
+        infraFailure = INFRA_CATEGORIES.has(category);
 
-        // Track error pattern
+        // Always track error patterns (even infra) for awareness
         upsertErrorPattern.run(projectId, pattern, category, result.error, result.name);
       }
 
+      if (infraFailure) {
+        infraCount++;
+        // Still write test_learnings so run counts are accurate,
+        // but skip selector/page/api learnings to avoid polluting metrics
+        insertTestLearning.run(
+          projectId, runDbId, result.name,
+          result.success ? 1 : 0, durationMs, isFlaky,
+          result.attempt || 1, result.maxAttempts || 1,
+          errorPattern
+        );
+        continue;
+      }
+
       // Test-level learning
       insertTestLearning.run(
         projectId, runDbId, result.name,
@@ -275,6 +313,33 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
           api.isError, result.name
         );
       }
+
+      // Action health — per-action metrics with collateral error estimation
+      if (result.actions?.length) {
+        const totalConsoleErrors = (result.consoleLogs || []).filter(l => l.type === 'error').length;
+        const totalNetworkErrors = (result.networkErrors || []).length;
+        const actionCount = result.actions.length;
+        let currentPage = '/';
+
+        for (let i = 0; i < actionCount; i++) {
+          const action = result.actions[i];
+          if (action.type === 'goto' || action.type === 'navigate') {
+            try { currentPage = new URL(action.value, 'http://placeholder').pathname; } catch { currentPage = action.value || '/'; }
+          }
+          // Estimate collateral errors: later actions inherit more errors (weighted distribution)
+          const weight = (i + 1) / actionCount;
+          const consoleAfter = action.success === false ? Math.round(totalConsoleErrors * weight) : 0;
+          const networkAfter = action.success === false ? Math.round(totalNetworkErrors * weight) : 0;
+
+          insertActionHealth.run(
+            projectId, runDbId, result.name, i,
+            action.type || 'unknown', action.selector || null,
+            action.success === false ? 0 : 1,
+            action.duration || null,
+            consoleAfter, networkAfter, currentPage
+          );
+        }
+      }
     }
   });
 
@@ -287,6 +352,8 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
   if (config?.learningsNeo4j) {
     writeToGraph(projectId, runDbId, report, config, suiteName).catch(() => {});
   }
+
+  return { infraCount };
 }
 
 // ── Summary cache ─────────────────────────────────────────────────────────────