@hasna/testers 0.0.32 → 0.0.34

package/dist/index.js

@@ -9748,6 +9748,7 @@ function resetDatabase() {
   database.exec("DELETE FROM auth_presets");
   database.exec("DELETE FROM environments");
   database.exec("DELETE FROM schedules");
+  database.exec("DELETE FROM testing_workflows");
   database.exec("DELETE FROM api_check_results");
   database.exec("DELETE FROM api_checks");
   database.exec("DELETE FROM runs");
@@ -9756,6 +9757,7 @@ function resetDatabase() {
   database.exec("DELETE FROM agents");
   database.exec("DELETE FROM scan_issues");
   database.exec("DELETE FROM projects");
+  database.exec("DELETE FROM sessions");
 }
 function resolvePartialId(table, partialId) {
   const database = getDatabase();
@@ -10171,6 +10173,46 @@ ALTER TABLE runs ADD COLUMN pr_base_branch TEXT;
 ALTER TABLE runs ADD COLUMN pr_commit_sha TEXT;
 ALTER TABLE runs ADD COLUMN pr_url TEXT;
 ALTER TABLE runs ADD COLUMN gh_app_installation_id TEXT;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    tab_id INTEGER NOT NULL,
+    url TEXT,
+    title TEXT,
+    entries TEXT NOT NULL DEFAULT '[]',
+    entry_count INTEGER NOT NULL DEFAULT 0,
+    error_count INTEGER NOT NULL DEFAULT 0,
+    console_count INTEGER NOT NULL DEFAULT 0,
+    nav_count INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'exported' CHECK(status IN ('live','saved','exported')),
+    start_time TEXT NOT NULL,
+    end_time TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_sessions_tab ON sessions(tab_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+  CREATE INDEX IF NOT EXISTS idx_sessions_created ON sessions(created_at DESC);
+  `,
+    `
+CREATE TABLE IF NOT EXISTS testing_workflows (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  description TEXT,
+  scenario_filter TEXT NOT NULL DEFAULT '{}',
+  persona_ids TEXT NOT NULL DEFAULT '[]',
+  goal TEXT,
+  execution TEXT NOT NULL DEFAULT '{"target":"local"}',
+  settings TEXT NOT NULL DEFAULT '{}',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_testing_workflows_project ON testing_workflows(project_id);
+CREATE INDEX IF NOT EXISTS idx_testing_workflows_enabled ON testing_workflows(enabled);
   `
   ];
 });
@@ -11297,7 +11339,8 @@ async function getPage(browser, options) {
   }
   const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
   try {
-    return await getBrowserPage(browser, { viewport, userAgent: options?.userAgent, locale: options?.locale });
+    const page = await getBrowserPage(browser, { viewport, userAgent: options?.userAgent, locale: options?.locale });
+    return page;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new BrowserError(`Failed to create page: ${message}`);
@@ -11640,6 +11683,41 @@ var init_healer = __esm(() => {
 
 // src/lib/ai-client.ts
 import Anthropic2 from "@anthropic-ai/sdk";
+import {
+  click as browserClick,
+  fill as browserFill,
+  clickRef,
+  typeRef,
+  fillRef,
+  selectRef,
+  checkRef,
+  hoverRef,
+  getPageInfo,
+  elementExists,
+  getText,
+  getUrl,
+  getTitle,
+  extractTable,
+  getAriaSnapshot,
+  crawl as browserCrawl,
+  addInterceptRule,
+  clearInterceptRules,
+  startHAR,
+  getPerformanceMetrics,
+  startCoverage
+} from "@hasna/browser";
+async function takeSnapshot(page, _sessionId) {
+  const tree = await getAriaSnapshot(page);
+  return {
+    tree,
+    snapshot: tree,
+    refs: [],
+    interactive_count: 0
+  };
+}
+async function extractStructuredData(page) {
+  return getPageInfo(page);
+}
 function resolveModel2(nameOrPreset) {
   if (nameOrPreset in MODEL_MAP) {
     return MODEL_MAP[nameOrPreset];
@@ -11679,7 +11757,18 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
       case "click": {
         const selector = toolInput.selector;
         try {
-          await page.click(selector);
+          const healResult = await browserClick(page, selector, { selfHeal: true });
+          const screenshot = await screenshotter.capture(page, {
+            runId: context.runId,
+            scenarioSlug: context.scenarioSlug,
+            stepNumber: context.stepNumber,
+            action: "click"
+          });
+          const healNote = healResult.healed ? ` [self-healed via ${healResult.method}]` : "";
+          return {
+            result: `Clicked element: ${selector}${healNote}`,
+            screenshot
+          };
         } catch (clickErr) {
           const errMsg = clickErr instanceof Error ? clickErr.message : String(clickErr);
           if (errMsg.includes("not found") || errMsg.includes("No element") || errMsg.includes("waiting for selector")) {
@@ -11688,29 +11777,23 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
               const heal = await healSelector2({ page, failedSelector: selector, intent: `click the element matching "${selector}"` });
               if (heal.healed && heal.newSelector) {
                 await page.click(heal.newSelector);
-                const screenshot2 = await screenshotter.capture(page, { runId: context.runId, scenarioSlug: context.scenarioSlug, stepNumber: context.stepNumber, action: "click" });
-                return { result: `Clicked element: ${heal.newSelector} [healed from "${selector}" \u2014 ${heal.reasoning}]`, screenshot: screenshot2 };
+                const screenshot = await screenshotter.capture(page, { runId: context.runId, scenarioSlug: context.scenarioSlug, stepNumber: context.stepNumber, action: "click" });
+                return { result: `Clicked element: ${heal.newSelector} [AI-healed from "${selector}" \u2014 ${heal.reasoning}]`, screenshot };
               }
             }
           }
           throw clickErr;
         }
-        const screenshot = await screenshotter.capture(page, {
-          runId: context.runId,
-          scenarioSlug: context.scenarioSlug,
-          stepNumber: context.stepNumber,
-          action: "click"
-        });
-        return {
-          result: `Clicked element: ${selector}`,
-          screenshot
-        };
       }
       case "fill": {
         const selector = toolInput.selector;
         const value = toolInput.value;
         try {
-          await page.fill(selector, value);
+          const healResult = await browserFill(page, selector, value, undefined, true);
+          const healNote = healResult.healed ? ` [self-healed via ${healResult.method}]` : "";
+          return {
+            result: `Filled "${selector}" with value${healNote}`
+          };
         } catch (fillErr) {
           const errMsg = fillErr instanceof Error ? fillErr.message : String(fillErr);
           if (errMsg.includes("not found") || errMsg.includes("No element") || errMsg.includes("waiting for selector")) {
@@ -11719,15 +11802,12 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
               const heal = await healSelector2({ page, failedSelector: selector, intent: `fill the input field "${selector}" with "${value}"` });
               if (heal.healed && heal.newSelector) {
                 await page.fill(heal.newSelector, value);
-                return { result: `Filled "${heal.newSelector}" with value [healed from "${selector}"]` };
+                return { result: `Filled "${heal.newSelector}" with value [AI-healed from "${selector}"]` };
               }
             }
           }
           throw fillErr;
         }
-        return {
-          result: `Filled "${selector}" with value`
-        };
       }
       case "select_option": {
         const selector = toolInput.selector;
@@ -11915,6 +11995,279 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
           result: `Test ${status}: ${reasoning}`
         };
       }
+      case "browser_snapshot": {
+        const snapshot = await takeSnapshot(page, context.sessionId);
+        return {
+          result: snapshot.tree
+        };
+      }
+      case "browser_click_ref": {
+        const ref = toolInput.ref;
+        await takeSnapshot(page, context.sessionId);
+        await clickRef(page, context.sessionId, ref);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "click_ref"
+        });
+        return {
+          result: `Clicked ref: ${ref}`,
+          screenshot
+        };
+      }
+      case "browser_type_ref": {
+        const ref = toolInput.ref;
+        const text = toolInput.text;
+        const clear = toolInput.clear;
+        await takeSnapshot(page, context.sessionId);
+        await typeRef(page, context.sessionId, ref, text, { clear: clear ?? true });
+        return {
+          result: `Typed into ref ${ref}: "${text}"`
+        };
+      }
+      case "browser_fill_ref": {
+        const ref = toolInput.ref;
+        const value = toolInput.value;
+        await takeSnapshot(page, context.sessionId);
+        await fillRef(page, context.sessionId, ref, value);
+        return {
+          result: `Filled ref ${ref} with value`
+        };
+      }
+      case "browser_select_ref": {
+        const ref = toolInput.ref;
+        const value = toolInput.value;
+        await takeSnapshot(page, context.sessionId);
+        const selected = await selectRef(page, context.sessionId, ref, value);
+        return {
+          result: `Selected "${selected.join(", ")}" in ref ${ref}`
+        };
+      }
+      case "browser_check_ref": {
+        const ref = toolInput.ref;
+        const checked = toolInput.checked;
+        await takeSnapshot(page, context.sessionId);
+        await checkRef(page, context.sessionId, ref, checked);
+        return {
+          result: `${checked ? "Checked" : "Unchecked"} ref: ${ref}`
+        };
+      }
+      case "browser_hover_ref": {
+        const ref = toolInput.ref;
+        await takeSnapshot(page, context.sessionId);
+        await hoverRef(page, context.sessionId, ref);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "hover_ref"
+        });
+        return {
+          result: `Hovered ref: ${ref}`,
+          screenshot
+        };
+      }
+      case "browser_check": {
+        const [info, snapshot] = await Promise.all([
+          getPageInfo(page),
+          takeSnapshot(page, context.sessionId)
+        ]);
+        const parts = [
+          `URL: ${info.url}`,
+          `Title: ${info.title}`,
+          info.meta_description ? `Description: ${info.meta_description}` : null,
+          `Links: ${info.links_count} | Images: ${info.images_count} | Forms: ${info.forms_count}`,
+          `Text length: ${info.text_length} | Console errors: ${info.has_console_errors}`,
+          `Viewport: ${info.viewport.width}x${info.viewport.height}`,
+          ``,
+          `Interactive elements: ${snapshot.interactive_count}`,
+          ``,
+          snapshot.tree
+        ].filter(Boolean);
+        return { result: parts.join(`
+`) };
+      }
+      case "browser_assert": {
+        const assertionType = toolInput.assertion_type;
+        const selector = toolInput.selector;
+        const expected = toolInput.expected;
+        const sessionId = context.sessionId ?? "default";
+        switch (assertionType) {
+          case "element_exists": {
+            if (!selector)
+              return { result: "Error: selector required for element_exists assertion" };
+            const result = await elementExists(page, selector);
+            const pass = result.exists;
+            return { result: pass ? `PASS: element "${selector}" exists (${result.count} match${result.count !== 1 ? "es" : ""}, visible: ${result.visible})` : `FAIL: element "${selector}" not found` };
+          }
+          case "text_contains": {
+            const text = selector ? await getText(page, selector) : await getText(page);
+            const pass = expected !== undefined && text.includes(expected);
+            return { result: pass ? `PASS: text contains "${expected}"` : `FAIL: text does not contain "${expected}". Found: "${text.slice(0, 200)}"` };
+          }
+          case "url_matches": {
+            const url = await getUrl(page);
+            const pattern = expected ?? "";
+            const pass = new RegExp(pattern).test(url);
+            return { result: pass ? `PASS: URL matches /${pattern}/` : `FAIL: URL "${url}" does not match /${pattern}/` };
+          }
+          case "title_contains": {
+            const title = await getTitle(page);
+            const pass = expected !== undefined && title.includes(expected);
+            return { result: pass ? `PASS: title contains "${expected}"` : `FAIL: title "${title}" does not contain "${expected}"` };
+          }
+          default:
+            return { result: `Unknown assertion type: ${assertionType}` };
+        }
+      }
+      case "browser_extract": {
+        const mode = toolInput.mode;
+        const selector = toolInput.selector;
+        switch (mode) {
+          case "structured": {
+            const data = await extractStructuredData(page);
+            return { result: JSON.stringify(data, null, 2) };
+          }
+          case "table": {
+            if (!selector)
+              return { result: "Error: selector required for table extraction" };
+            const rows = await extractTable(page, selector);
+            return { result: JSON.stringify(rows, null, 2) };
+          }
+          case "text": {
+            const text = selector ? await getText(page, selector) : await getText(page);
+            return { result: text };
+          }
+          case "aria": {
+            const aria = await getAriaSnapshot(page);
+            return { result: aria };
+          }
+          default:
+            return { result: `Unknown extract mode: ${mode}` };
+        }
+      }
+      case "browser_crawl": {
+        const url = toolInput.url;
+        const maxDepth = toolInput.max_depth ?? 2;
+        const maxPages = toolInput.max_pages ?? 20;
+        const result = await browserCrawl(url, { maxDepth, maxPages });
+        return { result: JSON.stringify(result, null, 2) };
+      }
+      case "browser_intercept": {
+        const action = toolInput.action;
+        const pattern = toolInput.pattern;
+        const interceptAction = toolInput.intercept_action;
+        const statusCode = toolInput.status_code;
+        const body = toolInput.body;
+        const sessionId = context.sessionId ?? "default";
+        switch (action) {
+          case "block": {
+            if (!pattern)
+              return { result: "Error: pattern required for block action" };
+            await addInterceptRule(page, { pattern, action: "block" });
+            return { result: `Blocked requests matching: ${pattern}` };
+          }
+          case "modify": {
+            if (!pattern)
+              return { result: "Error: pattern required for modify action" };
+            await addInterceptRule(page, { pattern, action: "modify", response: { status: statusCode ?? 200, body: body ?? "" } });
+            return { result: `Modified requests matching: ${pattern} \u2192 status ${statusCode ?? 200}` };
+          }
+          case "log": {
+            if (!pattern)
+              return { result: "Error: pattern required for log action" };
+            await addInterceptRule(page, { pattern, action: "log" });
+            return { result: `Logging requests matching: ${pattern}` };
+          }
+          case "clear": {
+            await clearInterceptRules(page);
+            return { result: "Cleared all intercept rules" };
+          }
+          case "har_start": {
+            const harCapture = startHAR(page);
+            activeHARs.set(sessionId, harCapture);
+            return { result: "HAR capture started" };
+          }
+          case "har_stop": {
+            const harCapture = activeHARs.get(sessionId);
+            if (!harCapture)
+              return { result: "Error: no active HAR capture for this session" };
+            const har = harCapture.stop();
+            activeHARs.delete(sessionId);
+            const entryCount = har.log.entries.length;
+            return { result: `HAR capture stopped: ${entryCount} entries captured
+${JSON.stringify(har, null, 2)}` };
+          }
+          default:
+            return { result: `Unknown intercept action: ${action}` };
+        }
+      }
+      case "browser_performance": {
+        const mode = toolInput.mode;
+        const sessionId = context.sessionId ?? "default";
+        switch (mode) {
+          case "metrics": {
+            const metrics = await getPerformanceMetrics(page);
+            return { result: JSON.stringify(metrics, null, 2) };
+          }
+          case "deep": {
+            const deep = await getPerformanceMetrics(page);
+            return { result: JSON.stringify(deep, null, 2) };
+          }
+          case "coverage_start": {
+            const session = await startCoverage(page);
+            activeCoverage.set(sessionId, session);
+            return { result: "Coverage tracking started" };
+          }
+          case "coverage_stop": {
+            const session = activeCoverage.get(sessionId);
+            if (!session)
+              return { result: "Error: no active coverage session" };
+            const result = await session.stop();
+            activeCoverage.delete(sessionId);
+            return { result: JSON.stringify(result, null, 2) };
+          }
+          default:
+            return { result: `Unknown performance mode: ${mode}` };
+        }
+      }
+      case "browser_a11y": {
+        const level = toolInput.level ?? "AA";
+        const snapshot = await page.accessibility.snapshot();
+        if (!snapshot)
+          return { result: "Error: could not capture accessibility tree" };
+        const issues = [];
+        const checkNode = (node, path = []) => {
+          const label = node.name ?? "";
+          const role = node.role ?? "";
+          const nodePath = [...path, `${role}${label ? ` "${label}"` : ""}`];
+          if (role === "img" && !label) {
+            issues.push(`[A] Image missing alt text at ${nodePath.join(" > ")}`);
+          }
+          if (["button", "link", "textbox", "checkbox", "radio", "combobox", "menuitem"].includes(role) && !label) {
+            issues.push(`[A] ${role} missing accessible name at ${nodePath.join(" > ")}`);
+          }
+          if (["textbox", "combobox", "slider", "spinbutton"].includes(role) && !label) {
+            issues.push(`[AA] Form field (${role}) missing label at ${nodePath.join(" > ")}`);
+          }
+          if (role.startsWith("heading") && !label) {
+            issues.push(`[AAA] Empty heading at ${nodePath.join(" > ")}`);
+          }
+          for (const child of node.children ?? []) {
+            checkNode(child, nodePath);
+          }
+        };
+        checkNode(snapshot);
+        const maxLevel = level === "A" ? 0 : level === "AA" ? 1 : 2;
+        const levelMap = { 0: ["A"], 1: ["A", "AA"], 2: ["A", "AA", "AAA"] };
+        const applicable = levelMap[maxLevel] ?? ["A", "AA"];
+        const filtered = issues.filter((i) => applicable.some((l) => i.includes(`[${l}]`)));
+        const summary = filtered.length === 0 ? `No a11y issues found at WCAG ${level} level` : `${filtered.length} a11y issue${filtered.length > 1 ? "s" : ""} found at WCAG ${level} level:
+${filtered.join(`
+`)}`;
+        return { result: summary };
+      }
       default:
         return { result: `Unknown tool: ${toolName}` };
     }
@@ -11931,6 +12284,7 @@ async function runAgentLoop(options) {
     screenshotter,
     model,
     runId,
+    sessionId,
     maxTurns = 30,
     onStep,
     persona,
@@ -11955,17 +12309,23 @@ Instructions: ${persona.instructions}` : "",
     "You are an expert QA testing agent. Your job is to thoroughly test web application scenarios.",
     "You have browser tools to navigate, interact with, and inspect web pages.",
     "",
-    "Strategy:",
-    "1. First navigate to the target page and take a screenshot to understand the layout",
-    "2. If you can't find an element, use get_elements or get_page_html to discover selectors",
-    "3. Use scroll to discover content below the fold",
+    "Strategy (snapshot \u2192 ref \u2192 act):",
+    "1. Navigate to the target page, then call browser_snapshot to get an accessibility tree with element refs (@e0, @e1, ...)",
+    "2. Use ref-based tools (browser_click_ref, browser_type_ref, browser_fill_ref, etc.) to interact with elements by their ref IDs \u2014 this is more reliable than CSS selectors",
+    "3. After actions that change page state, call browser_snapshot again to see the updated tree",
     "4. Use wait_for or wait_for_navigation after actions that trigger page loads",
     "5. Take screenshots after every meaningful state change",
     "6. Use assert_text and assert_visible to verify expected outcomes",
     "7. When done testing, call report_result with detailed pass/fail reasoning",
     "",
+    "When to use CSS-selector tools vs ref-based tools:",
+    "- Prefer ref-based tools (browser_click_ref, etc.) \u2014 they resolve via the accessibility snapshot and self-heal on DOM changes",
+    "- Use CSS-selector tools (click, fill) only when you need to target elements by a known stable selector",
+    "- Both click and fill have built-in self-healing: if the selector breaks, they try alternative strategies automatically",
+    "- If built-in healing fails, the AI healer kicks in as a deeper fallback",
+    "",
     "Tips:",
-    "- Try multiple selector strategies: by text, by role, by class, by id",
+    "- Call browser_snapshot before interacting \u2014 it gives you the current refs and interactive element count",
     "- If a click triggers navigation, use wait_for_navigation after",
     "- For forms, fill all fields before submitting",
     "- Check for error messages after form submissions",
@@ -12049,7 +12409,7 @@ Instructions: ${persona.instructions}` : "",
         if (onStep) {
           onStep({ type: "tool_call", toolName: toolBlock.name, toolInput, stepNumber });
         }
-        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber, a11y });
+        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber, sessionId, a11y });
         if (onStep) {
           onStep({ type: "tool_result", toolName: toolBlock.name, toolResult: execResult.result, stepNumber });
         }
@@ -12203,9 +12563,11 @@ function createClientForModel(model, apiKey) {
   }
   return createClient(apiKey);
 }
-var BROWSER_TOOLS;
+var activeHARs, activeCoverage, BROWSER_TOOLS;
 var init_ai_client = __esm(() => {
   init_types();
+  activeHARs = new Map;
+  activeCoverage = new Map;
   BROWSER_TOOLS = [
     {
       name: "navigate",
@@ -12508,6 +12870,218 @@ var init_ai_client = __esm(() => {
         },
         required: ["status", "reasoning"]
       }
+    },
+    {
+      name: "browser_snapshot",
+      description: "Take an ARIA accessibility snapshot of the current page. Returns a tree of interactive elements with refs (e.g. @e0, @e1) that can be used with browser_*_ref tools. Use this before interacting with elements to discover their refs.",
+      input_schema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "browser_click_ref",
+      description: "Click an element by its snapshot ref (e.g. @e0). More reliable than CSS selectors because it uses ARIA role-based resolution.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." }
+        },
+        required: ["ref"]
+      }
+    },
+    {
+      name: "browser_type_ref",
+      description: "Type text into an element by its snapshot ref. Optionally clears existing text first.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." },
+          text: { type: "string", description: "Text to type." },
+          clear: { type: "boolean", description: "Clear existing text before typing (default: false)." }
+        },
+        required: ["ref", "text"]
+      }
+    },
+    {
+      name: "browser_fill_ref",
+      description: "Fill an input element by its snapshot ref. Replaces existing content.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." },
+          value: { type: "string", description: "Value to fill." }
+        },
+        required: ["ref", "value"]
+      }
+    },
+    {
+      name: "browser_select_ref",
+      description: "Select an option in a dropdown element by its snapshot ref.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." },
+          value: { type: "string", description: "Option value to select." }
+        },
+        required: ["ref", "value"]
+      }
+    },
+    {
+      name: "browser_check_ref",
+      description: "Check or uncheck a checkbox/radio element by its snapshot ref.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." },
+          checked: { type: "boolean", description: "True to check, false to uncheck." }
+        },
+        required: ["ref", "checked"]
+      }
+    },
+    {
+      name: "browser_hover_ref",
+      description: "Hover over an element by its snapshot ref.",
+      input_schema: {
+        type: "object",
+        properties: {
+          ref: { type: "string", description: "Element ref from snapshot (e.g. @e0)." }
+        },
+        required: ["ref"]
+      }
+    },
+    {
+      name: "browser_check",
+      description: "Get a comprehensive page orientation: page info (URL, title, meta, link/image/form counts, console errors, viewport) plus an ARIA accessibility snapshot with interactive element refs. Use this to understand the current page state before testing.",
+      input_schema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "browser_assert",
+      description: "Run an assertion against the current page state. Supports: element_exists (check selector exists/visible), text_contains (check page text includes substring), url_matches (check URL matches pattern), title_contains (check page title includes substring). Returns pass/fail with details.",
+      input_schema: {
+        type: "object",
+        properties: {
+          assertion: {
+            type: "string",
+            enum: ["element_exists", "text_contains", "url_matches", "title_contains"],
+            description: "The type of assertion to run."
+          },
+          selector: {
+            type: "string",
+            description: "CSS selector (required for element_exists)."
+          },
+          expected: {
+            type: "string",
+            description: "Expected value (text substring, URL pattern, or title substring)."
+          },
+          visible: {
+            type: "boolean",
+            description: "For element_exists: also require the element to be visible (default true)."
+          }
+        },
+        required: ["assertion"]
+      }
+    },
+    {
+      name: "browser_extract",
+      description: "Extract structured data from the current page. Modes: 'structured' (tables, lists, JSON-LD, OpenGraph, meta), 'table' (a specific HTML table), 'text' (page or element text), 'aria' (accessibility snapshot). Returns extracted data as JSON.",
+      input_schema: {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["structured", "table", "text", "aria"],
+            description: "Extraction mode: 'structured' for auto-detected tables/lists/metadata, 'table' for a specific table selector, 'text' for page/element text, 'aria' for accessibility tree."
+          },
+          selector: {
+            type: "string",
+            description: "CSS selector for targeted extraction (required for 'table' mode, optional for 'text')."
+          }
+        },
+        required: ["mode"]
+      }
+    },
+    {
+      name: "browser_crawl",
+      description: "Crawl a website starting from a URL. Discovers linked pages within the same domain, up to a configurable depth. Returns a list of found URLs with their status codes and titles.",
+      input_schema: {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "Starting URL to crawl from."
+          },
+          maxDepth: {
+            type: "number",
+            description: "Maximum crawl depth (default 2)."
+          },
+          maxPages: {
+            type: "number",
+            description: "Maximum number of pages to visit (default 20)."
+          }
+        },
+        required: ["url"]
+      }
+    },
+    {
+      name: "browser_intercept",
+      description: "Intercept network requests on the current page. Actions: 'block' (block matching requests), 'modify' (rewrite response), 'log' (log matching requests), 'clear' (remove all rules), 'har_start' (start HAR recording), 'har_stop' (stop and return HAR).",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["block", "modify", "log", "clear", "har_start", "har_stop"],
+            description: "Intercept action to perform."
+          },
+          pattern: {
+            type: "string",
+            description: "URL pattern to match (required for block/modify/log)."
+          },
+          response: {
+            type: "object",
+            description: "Custom response for 'modify' action.",
+            properties: {
+              status: { type: "number" },
+              body: { type: "string" },
+              headers: { type: "object" }
+            }
+          }
+        },
+        required: ["action"]
+      }
+    },
+    {
+      name: "browser_performance",
+      description: "Measure page performance. Modes: 'metrics' (Web Vitals: FCP, LCP, CLS, TTFB), 'deep' (full resource breakdown, third-party analysis, DOM complexity, main thread blocking, memory), 'coverage_start' (start JS/CSS coverage), 'coverage_stop' (stop and report unused code).",
+      input_schema: {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["metrics", "deep", "coverage_start", "coverage_stop"],
+            description: "Performance measurement mode."
+          }
+        },
+        required: ["mode"]
+      }
+    },
+    {
+      name: "browser_a11y",
+      description: "Run an accessibility audit on the current page using the ARIA accessibility tree. Detects missing labels, roles, focus issues, and other common a11y problems. Returns a list of issues with severity and element details.",
+      input_schema: {
+        type: "object",
+        properties: {
+          level: {
+            type: "string",
+            enum: ["A", "AA", "AAA"],
+            description: "WCAG conformance level to check against (default AA)."
+          }
+        }
+      }
     }
   ];
 });
@@ -15085,17 +15659,17 @@ function resolveTodosDbPath() {
     return envPath;
   return join12(homedir10(), ".todos", "todos.db");
 }
-function connectToTodos() {
+function connectToTodos(options = {}) {
   const dbPath = resolveTodosDbPath();
   if (!existsSync10(dbPath)) {
     throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
   }
-  const db2 = new Database3(dbPath, { readonly: true });
+  const db2 = new Database3(dbPath, { readonly: options.readonly ?? true });
   db2.exec("PRAGMA foreign_keys = ON");
   return db2;
 }
 function pullTasks(options = {}) {
-  const db2 = connectToTodos();
+  const db2 = connectToTodos({ readonly: true });
   try {
     let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
     const params = [];
@@ -15199,7 +15773,7 @@ async function createFailureTasks(run, failedResults, scenarios) {
     return { created: 0, skipped: 0 };
   let db2 = null;
   try {
-    db2 = connectToTodos();
+    db2 = connectToTodos({ readonly: false });
   } catch {
     return { created: 0, skipped: 0 };
   }
@@ -15498,6 +16072,7 @@ async function runSingleScenario(scenario, runId, options) {
       screenshotter,
       model,
       runId,
+      sessionId: result.id,
       maxTurns: effectiveOptions.minimal ? 10 : 30,
       a11y: effectiveOptions.a11y,
       persona: persona ? {
@@ -17370,6 +17945,681 @@ async function startWatcher(options) {
   process.on("SIGTERM", cleanup);
   await new Promise(() => {});
 }
+// src/lib/repo-discovery.ts
+init_paths();
+import { existsSync as existsSync13, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4, mkdirSync as mkdirSync10, unlinkSync } from "fs";
+import { createHash } from "crypto";
+import { join as join15, resolve as resolve2, relative as relative2 } from "path";
+function getCacheDir() {
+  const testersDir = getTestersDir();
+  const cacheDir = join15(testersDir, "repo-index");
+  if (!existsSync13(cacheDir)) {
+    mkdirSync10(cacheDir, { recursive: true });
+  }
+  return cacheDir;
+}
+function pathHash(repoPath) {
+  return createHash("sha256").update(repoPath).digest("hex").slice(0, 16);
+}
+function getCachePath(repoPath) {
+  return join15(getCacheDir(), `${pathHash(repoPath)}.json`);
+}
+function isCacheStale(cached, repoPath) {
+  for (const spec of cached.specs) {
+    const fullPath = join15(repoPath, spec.file);
+    if (!existsSync13(fullPath))
+      return true;
+    try {
+      const stat = statSync(fullPath);
+      if (stat.mtimeMs !== spec.mtimeMs)
+        return true;
+    } catch {
+      return true;
+    }
+  }
+  if (cached.configPath) {
+    const configFullPath = join15(repoPath, cached.configPath);
+    if (!existsSync13(configFullPath))
+      return true;
+    try {
+      const stat = statSync(configFullPath);
+      const age = Date.now() - new Date(cached.snapshotAt).getTime();
+      if (age > 3600000)
+        return true;
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function loadCache(repoPath) {
+  const cachePath = getCachePath(repoPath);
+  if (!existsSync13(cachePath))
+    return null;
+  try {
+    const raw = JSON.parse(readFileSync5(cachePath, "utf-8"));
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function saveCache(snapshot) {
+  const cachePath = getCachePath(snapshot.repoPath);
+  writeFileSync4(cachePath, JSON.stringify(snapshot, null, 2), "utf-8");
+}
+function detectPackageManager(repoPath) {
+  const result = {
+    npm: existsSync13(join15(repoPath, "package-lock.json")),
+    yarn: existsSync13(join15(repoPath, "yarn.lock")),
+    pnpm: existsSync13(join15(repoPath, "pnpm-lock.yaml")),
+    bun: existsSync13(join15(repoPath, "bun.lockb")) || existsSync13(join15(repoPath, "bun.lock")),
+    preferred: "npm"
+  };
+  if (result.bun)
+    result.preferred = "bun";
+  else if (result.pnpm)
+    result.preferred = "pnpm";
+  else if (result.yarn)
+    result.preferred = "yarn";
+  else
+    result.preferred = "npm";
+  return result;
+}
+function detectDevScripts(repoPath) {
+  const pkgPath = join15(repoPath, "package.json");
+  if (!existsSync13(pkgPath)) {
+    return { dev: null, test: null, seed: null, build: null };
+  }
+  let scripts;
+  try {
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    scripts = pkg.scripts ?? {};
+  } catch {
+    return { dev: null, test: null, seed: null, build: null };
+  }
+  const dev = scripts.dev ?? scripts.start ?? scripts["dev:server"] ?? null;
+  const test = scripts.test ?? scripts["test:e2e"] ?? scripts["test:playwright"] ?? scripts.e2e ?? null;
+  const seed = scripts.seed ?? scripts["db:seed"] ?? scripts.seedDb ?? null;
+  const build = scripts.build ?? scripts["build:test"] ?? null;
+  return { dev, test, seed, build };
+}
+function findPlaywrightConfig(repoPath) {
+  const candidates = [
+    "playwright.config.ts",
+    "playwright.config.js",
+    "playwright.config.mjs",
+    "playwright.config.cjs",
+    "playwright-ct.config.ts",
+    "playwright-ct.config.js"
+  ];
+  for (const name of candidates) {
+    if (existsSync13(join15(repoPath, name)))
+      return name;
+  }
+  return null;
+}
+function extractTestGlobPatterns(configPath, repoPath) {
+  if (!configPath) {
+    return ["**/*.spec.ts", "**/*.spec.js", "**/*.test.ts", "**/*.test.js", "**/e2e/**/*.ts", "**/e2e/**/*.js", "**/tests/**/*.ts", "**/tests/**/*.js"];
+  }
+  const fullPath = join15(repoPath, configPath);
+  let content;
+  try {
+    content = readFileSync5(fullPath, "utf-8");
+  } catch {
+    return ["**/*.spec.ts", "**/*.test.ts"];
+  }
+  const patterns = [];
+  const testDirMatch = content.match(/testDir\s*[:=]\s*['"`]([^'"`]+)['"`]/);
+  const testDir = testDirMatch?.[1];
+  const testMatchArray = content.match(/testMatch\s*[:=]\s*\[([^\]]+)\]/);
+  if (testMatchArray) {
+    const items = testMatchArray[1].match(/['"`]([^'"`]+)['"`]/g);
+    if (items) {
+      for (const item of items) {
+        patterns.push(item.replace(/['"`]/g, ""));
+      }
+    }
+  }
+  const testMatchSingle = content.match(/testMatch\s*[:=]\s*['"`]([^'"`]+)['"`]/);
+  if (testMatchSingle) {
+    patterns.push(testMatchSingle[1]);
+  }
+  if (testDir && patterns.length === 0) {
+    patterns.push(`${testDir}/**/*.spec.ts`, `${testDir}/**/*.test.ts`, `${testDir}/**/*.spec.js`, `${testDir}/**/*.test.js`);
+  }
+  if (patterns.length === 0) {
+    patterns.push("**/*.spec.ts", "**/*.test.ts", "**/*.spec.js", "**/*.test.js");
+  }
+  return patterns;
+}
+function approximateTestCount(filePath) {
+  let content;
+  try {
+    content = readFileSync5(filePath, "utf-8");
+  } catch {
+    return 0;
+  }
+  const testCalls = (content.match(/(?:^|\n)\s*(?:test|it)\(/gm) || []).length;
+  return testCalls || 0;
+}
+function findSpecFiles(repoPath, globPatterns) {
+  const specs = [];
+  const seen = new Set;
+  for (const pattern of globPatterns) {
+    const dirsToSearch = ["", ".", "tests", "e2e", "test", "__tests__", "specs", "src"];
+    for (const dir of dirsToSearch) {
+      const searchDir = dir ? join15(repoPath, dir) : repoPath;
+      if (!existsSync13(searchDir))
+        continue;
+      try {
+        const files = walkDir(searchDir);
+        for (const file of files) {
+          const relativePath = relative2(repoPath, file);
+          if (seen.has(relativePath))
+            continue;
+          if (matchesGlob(relativePath, pattern)) {
+            seen.add(relativePath);
+            const content = readFileSync5(file, "utf-8");
+            const contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+            const stat = statSync(file);
+            specs.push({
+              file: relativePath,
+              fromGlob: pattern,
+              testCount: approximateTestCount(file),
+              mtimeMs: stat.mtimeMs,
+              contentHash
+            });
+          }
+        }
+      } catch {}
+    }
+  }
+  specs.sort((a, b) => a.file.localeCompare(b.file));
+  return specs;
+}
+function walkDir(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join15(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git")
+          continue;
+        results.push(...walkDir(fullPath));
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  } catch {}
+  return results;
+}
+function matchesGlob(filePath, pattern) {
+  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "(.+/)?").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  regex = "^" + regex + "$";
+  return new RegExp(regex).test(filePath);
+}
+function detectSuggestedUrl(repoPath) {
+  const pkgPath = join15(repoPath, "package.json");
+  if (!existsSync13(pkgPath))
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if ("next" in deps)
+      return "http://localhost:3000";
+    if ("vite" in deps)
+      return "http://localhost:5173";
+    if (Object.keys(deps).some((d) => d.startsWith("@remix-run")))
+      return "http://localhost:3000";
+    if ("nuxt" in deps)
+      return "http://localhost:3000";
+    if (Object.keys(deps).some((d) => d.startsWith("@angular")))
+      return "http://localhost:4200";
+  } catch {}
+  return null;
+}
+function checkPlaywrightBrowserInstalled(repoPath) {
+  const cacheDir = join15(repoPath, "node_modules", ".cache", "ms-playwright");
+  if (existsSync13(cacheDir))
+    return true;
+  const globalCache = join15(repoPath, ".cache", "ms-playwright");
+  if (existsSync13(globalCache))
+    return true;
+  return false;
+}
+function getInstallCommand(pm) {
+  switch (pm.preferred) {
+    case "npm":
+      return "npm install";
+    case "yarn":
+      return "yarn install";
+    case "pnpm":
+      return "pnpm install";
+    case "bun":
+      return "bun install";
+  }
+}
+function getPlaywrightInstallCommand(pm) {
+  return "npx playwright install";
+}
+function discoverRepo(opts) {
+  const repoPath = resolve2(opts.repoPath);
+  if (!opts.refresh) {
+    const cached = loadCache(repoPath);
+    if (cached && !isCacheStale(cached, repoPath)) {
+      return cached;
+    }
+  }
+  const configPath = findPlaywrightConfig(repoPath);
+  let configRaw = null;
+  if (configPath) {
+    try {
+      configRaw = readFileSync5(join15(repoPath, configPath), "utf-8");
+    } catch {
+      configRaw = null;
+    }
+  }
+  const globPatterns = extractTestGlobPatterns(configPath, repoPath);
+  const specs = findSpecFiles(repoPath, globPatterns);
+  const packageManager = detectPackageManager(repoPath);
+  const devScripts = detectDevScripts(repoPath);
+  const playwrightInstalled = existsSync13(join15(repoPath, "node_modules", "playwright")) || existsSync13(join15(repoPath, "node_modules", "@playwright", "test"));
+  const browsersInstalled = checkPlaywrightBrowserInstalled(repoPath);
+  const configExists = configPath !== null;
+  const specsFound = specs.length > 0;
+  const issues = [];
+  if (!configExists)
+    issues.push("No Playwright config file found");
+  if (!playwrightInstalled)
+    issues.push("Playwright is not installed (node_modules/playwright missing)");
+  if (!browsersInstalled)
+    issues.push("Playwright browsers not installed (run `npx playwright install`)");
+  if (!specsFound)
+    issues.push("No spec files found");
+  const ready = issues.length === 0;
+  const runPm = (script) => {
+    const name = script.split(" ")[0];
+    const pm = packageManager.preferred;
+    if (pm === "npm")
+      return `npm run ${name}`;
+    return `${pm} run ${name}`;
+  };
+  const prep = {
+    installCmd: playwrightInstalled ? null : getInstallCommand(packageManager),
+    installBrowsersCmd: browsersInstalled ? null : getPlaywrightInstallCommand(packageManager),
+    startDevCmd: devScripts.dev ? runPm(devScripts.dev) : null,
+    buildCmd: devScripts.build ? runPm(devScripts.build) : null,
+    seedCmd: devScripts.seed ? runPm(devScripts.seed) : null
+  };
+  const suggestedUrl = opts.baseUrl ?? detectSuggestedUrl(repoPath);
+  const workingDir = opts.workingDir ?? repoPath;
+  const specHashes = specs.map((s) => s.contentHash).join(",");
+  const cacheKey = createHash("sha256").update(`${repoPath}:${specHashes}:${configRaw ?? ""}`).digest("hex").slice(0, 16);
+  const snapshot = {
+    repoPath,
+    configPath,
+    configRaw,
+    specs,
+    totalTests: specs.reduce((sum, s) => sum + s.testCount, 0),
+    packageManager,
+    devScripts,
+    readiness: {
+      playwrightInstalled,
+      browsersInstalled,
+      configExists,
+      specsFound,
+      ready,
+      issues
+    },
+    prep,
+    suggestedUrl,
+    workingDir,
+    snapshotAt: new Date().toISOString(),
+    cacheKey
+  };
+  saveCache(snapshot);
+  return snapshot;
+}
+function clearDiscoveryCache(repoPath) {
+  const cacheDir = getCacheDir();
+  if (!existsSync13(cacheDir))
+    return;
+  if (repoPath) {
+    const cachePath = getCachePath(repoPath);
+    if (existsSync13(cachePath)) {
+      unlinkSync(cachePath);
+    }
+  } else {
+    for (const file of readdirSync3(cacheDir)) {
+      if (file.endsWith(".json")) {
+        unlinkSync(join15(cacheDir, file));
+      }
+    }
+  }
+}
+function getDiscoveryCacheInfo(repoPath) {
+  const cachePath = getCachePath(repoPath);
+  if (!existsSync13(cachePath))
+    return null;
+  const cached = loadCache(repoPath);
+  if (!cached)
+    return null;
+  return {
+    cached: true,
+    stale: isCacheStale(cached, repoPath),
+    path: cachePath
+  };
+}
+// src/lib/repo-executor.ts
+init_runs();
+init_database();
+init_paths();
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, writeFileSync as writeFileSync5 } from "fs";
+import { join as join16 } from "path";
+function resolvePlaywrightCmd(repoPath) {
+  const localPw = join16(repoPath, "node_modules", ".bin", "playwright");
+  if (existsSync14(localPw)) {
+    return [localPw, "test"];
+  }
+  return ["npx", "playwright", "test"];
+}
+function buildPlaywrightArgs(specFiles, extraArgs = []) {
+  const args = [];
+  if (specFiles.length > 0) {
+    args.push(...specFiles);
+  }
+  args.push("--reporter", "json");
+  if (extraArgs.length > 0) {
+    args.push(...extraArgs);
+  }
+  return args;
+}
+function runPlaywright(repoPath, workingDir, specFiles, extraArgs, timeoutMs) {
+  const cmd = resolvePlaywrightCmd(repoPath);
+  const args = buildPlaywrightArgs(specFiles, extraArgs, workingDir);
+  const startTime = Date.now();
+  try {
+    const result = execSync2(`${cmd.join(" ")} ${args.join(" ")}`, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      maxBuffer: 50 * 1024 * 1024,
+      env: { ...process.env, CI: "1" }
+    }).toString();
+    return {
+      exitCode: 0,
+      stdout: result,
+      stderr: "",
+      durationMs: Date.now() - startTime
+    };
+  } catch (err) {
+    const stdout = err.stdout?.toString() ?? "";
+    const stderr = err.stderr?.toString() ?? "";
+    const exitCode = err.status ?? err.code ?? -1;
+    return {
+      exitCode: typeof exitCode === "number" ? exitCode : -1,
+      stdout,
+      stderr,
+      durationMs: Date.now() - startTime
+    };
+  }
+}
+function parsePlaywrightJsonOutput(stdout, stderr) {
+  const testResults = [];
+  try {
+    const obj = JSON.parse(stdout);
+    if (obj.suites) {
+      for (const suite of obj.suites) {
+        collectTestsFromSuite(suite, testResults);
+      }
+    }
+    if (obj.tests && Array.isArray(obj.tests)) {
+      for (const test of obj.tests) {
+        testResults.push({
+          name: test.title || test.name || "unknown test",
+          status: test.outcome === "expected" ? "passed" : test.outcome === "skipped" ? "skipped" : "failed"
+        });
+      }
+    }
+  } catch {
+    const lines = stdout.split(`
+`);
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.suites) {
+          for (const suite of obj.suites) {
+            collectTestsFromSuite(suite, testResults);
+          }
+        }
+        if (obj.tests && Array.isArray(obj.tests)) {
+          for (const test of obj.tests) {
+            testResults.push({
+              name: test.title || test.name || "unknown test",
+              status: test.outcome === "expected" ? "passed" : test.outcome === "skipped" ? "skipped" : "failed"
+            });
+          }
+        }
+      } catch {}
+    }
+  }
+  if (testResults.length === 0) {
+    const passed = (stdout.match(/\u2713/g) || []).length;
+    const failed = (stdout.match(/\u2717/g) || []).length;
+    if (passed > 0 || failed > 0) {
+      testResults.push({ name: `${passed} passed, ${failed} failed`, status: failed > 0 ? "failed" : "passed" });
+    } else {
+      testResults.push({ name: "suite", status: stdout.includes("Error") ? "failed" : "passed" });
+    }
+  }
+  return testResults;
+}
+function collectTestsFromSuite(suite, results) {
+  if (suite.specs) {
+    for (const spec of suite.specs) {
+      const title = spec.title || spec.name || "unknown test";
+      if (spec.tests && Array.isArray(spec.tests)) {
+        for (const t of spec.tests) {
+          results.push({
+            name: title,
+            status: t.outcome === "expected" ? "passed" : t.outcome === "skipped" ? "skipped" : "failed"
+          });
+        }
+      }
+    }
+  }
+  if (suite.suites) {
+    for (const sub of suite.suites) {
+      collectTestsFromSuite(sub, results);
+    }
+  }
+}
+function determineSpecStatus(exitCode, testResults) {
+  if (exitCode === null)
+    return "error";
+  if (exitCode === 0)
+    return "passed";
+  if (testResults.length > 0 && testResults.every((t) => t.status === "passed"))
+    return "passed";
+  if (exitCode > 128)
+    return "error";
+  return "failed";
+}
+function runSingleSpec(repoPath, workingDir, spec, extraArgs, timeoutMs) {
+  const result = runPlaywright(repoPath, workingDir, [spec.file], extraArgs, timeoutMs);
+  const testResults = parsePlaywrightJsonOutput(result.stdout, result.stderr);
+  const status = determineSpecStatus(result.exitCode, testResults);
+  return {
+    specFile: spec.file,
+    status,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    durationMs: result.durationMs,
+    testResults,
+    error: result.exitCode !== 0 && result.stderr ? result.stderr.slice(0, 2000) : undefined
+  };
+}
+async function runRepoTests(opts) {
+  const { snapshot } = opts;
+  const specFiles = opts.specFiles ?? snapshot.specs.map((s) => s.file);
+  const timeout = opts.timeout ?? 300000;
+  const workingDir = opts.snapshot.workingDir;
+  const repoPath = snapshot.repoPath;
+  const url = opts.url ?? snapshot.suggestedUrl ?? "http://localhost:3000";
+  const run = createRun({
+    projectId: opts.projectId,
+    url,
+    model: opts.model ?? "repo-native",
+    headed: false,
+    parallel: 1,
+    metadata: {
+      runType: "repo-native",
+      repoPath,
+      configPath: snapshot.configPath,
+      cacheKey: snapshot.cacheKey,
+      label: opts.label
+    }
+  });
+  const specResults = [];
+  const startTime = Date.now();
+  for (const specFile of specFiles) {
+    const spec = snapshot.specs.find((s) => s.file === specFile);
+    if (!spec)
+      continue;
+    const result = runSingleSpec(repoPath, workingDir, spec, opts.extraArgs ?? [], timeout);
+    specResults.push(result);
+    const resultId = uuid();
+    const timestamp = now();
+    const db2 = getDatabase();
+    db2.exec("PRAGMA foreign_keys = OFF");
+    try {
+      const reasoning = result.status === "passed" ? "All tests passed" : (result.error ?? "").slice(0, 500) || null;
+      const errorStr = result.status !== "passed" ? result.error ?? null : null;
+      db2.query(`
+        INSERT INTO results (id, run_id, scenario_id, status, reasoning, error, steps_completed, steps_total, duration_ms, model, tokens_used, cost_cents, metadata, created_at, persona_id, persona_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, NULL, NULL)
+      `).run(resultId, run.id, "__repo__", result.status, reasoning, errorStr, result.testResults.filter((t) => t.status === "passed").length, result.testResults.length || 1, result.durationMs, "repo-native", JSON.stringify({
+        specFile: result.specFile,
+        exitCode: result.exitCode,
+        testResults: result.testResults
+      }), timestamp);
+    } finally {
+      db2.exec("PRAGMA foreign_keys = ON");
+    }
+    const resultRecord = { id: resultId };
+    if (result.stdout || result.stderr) {
+      const reportersDir = join16(getTestersDir(), "repo-run-output");
+      mkdirSync11(reportersDir, { recursive: true });
+      const outputFile = join16(reportersDir, `${resultRecord.id}.log`);
+      writeFileSync5(outputFile, `=== stdout ===
+${result.stdout}
+
+=== stderr ===
+${result.stderr}
+`);
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  const passed = specResults.filter((r) => r.status === "passed").length;
+  const failed = specResults.filter((r) => r.status === "failed").length;
+  const skipped = specResults.filter((r) => r.status === "skipped").length;
+  const errored = specResults.filter((r) => r.status === "error").length;
+  const status = failed > 0 || errored > 0 ? "failed" : "passed";
+  const runMeta = run.metadata ?? {};
+  updateRun(run.id, {
+    status,
+    total: specResults.length,
+    passed,
+    failed: failed + errored,
+    metadata: JSON.stringify({
+      ...runMeta,
+      specResults: specResults.map((r) => ({
+        specFile: r.specFile,
+        status: r.status,
+        exitCode: r.exitCode,
+        testCount: r.testResults.length,
+        durationMs: r.durationMs
+      }))
+    })
+  });
+  return {
+    runId: run.id,
+    specResults,
+    total: specResults.length,
+    passed,
+    failed,
+    skipped,
+    errored,
+    durationMs,
+    status
+  };
+}
+function runPrep(snapshot, steps) {
+  const { prep } = snapshot;
+  const results = [];
+  for (const step of steps) {
+    let cmd = null;
+    switch (step) {
+      case "install":
+        cmd = prep.installCmd;
+        break;
+      case "browsers":
+        cmd = prep.installBrowsersCmd;
+        break;
+      case "dev":
+        cmd = prep.startDevCmd;
+        break;
+      case "build":
+        cmd = prep.buildCmd;
+        break;
+      case "seed":
+        cmd = prep.seedCmd;
+        break;
+    }
+    if (!cmd) {
+      results.push({ cmd: step, success: true, output: "Not needed (already satisfied)", durationMs: 0 });
+      continue;
+    }
+    const startTime = Date.now();
+    try {
+      const output = execSync2(cmd, {
+        cwd: snapshot.workingDir,
+        encoding: "utf-8",
+        timeout: 120000,
+        maxBuffer: 50 * 1024 * 1024,
+        env: { ...processSyncEnv() }
+      });
+      results.push({
+        cmd,
+        success: true,
+        output: output.slice(0, 1000),
+        durationMs: Date.now() - startTime
+      });
+    } catch (err) {
+      const stdout = err.stdout?.toString() ?? "";
+      const stderr = err.stderr?.toString() ?? "";
+      results.push({
+        cmd,
+        success: false,
+        output: (stderr || stdout).slice(0, 1000),
+        durationMs: Date.now() - startTime
+      });
+    }
+  }
+  return {
+    steps: results,
+    allSucceeded: results.every((r) => r.success)
+  };
+}
+function processSyncEnv() {
+  return { ...process.env, CI: "1", FORCE_COLOR: "0" };
+}
 // src/lib/prod-debug.ts
 var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/i;
 var SENSITIVE_PARAM_RE = /token|secret|key|password|code|state|cookie|session|grant|credential|auth|jwt|access/i;
@@ -17869,6 +19119,68 @@ async function postGitHubComment(run, results, options) {
     return false;
   }
 }
+// src/db/sessions.ts
+init_database();
+function createSession(input) {
+  const db2 = getDatabase();
+  const id = input.sessionId ?? uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO sessions (id, tab_id, url, title, entries, entry_count, error_count, console_count, nav_count, status, start_time, end_time, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.tabId, input.url ?? null, input.title ?? null, input.entries, input.entryCount, input.errorCount ?? 0, input.consoleCount ?? 0, input.navCount ?? 0, input.status, input.startTime, input.endTime ?? null, timestamp);
+  return getSession(id);
+}
+function getSession(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  if (row)
+    return sessionFromRow(row);
+  const fullId = resolvePartialId("sessions", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM sessions WHERE id = ?").get(fullId);
+    if (row)
+      return sessionFromRow(row);
+  }
+  return null;
+}
+function listSessions(limit = 50, offset = 0) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM sessions ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  return rows.map(sessionFromRow);
+}
+function deleteSession(id) {
+  const db2 = getDatabase();
+  const result = db2.query("DELETE FROM sessions WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+function searchSessions(query, limit = 20) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM sessions WHERE url LIKE ? OR title LIKE ? ORDER BY created_at DESC LIMIT ?").all(`%${query}%`, `%${query}%`, limit);
+  return rows.map(sessionFromRow);
+}
+function countSessions() {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT COUNT(*) as count FROM sessions").get();
+  return row.count;
+}
+function sessionFromRow(row) {
+  return {
+    id: row.id,
+    tabId: row.tab_id,
+    url: row.url,
+    title: row.title,
+    entries: JSON.parse(row.entries),
+    entryCount: row.entry_count,
+    errorCount: row.error_count,
+    consoleCount: row.console_count,
+    navCount: row.nav_count,
+    status: row.status,
+    startTime: row.start_time,
+    endTime: row.end_time,
+    createdAt: row.created_at
+  };
+}
 export {
   writeScenarioMeta,
   writeRunMeta,
@@ -17886,11 +19198,14 @@ export {
   slugify,
   shouldRunAt,
   shortUuid,
+  searchSessions,
   screenshotFromRow,
   scheduleFromRow,
   scenarioFromRow,
   runSmoke,
   runSingleScenario,
+  runRepoTests,
+  runPrep,
   runFromRow,
   runByFilter,
   runBatch,
@@ -17919,6 +19234,7 @@ export {
   loadConfig,
   listWebhooks,
   listTemplateNames,
+  listSessions,
   listScreenshots,
   listSchedules,
   listScenarios,
@@ -17941,6 +19257,7 @@ export {
   getTransitiveDependencies,
   getTemplate,
   getStarterScenarios,
+  getSession,
   getScreenshotsByResult,
   getScreenshotDir,
   getScreenshot,
@@ -17958,6 +19275,7 @@ export {
   getFlow,
   getExitCode,
   getEnabledSchedules,
+  getDiscoveryCacheInfo,
   getDependents,
   getDependencies,
   getDefaultConfig,
@@ -17989,15 +19307,18 @@ export {
   ensurePersonaAuthenticated,
   ensureDir,
   dispatchWebhooks,
+  discoverRepo,
   diffRuns,
   detectFramework,
   deleteWebhook,
+  deleteSession,
   deleteSchedule,
   deleteScenario,
   deleteRun,
   deleteFlow,
   deleteAuthPreset,
   createWebhook,
+  createSession,
   createScreenshot,
   createSchedule,
   createScenario,
@@ -18008,10 +19329,12 @@ export {
   createFlow,
   createClient,
   createAuthPreset,
+  countSessions,
   connectToTodos,
   closeLightpanda,
   closeDatabase,
   closeBrowser,
+  clearDiscoveryCache,
   checkBudget,
   agentFromRow,
   addDependency,