@matware/e2e-runner 1.1.0 → 1.2.1

package/src/dashboard.js

@@ -17,9 +17,10 @@ import { createWebSocketServer } from './websocket.js';
 import { getPoolStatus, waitForPool } from './pool.js';
 import { runTestsParallel, loadAllSuites, loadTestSuite, listSuites } from './runner.js';
 import { generateReport, generateJUnitXML, saveReport, persistRun, loadHistory, loadHistoryRun } from './reporter.js';
-import { listProjects as dbListProjects, getProjectRuns as dbGetProjectRuns, getRunDetail as dbGetRunDetail, getAllRuns as dbGetAllRuns, getRunCount as dbGetRunCount, getProjectScreenshotsDir as dbGetProjectScreenshotsDir, getProjectTestsDir as dbGetProjectTestsDir, getProjectCwd as dbGetProjectCwd, lookupScreenshotHash as dbLookupScreenshotHash, closeDb } from './db.js';
+import { listProjects as dbListProjects, 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, 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 } from './learner-sqlite.js';
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -204,6 +205,27 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — network logs for a run (filterable)
+      const networkLogsMatch = pathname.match(/^\/api\/db\/runs\/(\d+)\/network-logs$/);
+      if (networkLogsMatch) {
+        try {
+          const runDbId = parseInt(networkLogsMatch[1], 10);
+          const filters = {};
+          if (url.searchParams.has('testName')) filters.testName = url.searchParams.get('testName');
+          if (url.searchParams.has('method')) filters.method = url.searchParams.get('method');
+          if (url.searchParams.has('statusMin')) filters.statusMin = parseInt(url.searchParams.get('statusMin'), 10);
+          if (url.searchParams.has('statusMax')) filters.statusMax = parseInt(url.searchParams.get('statusMax'), 10);
+          if (url.searchParams.has('urlPattern')) filters.urlPattern = url.searchParams.get('urlPattern');
+          if (url.searchParams.get('errorsOnly') === 'true') filters.errorsOnly = true;
+          if (url.searchParams.get('includeHeaders') === 'true') filters.includeHeaders = true;
+          if (url.searchParams.get('includeBodies') === 'true') filters.includeBodies = true;
+          jsonResponse(res, dbGetNetworkLogs(runDbId, filters));
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: DB — project screenshots list
       const projectScreenshotsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/screenshots$/);
       if (projectScreenshotsMatch) {
@@ -239,6 +261,124 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — suite detail (tests + actions)
+      const suiteDetailMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/suites\/(.+)$/);
+      if (suiteDetailMatch) {
+        try {
+          const projectId = parseInt(suiteDetailMatch[1], 10);
+          const suiteName = decodeURIComponent(suiteDetailMatch[2]);
+          const dir = dbGetProjectTestsDir(projectId);
+          if (!dir || !fs.existsSync(dir)) {
+            jsonResponse(res, { error: 'Tests directory not found' }, 404);
+            return;
+          }
+          const { tests, hooks } = loadTestSuite(suiteName, dir);
+          jsonResponse(res, { name: suiteName, tests, hooks });
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — cross-project learnings (when no project selected)
+      const crossLearningsMatch = pathname.match(/^\/api\/db\/learnings(?:\/(\w+))?$/);
+      if (crossLearningsMatch) {
+        try {
+          const category = crossLearningsMatch[1] || 'summary';
+          const days = parseInt(url.searchParams.get('days') || '30', 10);
+          let data;
+          switch (category) {
+            case 'summary': {
+              const summary = getLearningsSummary(null);
+              const trends = getTestTrends(null, 7);
+              data = { ...summary, recentTrend: trends };
+              break;
+            }
+            default:
+              jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
+              return;
+          }
+          jsonResponse(res, data);
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project modules list
+      const projectModulesMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/modules$/);
+      if (projectModulesMatch) {
+        try {
+          const projectId = parseInt(projectModulesMatch[1], 10);
+          const projectCwd = dbGetProjectCwd(projectId);
+          if (!projectCwd) { jsonResponse(res, []); return; }
+          const modulesDir = path.join(projectCwd, 'e2e', 'modules');
+          if (!fs.existsSync(modulesDir)) { jsonResponse(res, []); return; }
+          const files = fs.readdirSync(modulesDir).filter(f => f.endsWith('.json')).sort();
+          const modules = files.map(f => {
+            try {
+              const data = JSON.parse(fs.readFileSync(path.join(modulesDir, f), 'utf-8'));
+              return {
+                name: f.replace('.json', ''),
+                file: f,
+                description: data.description || null,
+                params: data.params || [],
+                actionCount: Array.isArray(data.actions) ? data.actions.length : 0,
+              };
+            } catch { return { name: f.replace('.json', ''), file: f, description: null, params: [], actionCount: 0 }; }
+          });
+          jsonResponse(res, modules);
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project learnings (summary or specific category)
+      const learningsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/learnings(?:\/(\w+))?$/);
+      if (learningsMatch) {
+        try {
+          const projectId = parseInt(learningsMatch[1], 10);
+          const category = learningsMatch[2] || 'summary';
+          const days = parseInt(url.searchParams.get('days') || '30', 10);
+
+          let data;
+          switch (category) {
+            case 'summary': {
+              const summary = getLearningsSummary(projectId);
+              const trends = getTestTrends(projectId, 7);
+              data = { ...summary, recentTrend: trends };
+              break;
+            }
+            case 'flaky':
+              data = getFlakySummary(projectId, days);
+              break;
+            case 'selectors':
+              data = getSelectorStability(projectId, days);
+              break;
+            case 'pages':
+              data = getPageHealth(projectId, days);
+              break;
+            case 'apis':
+              data = getApiHealth(projectId, days);
+              break;
+            case 'errors':
+              data = getErrorPatterns(projectId);
+              break;
+            case 'trends':
+              data = getTestTrends(projectId, days);
+              break;
+            default:
+              jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
+              return;
+          }
+          jsonResponse(res, data);
+        } 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) {
@@ -262,7 +402,7 @@ export async function startDashboard(config) {
           const ext = path.extname(realPath).toLowerCase();
           const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
           if (!mimeTypes[ext]) { jsonResponse(res, { error: 'Not an image' }, 400); return; }
-          res.writeHead(200, { 'Content-Type': mimeTypes[ext] });
+          res.writeHead(200, { 'Content-Type': mimeTypes[ext], 'Cache-Control': 'no-store' });
           fs.createReadStream(realPath).pipe(res);
         } catch (error) {
           jsonResponse(res, { error: error.message }, 500);
@@ -302,7 +442,7 @@ export async function startDashboard(config) {
           jsonResponse(res, { error: 'Not an image' }, 400);
           return;
         }
-        res.writeHead(200, { 'Content-Type': mimeTypes[ext] });
+        res.writeHead(200, { 'Content-Type': mimeTypes[ext], 'Cache-Control': 'no-store' });
         fs.createReadStream(realPath).pipe(res);
         return;
       }
@@ -347,7 +487,7 @@ export async function startDashboard(config) {
           return;
         }
         if (fs.existsSync(resolvedPath)) {
-          res.writeHead(200, { 'Content-Type': imageMimeTypes[ext] });
+          res.writeHead(200, { 'Content-Type': imageMimeTypes[ext], 'Cache-Control': 'no-store' });
           fs.createReadStream(resolvedPath).pipe(res);
         } else {
           jsonResponse(res, { error: 'Not found' }, 404);
@@ -422,20 +562,31 @@ export async function startDashboard(config) {
   function bufferLiveEvent(data) {
     const rid = data.runId;
     if (!rid) return;
-    if (data.event === 'run:start') liveEventBuffers[rid] = [];
-    if (!liveEventBuffers[rid]) liveEventBuffers[rid] = [];
-    liveEventBuffers[rid].push(data);
+    if (data.event === 'run:start') liveEventBuffers[rid] = { events: [], ts: Date.now() };
+    if (!liveEventBuffers[rid]) liveEventBuffers[rid] = { events: [], ts: Date.now() };
+    liveEventBuffers[rid].events.push(data);
+    liveEventBuffers[rid].ts = Date.now();
     if (data.event === 'run:complete' || data.event === 'run:error') {
       setTimeout(() => { delete liveEventBuffers[rid]; }, 30000);
     }
   }
 
+  // Purge stale live event buffers (runs that never completed, max 5 min)
+  const bufferPurgeInterval = setInterval(() => {
+    const maxAge = 5 * 60 * 1000;
+    for (const rid of Object.keys(liveEventBuffers)) {
+      if (Date.now() - liveEventBuffers[rid].ts > maxAge) {
+        delete liveEventBuffers[rid];
+      }
+    }
+  }, 30000);
+
   const wss = createWebSocketServer(server, {
     allowedOrigins: [`http://localhost:${port}`, `http://127.0.0.1:${port}`],
     onConnect(socket) {
       // Replay live state for new/reconnected clients
       for (const rid of Object.keys(liveEventBuffers)) {
-        for (const evt of liveEventBuffers[rid]) {
+        for (const evt of liveEventBuffers[rid].events) {
           wss.sendTo(socket, JSON.stringify(evt));
         }
       }
@@ -479,6 +630,7 @@ export async function startDashboard(config) {
         runConfig = { ...config };
       }
 
+      runConfig.triggeredBy = 'dashboard';
       if (params.concurrency) runConfig.concurrency = params.concurrency;
       if (params.baseUrl) runConfig.baseUrl = params.baseUrl;
 
@@ -492,7 +644,7 @@ export async function startDashboard(config) {
       if (params.suite) {
         ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir));
       } else {
-        ({ tests, hooks } = loadAllSuites(runConfig.testsDir));
+        ({ tests, hooks } = loadAllSuites(runConfig.testsDir, runConfig.modulesDir, runConfig.exclude));
       }
 
       await waitForPool(runConfig.poolUrl);
@@ -509,8 +661,18 @@ export async function startDashboard(config) {
     }
   }
 
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const host = config.dashboardHost || '127.0.0.1';
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        log('❌', `${C.red}Port ${port} is already in use. Try a different port with --port <number>.${C.reset}`);
+        reject(new Error(`Port ${port} is already in use`));
+      } else {
+        reject(err);
+      }
+    });
+
     server.listen(port, host, () => {
       log('🖥️', `${C.bold}Dashboard${C.reset} running at ${C.cyan}http://${host}:${port}${C.reset}`);
 
@@ -521,6 +683,7 @@ export async function startDashboard(config) {
         close() {
           clearInterval(pollInterval);
           clearInterval(dbPollInterval);
+          clearInterval(bufferPurgeInterval);
           wss.close();
           server.close();
           closeDb();

package/src/db.js

@@ -100,6 +100,27 @@ function migrate(db) {
     db.exec('ALTER TABLE test_results ADD COLUMN screenshots TEXT');
   }
 
+  // Add network_logs column if upgrading from older schema
+  try {
+    db.prepare('SELECT network_logs FROM test_results LIMIT 0').run();
+  } catch {
+    db.exec('ALTER TABLE test_results ADD COLUMN network_logs TEXT');
+  }
+
+  // Add actions_json column if upgrading from older schema
+  try {
+    db.prepare('SELECT actions_json FROM test_results LIMIT 0').run();
+  } catch {
+    db.exec('ALTER TABLE test_results ADD COLUMN actions_json TEXT');
+  }
+
+  // Add triggered_by column if upgrading from older schema
+  try {
+    db.prepare('SELECT triggered_by FROM runs LIMIT 0').run();
+  } catch {
+    db.exec('ALTER TABLE runs ADD COLUMN triggered_by TEXT');
+  }
+
   // Screenshot hashes table
   db.exec(`
     CREATE TABLE IF NOT EXISTS screenshot_hashes (
@@ -111,6 +132,113 @@ function migrate(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_ss_path ON screenshot_hashes(file_path);
   `);
+
+  // ── Learning system tables ──────────────────────────────────────────────────
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS test_learnings (
+      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,
+      success       INTEGER NOT NULL,
+      duration_ms   INTEGER,
+      flaky         INTEGER DEFAULT 0,
+      attempt       INTEGER DEFAULT 1,
+      max_attempts  INTEGER DEFAULT 1,
+      error_pattern TEXT,
+      created_at    TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_tl_project ON test_learnings(project_id);
+    CREATE INDEX IF NOT EXISTS idx_tl_test    ON test_learnings(test_name);
+    CREATE INDEX IF NOT EXISTS idx_tl_created ON test_learnings(created_at);
+
+    CREATE TABLE IF NOT EXISTS selector_learnings (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id    INTEGER NOT NULL REFERENCES projects(id),
+      run_id        INTEGER REFERENCES runs(id) ON DELETE CASCADE,
+      selector      TEXT NOT NULL,
+      action_type   TEXT NOT NULL,
+      success       INTEGER NOT NULL,
+      page_url      TEXT,
+      test_name     TEXT,
+      error         TEXT,
+      created_at    TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_sl_project  ON selector_learnings(project_id);
+    CREATE INDEX IF NOT EXISTS idx_sl_selector ON selector_learnings(selector);
+
+    CREATE TABLE IF NOT EXISTS page_learnings (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id      INTEGER NOT NULL REFERENCES projects(id),
+      run_id          INTEGER REFERENCES runs(id) ON DELETE CASCADE,
+      url_path        TEXT NOT NULL,
+      load_time_ms    INTEGER,
+      console_errors  INTEGER DEFAULT 0,
+      console_warns   INTEGER DEFAULT 0,
+      network_errors  INTEGER DEFAULT 0,
+      test_name       TEXT,
+      success         INTEGER NOT NULL,
+      created_at      TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_pl_project ON page_learnings(project_id);
+    CREATE INDEX IF NOT EXISTS idx_pl_url     ON page_learnings(url_path);
+
+    CREATE TABLE IF NOT EXISTS api_learnings (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id    INTEGER NOT NULL REFERENCES projects(id),
+      run_id        INTEGER REFERENCES runs(id) ON DELETE CASCADE,
+      endpoint      TEXT NOT NULL,
+      method        TEXT NOT NULL,
+      status        INTEGER,
+      duration_ms   INTEGER,
+      is_error      INTEGER DEFAULT 0,
+      test_name     TEXT,
+      created_at    TEXT DEFAULT (datetime('now'))
+    );
+    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 error_patterns (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id      INTEGER NOT NULL REFERENCES projects(id),
+      pattern         TEXT NOT NULL,
+      category        TEXT NOT NULL,
+      occurrence_count INTEGER DEFAULT 1,
+      first_seen      TEXT DEFAULT (datetime('now')),
+      last_seen       TEXT DEFAULT (datetime('now')),
+      example_error   TEXT,
+      example_test    TEXT,
+      UNIQUE(project_id, pattern)
+    );
+    CREATE INDEX IF NOT EXISTS idx_ep_project ON error_patterns(project_id);
+    CREATE INDEX IF NOT EXISTS idx_ep_cat     ON error_patterns(category);
+
+    CREATE TABLE IF NOT EXISTS learning_summary (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id      INTEGER NOT NULL UNIQUE REFERENCES projects(id),
+      total_runs      INTEGER DEFAULT 0,
+      total_tests     INTEGER DEFAULT 0,
+      overall_pass_rate REAL DEFAULT 0,
+      avg_duration_ms REAL DEFAULT 0,
+      flaky_tests     TEXT,
+      slow_tests      TEXT,
+      unstable_selectors TEXT,
+      failing_pages   TEXT,
+      api_issues      TEXT,
+      top_errors      TEXT,
+      updated_at      TEXT DEFAULT (datetime('now'))
+    );
+  `);
+
+  // Migrations: add metadata columns to screenshot_hashes
+  const ssColumns = db.pragma('table_info(screenshot_hashes)').map(c => c.name);
+  if (!ssColumns.includes('test_name')) {
+    db.exec('ALTER TABLE screenshot_hashes ADD COLUMN test_name TEXT');
+    db.exec('ALTER TABLE screenshot_hashes ADD COLUMN step_index INTEGER');
+    db.exec('ALTER TABLE screenshot_hashes ADD COLUMN page_url TEXT');
+    db.exec('ALTER TABLE screenshot_hashes ADD COLUMN screenshot_type TEXT');
+  }
 }
 
 /** Upsert a project row. Returns the project id. */
@@ -155,17 +283,19 @@ export function computeScreenshotHash(filePath) {
   return crypto.createHash('sha256').update(filePath).digest('hex').slice(0, 8);
 }
 
-/** Register a screenshot hash. INSERT OR IGNORE avoids duplicates. */
-export function registerScreenshotHash(hash, filePath, projectId, runDbId) {
+/** Register a screenshot hash. INSERT OR IGNORE avoids duplicates. Optional metadata: testName, stepIndex, pageUrl, screenshotType. */
+export function registerScreenshotHash(hash, filePath, projectId, runDbId, meta = {}) {
   const d = getDb();
-  d.prepare('INSERT OR IGNORE INTO screenshot_hashes (hash, file_path, project_id, run_id) VALUES (?, ?, ?, ?)').run(hash, filePath, projectId || null, runDbId || null);
+  d.prepare(
+    'INSERT OR IGNORE INTO screenshot_hashes (hash, file_path, project_id, run_id, test_name, step_index, page_url, screenshot_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
+  ).run(hash, filePath, projectId || null, runDbId || null, meta.testName || null, meta.stepIndex ?? null, meta.pageUrl || null, meta.screenshotType || null);
 }
 
-/** Look up a screenshot by hash. Strips optional "ss:" prefix. Returns { hash, file_path, project_id } or null. */
+/** Look up a screenshot by hash. Strips optional "ss:" prefix. Returns { hash, file_path, project_id, test_name, step_index, page_url, screenshot_type } or null. */
 export function lookupScreenshotHash(rawHash) {
   const d = getDb();
   const hash = rawHash.replace(/^ss:/, '');
-  return d.prepare('SELECT hash, file_path, project_id FROM screenshot_hashes WHERE hash = ?').get(hash) || null;
+  return d.prepare('SELECT hash, file_path, project_id, test_name, step_index, page_url, screenshot_type FROM screenshot_hashes WHERE hash = ?').get(hash) || null;
 }
 
 /** Batch lookup: given an array of file paths, returns { [path]: hash } map. */
@@ -182,21 +312,21 @@ 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) {
+export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
   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)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO runs (project_id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by)
+    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)
-    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)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
-  const insertHash = d.prepare('INSERT OR IGNORE INTO screenshot_hashes (hash, file_path, project_id, run_id) 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 (?, ?, ?, ?, ?, ?, ?, ?)');
 
   const tx = d.transaction(() => {
     const runInfo = insertRun.run(
@@ -209,6 +339,7 @@ export function saveRun(projectId, report, runId, suiteName) {
       summary.duration,
       generatedAt,
       suiteName || null,
+      triggeredBy || null,
     );
     const runDbId = runInfo.lastInsertRowid;
 
@@ -222,6 +353,19 @@ export function saveRun(projectId, report, runId, suiteName) {
         .filter(a => a.type === 'screenshot' && a.result?.screenshot)
         .map(a => a.result.screenshot);
 
+      // Condensed actions for narrative display
+      const actionsCondensed = (r.actions || []).map(a => ({
+        type: a.type,
+        selector: a.selector || undefined,
+        value: a.value || undefined,
+        text: a.text || undefined,
+        success: a.success,
+        duration: a.duration,
+        narrative: a.narrative || undefined,
+        error: a.error || undefined,
+        actionRetries: a.actionRetries || undefined,
+      }));
+
       insertTest.run(
         runDbId,
         r.name,
@@ -236,14 +380,22 @@ export function saveRun(projectId, report, runId, suiteName) {
         r.consoleLogs ? JSON.stringify(r.consoleLogs) : null,
         r.networkErrors ? JSON.stringify(r.networkErrors) : null,
         screenshots.length ? JSON.stringify(screenshots) : null,
+        r.networkLogs?.length ? JSON.stringify(r.networkLogs) : null,
+        actionsCondensed.length ? JSON.stringify(actionsCondensed) : null,
       );
 
-      // Register screenshot hashes
-      for (const ssPath of screenshots) {
-        insertHash.run(computeScreenshotHash(ssPath), ssPath, projectId, runDbId);
+      // Register screenshot hashes with metadata
+      const ssActions = (r.actions || []).filter(a => a.type === 'screenshot' && a.result?.screenshot);
+      for (let si = 0; si < ssActions.length; si++) {
+        const a = ssActions[si];
+        const actionIdx = r.actions.indexOf(a);
+        insertHash.run(computeScreenshotHash(a.result.screenshot), a.result.screenshot, projectId, runDbId, r.name, actionIdx, null, 'action');
       }
       if (r.errorScreenshot) {
-        insertHash.run(computeScreenshotHash(r.errorScreenshot), r.errorScreenshot, projectId, runDbId);
+        insertHash.run(computeScreenshotHash(r.errorScreenshot), r.errorScreenshot, projectId, runDbId, r.name, null, null, 'error');
+      }
+      if (r.verificationScreenshot) {
+        insertHash.run(computeScreenshotHash(r.verificationScreenshot), r.verificationScreenshot, projectId, runDbId, r.name, null, null, 'verification');
       }
     }
 
@@ -273,7 +425,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
+    SELECT id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by
     FROM runs
     WHERE project_id = ?
     ORDER BY generated_at DESC
@@ -310,6 +462,7 @@ export function getRunDetail(runDbId) {
     },
     generatedAt: run.generated_at,
     suiteName: run.suite_name,
+    triggeredBy: run.triggered_by || null,
     results: tests.map(t => {
       const screenshots = t.screenshots ? JSON.parse(t.screenshots) : [];
       const testPaths = [...screenshots];
@@ -331,6 +484,8 @@ export function getRunDetail(runDbId) {
         screenshots,
         consoleLogs: t.console_logs ? JSON.parse(t.console_logs) : [],
         networkErrors: t.network_errors ? JSON.parse(t.network_errors) : [],
+        networkLogs: t.network_logs ? JSON.parse(t.network_logs) : [],
+        actions: t.actions_json ? JSON.parse(t.actions_json) : [],
         screenshotHashes,
       };
     }),
@@ -342,7 +497,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, p.name AS project_name, p.id AS project_id
+           r.generated_at, r.suite_name, r.triggered_by, 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
@@ -357,6 +512,66 @@ export function getRunCount() {
   return row.cnt;
 }
 
+/** Query network logs for a run with optional filters.
+ * Filters: testName, method, statusMin, statusMax, urlPattern, errorsOnly, includeHeaders, includeBodies.
+ * By default returns only: url, method, status, statusText, duration.
+ */
+export function getNetworkLogs(runDbId, filters = {}) {
+  const d = getDb();
+
+  let query = 'SELECT name, network_logs FROM test_results WHERE run_id = ?';
+  const params = [runDbId];
+
+  if (filters.testName) {
+    query += ' AND name = ?';
+    params.push(filters.testName);
+  }
+
+  const rows = d.prepare(query).all(...params);
+  const results = [];
+
+  for (const row of rows) {
+    if (!row.network_logs) continue;
+    let logs = JSON.parse(row.network_logs);
+
+    if (filters.method) {
+      logs = logs.filter(l => l.method === filters.method.toUpperCase());
+    }
+    if (filters.statusMin !== undefined) {
+      logs = logs.filter(l => l.status >= filters.statusMin);
+    }
+    if (filters.statusMax !== undefined) {
+      logs = logs.filter(l => l.status <= filters.statusMax);
+    }
+    if (filters.urlPattern) {
+      const re = new RegExp(filters.urlPattern, 'i');
+      logs = logs.filter(l => re.test(l.url));
+    }
+    if (filters.errorsOnly) {
+      logs = logs.filter(l => l.status >= 400);
+    }
+
+    const mapped = logs.map(l => {
+      const entry = { url: l.url, method: l.method, status: l.status, statusText: l.statusText, duration: l.duration };
+      if (filters.includeHeaders || filters.includeBodies) {
+        entry.requestHeaders = l.requestHeaders;
+        entry.responseHeaders = l.responseHeaders;
+      }
+      if (filters.includeBodies) {
+        entry.requestBody = l.requestBody;
+        entry.responseBody = l.responseBody;
+      }
+      return entry;
+    });
+
+    if (mapped.length > 0) {
+      results.push({ testName: row.name, logs: mapped });
+    }
+  }
+
+  return results;
+}
+
 /** Close the database connection. */
 export function closeDb() {
   if (db) {

package/src/index.js

@@ -16,6 +16,12 @@ 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 } 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';
 
 import { loadConfig } from './config.js';
 import { waitForPool } from './pool.js';
@@ -36,7 +42,7 @@ export async function createRunner(userConfig = {}) {
     /** Runs all test suites from the tests directory */
     async runAll() {
       await waitForPool(config.poolUrl);
-      const { tests, hooks } = loadAllSuites(config.testsDir);
+      const { tests, hooks } = loadAllSuites(config.testsDir, config.modulesDir, config.exclude);
       const results = await runTestsParallel(tests, config, hooks);
       const report = generateReport(results);
       saveReport(report, config.screenshotsDir, config);
@@ -47,7 +53,7 @@ export async function createRunner(userConfig = {}) {
     /** Runs a single suite by name */
     async runSuite(name) {
       await waitForPool(config.poolUrl);
-      const { tests, hooks } = loadTestSuite(name, config.testsDir);
+      const { tests, hooks } = loadTestSuite(name, config.testsDir, config.modulesDir);
       const results = await runTestsParallel(tests, config, hooks);
       const report = generateReport(results);
       saveReport(report, config.screenshotsDir, config);
@@ -68,7 +74,7 @@ export async function createRunner(userConfig = {}) {
     /** Runs tests from a JSON file path */
     async runFile(filePath) {
       await waitForPool(config.poolUrl);
-      const { tests, hooks } = loadTestFile(filePath);
+      const { tests, hooks } = loadTestFile(filePath, config.modulesDir);
       const results = await runTestsParallel(tests, config, hooks);
       const report = generateReport(results);
       saveReport(report, config.screenshotsDir, config);