@bbearai/ai-executor 0.2.0 → 0.2.1

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,22 +30,299 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/report-generator.ts
+var report_generator_exports = {};
+__export(report_generator_exports, {
+  generateExplorationReport: () => generateExplorationReport
+});
+async function generateExplorationReport(anthropic, input) {
+  const { projectName, featureDescription, targetUrl, actions, model } = input;
+  const findings = actions.filter((a) => a.category !== "normal");
+  const passed = actions.filter((a) => a.category === "normal");
+  const actionableFindings = findings.map((f) => ({
+    title: buildFindingTitle(f),
+    category: f.category,
+    severity: f.severity || "medium",
+    confidence: f.confidence,
+    networkRequests: f.networkRequests,
+    consoleErrors: f.consoleLogs.filter((l) => l.level === "error"),
+    domContext: f.domContext,
+    url: targetUrl,
+    route: extractRoute(targetUrl),
+    reproSteps: buildReproSteps(actions, f.actionNumber),
+    screenshotUrl: "",
+    // Filled in by API route after upload
+    actionPerformed: f.action,
+    expectedBehavior: "Normal application behavior",
+    actualBehavior: f.description
+  }));
+  const tested = passed.map((a) => ({
+    description: a.action,
+    route: extractRoute(targetUrl),
+    status: "passed"
+  }));
+  const notTested = detectUntestable(actions);
+  const summaryResponse = await anthropic.messages.create({
+    model,
+    max_tokens: 500,
+    messages: [
+      {
+        role: "user",
+        content: `Summarize this exploratory QA session in 2-3 sentences.
+
+Feature tested: "${featureDescription}"
+URL: ${targetUrl}
+Actions performed: ${actions.length}
+Findings: ${findings.length} (${findings.filter((f) => f.severity === "critical" || f.severity === "high").length} high/critical)
+Passed checks: ${passed.length}
+
+Finding details:
+${findings.map((f) => `- [${f.severity?.toUpperCase()}] ${f.category}: ${f.description}`).join("\n")}
+
+Be concise and factual. Focus on what was tested and the most important findings.`
+      }
+    ]
+  });
+  const summary = summaryResponse.content[0].type === "text" ? summaryResponse.content[0].text : "Exploration complete.";
+  const suggestedPrompt = buildSuggestedPrompt(
+    featureDescription,
+    actionableFindings,
+    tested,
+    notTested
+  );
+  const totalDuration = actions.reduce((sum, a) => sum + a.durationMs, 0);
+  return {
+    report: {
+      projectName,
+      featureDescription,
+      targetUrl,
+      exploredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: `${Math.round(totalDuration / 1e3)}s`,
+      actionsUsed: actions.length,
+      actionBudget: actions.length,
+      findings: actionableFindings,
+      tested,
+      notTested,
+      summary,
+      suggestedPrompt
+    },
+    tokenUsage: {
+      inputTokens: summaryResponse.usage.input_tokens,
+      outputTokens: summaryResponse.usage.output_tokens
+    }
+  };
+}
+function buildFindingTitle(action) {
+  const prefix = {
+    console_error: "JS Error",
+    broken_interaction: "Broken",
+    visual_anomaly: "Visual",
+    input_handling: "Validation",
+    normal: ""
+  };
+  return `${prefix[action.category] || action.category}: ${action.description.slice(0, 80)}`;
+}
+function extractRoute(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function buildReproSteps(allActions, targetActionNumber) {
+  return allActions.filter((a) => a.actionNumber <= targetActionNumber).map((a) => `${a.actionNumber}. ${a.action}`);
+}
+function detectUntestable(actions) {
+  const untestable = [];
+  const allText = actions.map((a) => `${a.action} ${a.description}`).join(" ").toLowerCase();
+  if (allText.includes("file upload") || allText.includes("drag and drop")) {
+    untestable.push({
+      description: "File upload functionality",
+      reason: "AI cannot interact with OS file dialogs"
+    });
+  }
+  if (allText.includes("captcha") || allText.includes("recaptcha")) {
+    untestable.push({
+      description: "CAPTCHA verification",
+      reason: "AI cannot solve CAPTCHAs"
+    });
+  }
+  if (allText.includes("disabled") || allText.includes("permission")) {
+    untestable.push({
+      description: "Permission-gated features",
+      reason: "Current auth may not have required permissions"
+    });
+  }
+  return untestable;
+}
+function buildSuggestedPrompt(featureDescription, findings, tested, notTested) {
+  if (findings.length === 0) {
+    return `Exploratory QA tested "${featureDescription}" with ${tested.length} interactions \u2014 no issues found.`;
+  }
+  let prompt = `Fix these ${findings.length} issue(s) found during exploratory QA testing of "${featureDescription}":
+
+`;
+  findings.forEach((f, i) => {
+    prompt += `${i + 1}. [${f.severity.toUpperCase()}] ${f.title}
+`;
+    if (f.consoleErrors.length > 0) {
+      prompt += `   Console: ${f.consoleErrors[0].text}
+`;
+      if (f.consoleErrors[0].source) {
+        prompt += `   Source: ${f.consoleErrors[0].source}
+`;
+      }
+    }
+    if (f.networkRequests.some((r) => r.status >= 400)) {
+      const failed = f.networkRequests.find((r) => r.status >= 400);
+      if (failed) {
+        prompt += `   API: ${failed.method} ${failed.url} \u2192 ${failed.status}
+`;
+        if (failed.responseBody) {
+          prompt += `   Response: ${failed.responseBody.slice(0, 200)}
+`;
+        }
+      }
+    }
+    if (f.domContext?.selector) {
+      prompt += `   Element: ${f.domContext.selector}
+`;
+    }
+    prompt += `   Route: ${f.route}
+`;
+    prompt += `   Repro: ${f.reproSteps.join(" \u2192 ")}
+
+`;
+  });
+  if (notTested.length > 0) {
+    prompt += `Not tested (requires manual review):
+`;
+    notTested.forEach((n) => {
+      prompt += `- ${n.description}: ${n.reason}
+`;
+    });
+  }
+  return prompt.trim();
+}
+var init_report_generator = __esm({
+  "src/report-generator.ts"() {
+    "use strict";
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Semaphore: () => Semaphore,
+  analyzeFailure: () => analyzeFailure,
+  authenticateSupabase: () => authenticateSupabase,
   createStagehandSession: () => createStagehandSession,
+  discoverSelector: () => discoverSelector,
+  estimateBatchCost: () => estimateBatchCost,
+  estimateCost: () => estimateCost,
+  estimateTestCost: () => estimateTestCost,
+  evaluateStep: () => evaluateStep,
+  executeAction: () => executeAction,
+  generateExplorationReport: () => generateExplorationReport,
   generateRunSummary: () => generateRunSummary,
+  getTokenEstimate: () => getTokenEstimate,
   injectAuth: () => injectAuth,
-  runTest: () => runTest
+  injectSupabaseAuth: () => injectSupabaseAuth,
+  installClickTracker: () => installClickTracker,
+  performSupabaseAuth: () => performSupabaseAuth,
+  rollupFailureClassification: () => rollupFailureClassification,
+  runExploration: () => runExploration,
+  runTest: () => runTest,
+  suppressBugBearWidget: () => suppressBugBearWidget,
+  triageReport: () => triageReport,
+  verifySupabaseSession: () => verifySupabaseSession
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/runner.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_zod = require("zod");
 
 // src/browser.ts
 var import_stagehand = require("@browserbasehq/stagehand");
+
+// src/supabase-auth.ts
+function extractProjectRef(supabaseUrl) {
+  const url = new URL(supabaseUrl);
+  const hostname = url.hostname;
+  const ref = hostname.split(".")[0];
+  return ref;
+}
+async function authenticateSupabase(auth) {
+  const url = `${auth.supabaseUrl.replace(/\/$/, "")}/auth/v1/token?grant_type=password`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "apikey": auth.anonKey
+    },
+    body: JSON.stringify({
+      email: auth.email,
+      password: auth.password
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `Supabase auth failed (${response.status}): ${body.slice(0, 200)}`
+    );
+  }
+  const session = await response.json();
+  if (!session.access_token) {
+    throw new Error("Supabase auth returned no access_token");
+  }
+  return session;
+}
+async function injectSupabaseAuth(page, auth, session) {
+  const ref = extractProjectRef(auth.supabaseUrl);
+  const storageKey = `sb-${ref}-auth-token`;
+  const storageValue = JSON.stringify({
+    access_token: session.access_token,
+    refresh_token: session.refresh_token,
+    expires_in: session.expires_in,
+    expires_at: session.expires_at,
+    token_type: session.token_type,
+    user: session.user
+  });
+  const currentUrl = page.url();
+  if (currentUrl === "about:blank" || !currentUrl) {
+    await page.goto(auth.supabaseUrl.replace(/\/$/, ""), {
+      waitUntil: "domcontentloaded",
+      timeoutMs: 1e4
+    }).catch(() => {
+    });
+  }
+  await page.evaluate(
+    ({ key, value }) => {
+      localStorage.setItem(key, value);
+    },
+    { key: storageKey, value: storageValue }
+  );
+}
+async function verifySupabaseSession(auth, accessToken) {
+  const url = `${auth.supabaseUrl.replace(/\/$/, "")}/auth/v1/user`;
+  const response = await fetch(url, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "apikey": auth.anonKey
+    }
+  });
+  return response.ok;
+}
+async function performSupabaseAuth(page, auth) {
+  const session = await authenticateSupabase(auth);
+  await injectSupabaseAuth(page, auth, session);
+  const valid = await verifySupabaseSession(auth, session.access_token);
+  if (!valid) {
+    throw new Error("Supabase auth verification failed \u2014 session token rejected");
+  }
+}
+
+// src/browser.ts
 var DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514";
 async function createStagehandSession(config, anthropicApiKey) {
   const modelName = config.model ?? DEFAULT_MODEL;
@@ -55,6 +335,11 @@ async function createStagehandSession(config, anthropicApiKey) {
       modelName,
       apiKey: anthropicApiKey
     },
+    // Bypass pino logger — its pino-pretty transport uses worker threads
+    // which fail in Vercel's serverless environment
+    logger: (msg) => {
+      if ((msg.level ?? 0) >= 40) console.warn("[Stagehand]", msg.message);
+    },
     localBrowserLaunchOptions: config.provider === "local" ? {
       headless: config.headless ?? true,
       viewport
@@ -78,6 +363,21 @@ async function createStagehandSession(config, anthropicApiKey) {
     }
   };
 }
+async function suppressBugBearWidget(stagehand) {
+  try {
+    const ctx = stagehand.context;
+    if (ctx?.addInitScript) {
+      await ctx.addInitScript(() => {
+        window.__bugbear_suppress = true;
+        try {
+          localStorage.setItem("__bugbear_suppress", "true");
+        } catch {
+        }
+      });
+    }
+  } catch {
+  }
+}
 async function injectAuth(page, auth, stagehand) {
   if (auth.type === "cookie") {
     for (const c of auth.cookies) {
@@ -103,23 +403,123 @@ async function injectAuth(page, auth, stagehand) {
     }, auth.items);
   } else if (auth.type === "form-login") {
     await performFormLogin(page, auth, stagehand);
+  } else if (auth.type === "supabase-native") {
+    await performSupabaseAuth(page, auth);
   }
 }
+function createNetworkCapture(page) {
+  const requests = [];
+  const errors = [];
+  let active = false;
+  let startTimestamp = Date.now();
+  const onResponse = async (response) => {
+    if (!active) return;
+    const req = response.request();
+    const resourceType = typeof req.resourceType === "function" ? req.resourceType() : req.resourceType;
+    if (["image", "stylesheet", "font", "media"].includes(resourceType)) return;
+    const entry = {
+      method: typeof req.method === "function" ? req.method() : String(req.method),
+      url: (typeof response.url === "function" ? response.url() : String(response.url)).slice(0, 500),
+      status: typeof response.status === "function" ? response.status() : Number(response.status),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const status = entry.status;
+    if (status >= 400) {
+      try {
+        const body = await response.text();
+        entry.responseBody = body.slice(0, 500);
+      } catch {
+      }
+      errors.push({
+        method: entry.method,
+        url: entry.url,
+        status,
+        statusText: typeof response.statusText === "function" ? response.statusText() : String(response.statusText ?? ""),
+        timestamp: Date.now() - startTimestamp
+      });
+    }
+    if (["POST", "PUT", "PATCH"].includes(entry.method)) {
+      try {
+        const postData = typeof req.postData === "function" ? req.postData() : req.postData;
+        if (postData) entry.requestBody = String(postData).slice(0, 500);
+      } catch {
+      }
+    }
+    requests.push(entry);
+  };
+  const onRequestFailed = (req) => {
+    if (!active) return;
+    const url = typeof req.url === "function" ? req.url() : String(req.url ?? "");
+    const method = typeof req.method === "function" ? req.method() : String(req.method ?? "GET");
+    const failure = typeof req.failure === "function" ? req.failure() : req.failure;
+    errors.push({
+      method,
+      url: url.slice(0, 500),
+      status: 0,
+      statusText: failure?.errorText ?? "Request failed",
+      timestamp: Date.now() - startTimestamp
+    });
+  };
+  const rawPage = page;
+  let responseSupported = true;
+  let requestFailedSupported = true;
+  return {
+    start() {
+      active = true;
+      requests.length = 0;
+      errors.length = 0;
+      startTimestamp = Date.now();
+      if (responseSupported) {
+        try {
+          rawPage.on("response", onResponse);
+        } catch {
+          responseSupported = false;
+        }
+      }
+      if (requestFailedSupported) {
+        try {
+          rawPage.on("requestfailed", onRequestFailed);
+        } catch {
+          requestFailedSupported = false;
+        }
+      }
+    },
+    stop() {
+      active = false;
+      if (responseSupported) {
+        try {
+          rawPage.off("response", onResponse);
+        } catch {
+        }
+      }
+      if (requestFailedSupported) {
+        try {
+          rawPage.off("requestfailed", onRequestFailed);
+        } catch {
+        }
+      }
+    },
+    getRequests: () => [...requests],
+    getErrors: () => [...errors]
+  };
+}
 async function performFormLogin(page, auth, stagehand) {
   await page.goto(auth.loginUrl, { waitUntil: "domcontentloaded" });
   await page.waitForLoadState("networkidle", 15e3).catch(() => {
   });
+  await fillLoginCredentials(page, auth);
   if (stagehand) {
     await stagehand.act(
-      `Fill in the email/username field with "${auth.email}" and the password field with "${auth.password}", then click the login/sign-in button to submit the form.`
-    );
+      "Click the login, sign-in, or submit button to submit the form."
+    ).catch(() => {
+    });
   } else {
-    await manualFormLogin(page, auth);
+    await clickSubmitButton(page);
   }
   await page.waitForLoadState("networkidle", 15e3).catch(() => {
   });
 }
-async function manualFormLogin(page, auth) {
+async function fillLoginCredentials(page, auth) {
   await page.waitForSelector(
     'input[type="email"], input[type="text"][name*="email"], input[name*="user"], input[type="text"]',
     { timeout: 15e3 }
@@ -153,6 +553,8 @@ async function manualFormLogin(page, auth) {
   } else {
     throw new Error("Could not find password input on login page");
   }
+}
+async function clickSubmitButton(page) {
   const submitSelectors = [
     'button[type="submit"]',
     'input[type="submit"]'
@@ -177,21 +579,23 @@ async function generateRunSummary(anthropic, testTitle, steps, model) {
     (s) => `Step ${s.stepNumber}: ${s.action}
   Expected: ${s.expectedResult}
   Actual: ${s.actualResult}
-  Result: ${s.passed ? "PASS" : "FAIL"} (confidence: ${Math.round(s.confidence * 100)}%)${s.error ? `
+  Result: ${s.skipped ? "SKIPPED" : s.passed ? "PASS" : "FAIL"} (confidence: ${Math.round(s.confidence * 100)}%)${s.error ? `
   Error: ${s.error}` : ""}`
   ).join("\n\n");
-  const passCount = steps.filter((s) => s.passed).length;
-  const failCount = steps.filter((s) => !s.passed).length;
+  const passCount = steps.filter((s) => s.passed && !s.skipped).length;
+  const failCount = steps.filter((s) => !s.passed && !s.skipped).length;
+  const skipCount = steps.filter((s) => s.skipped).length;
+  const skipNote = skipCount > 0 ? " Some steps were skipped due to page state recovery \u2014 these are not failures, just steps that could not be executed." : "";
   const response = await anthropic.messages.create({
     model,
     max_tokens: 512,
     messages: [
       {
         role: "user",
-        content: `Summarize this AI test execution in 2-3 sentences. Focus on what was tested, what passed, and what failed (if anything). Be concise and factual.
+        content: `Summarize this AI test execution in 2-3 sentences. Focus on what was tested, what passed, and what failed (if anything).${skipNote} Be concise and factual.
 
 Test: ${testTitle}
-Results: ${passCount} passed, ${failCount} failed out of ${steps.length} steps
+Results: ${passCount} passed, ${failCount} failed, ${skipCount} skipped out of ${steps.length} steps
 
 ${stepsText}`
       }
@@ -200,7 +604,355 @@ ${stepsText}`
   return response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
 
+// src/vision-evaluator.ts
+var DEFAULT_MODEL2 = "claude-sonnet-4-20250514";
+async function evaluateStep(input) {
+  const model = input.model ?? DEFAULT_MODEL2;
+  const hintClause = input.evaluationHint ? `
+EVALUATION HINT: ${input.evaluationHint}` : "";
+  const response = await input.anthropic.messages.create({
+    model,
+    max_tokens: 512,
+    messages: [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "BEFORE screenshot (page state before the action):"
+          },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: input.screenshotBefore.toString("base64")
+            }
+          },
+          {
+            type: "text",
+            text: "AFTER screenshot (page state after the action):"
+          },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: input.screenshotAfter.toString("base64")
+            }
+          },
+          {
+            type: "text",
+            text: `You are a QA test evaluator. Compare the BEFORE and AFTER screenshots to evaluate this test step.
+
+ACTION PERFORMED: ${input.action}
+EXPECTED RESULT: ${input.expectedResult}${hintClause}
+
+Analyze the visual differences between the two screenshots and determine if the expected result was achieved.
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON):
+{
+  "passed": true/false,
+  "confidence": 0.0-1.0,
+  "actualResult": "Brief description of what actually changed between the screenshots"
+}
+
+Confidence guide:
+- 0.95-1.0: Clearly achieved/not achieved, obvious visual evidence
+- 0.8-0.94: Very likely, strong visual indicators
+- 0.6-0.79: Probable but some ambiguity
+- Below 0.6: Uncertain, hard to tell from screenshots alone`
+          }
+        ]
+      }
+    ]
+  });
+  const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+  return parseEvaluation(text);
+}
+function parseEvaluation(text) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    return validateEvaluation(parsed);
+  } catch {
+    const jsonMatch = text.match(/\{[\s\S]*"passed"[\s\S]*"confidence"[\s\S]*"actualResult"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return validateEvaluation(parsed);
+      } catch {
+      }
+    }
+  }
+  return {
+    passed: false,
+    confidence: 0.3,
+    actualResult: `Vision evaluation returned unparseable response: ${text.slice(0, 200)}`
+  };
+}
+function validateEvaluation(parsed) {
+  return {
+    passed: typeof parsed.passed === "boolean" ? parsed.passed : false,
+    confidence: typeof parsed.confidence === "number" ? Math.max(0, Math.min(1, parsed.confidence)) : 0.5,
+    actualResult: typeof parsed.actualResult === "string" ? parsed.actualResult : "No description provided"
+  };
+}
+
+// src/action-executor.ts
+async function executeAction(page, stagehand, step) {
+  if (step.selector && step.actionType) {
+    try {
+      await executePlaywrightAction(page, step);
+      return { deterministic: true };
+    } catch (err) {
+      const fallbackResult = await executeStagehandAction(stagehand, step);
+      return {
+        deterministic: false,
+        error: fallbackResult.error ? `Playwright failed (${err instanceof Error ? err.message : String(err)}), Stagehand fallback also failed: ${fallbackResult.error}` : void 0
+      };
+    }
+  }
+  return executeStagehandAction(stagehand, step);
+}
+async function executePlaywrightAction(page, step) {
+  const { actionType, selector, value, waitMs } = step;
+  switch (actionType) {
+    case "click": {
+      const locator = page.locator(selector);
+      await locator.click();
+      break;
+    }
+    case "fill": {
+      const locator = page.locator(selector);
+      await locator.fill(value ?? "");
+      break;
+    }
+    case "select": {
+      await page.evaluate(
+        ({ sel, val }) => {
+          const el = document.querySelector(sel);
+          if (!el) throw new Error(`Select element not found: ${sel}`);
+          el.value = val;
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+        },
+        { sel: selector, val: value ?? "" }
+      );
+      break;
+    }
+    case "navigate": {
+      const url = value ?? selector ?? "";
+      if (!url) throw new Error("Navigate action requires a value or selector with the URL");
+      await page.goto(url, { waitUntil: "domcontentloaded", timeoutMs: 15e3 });
+      break;
+    }
+    case "scroll": {
+      await page.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (el) el.scrollIntoView({ behavior: "smooth", block: "center" });
+      }, selector);
+      break;
+    }
+    case "wait": {
+      if (selector) {
+        await page.waitForSelector(selector, { timeout: waitMs ?? 1e4 });
+      } else if (waitMs) {
+        await page.waitForTimeout(waitMs);
+      }
+      break;
+    }
+    case "assert": {
+      break;
+    }
+    default: {
+      throw new Error(`Unknown actionType: ${actionType}`);
+    }
+  }
+  if (waitMs && actionType !== "wait") {
+    await page.waitForTimeout(waitMs);
+  }
+}
+async function executeStagehandAction(stagehand, step) {
+  try {
+    await stagehand.act(step.action);
+    return { deterministic: false };
+  } catch (err) {
+    return {
+      deterministic: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/selector-discovery.ts
+async function discoverSelector(page) {
+  try {
+    const result = await page.evaluate(() => {
+      const el = document.__bbLastClicked ?? document.activeElement;
+      if (!el || el === document.body || el === document.documentElement) return null;
+      const tagName = el.tagName?.toLowerCase() ?? "unknown";
+      const textContent = (el.textContent ?? "").trim().slice(0, 100);
+      let selector = "";
+      let strategy = "css-path";
+      const testId = el.getAttribute("data-testid") ?? el.getAttribute("data-test-id");
+      if (testId) {
+        selector = `[data-testid="${testId}"]`;
+        strategy = "data-testid";
+      } else if (el.id && !/^:r[0-9a-z]+:?$/.test(el.id) && !/^react-/.test(el.id)) {
+        selector = `#${el.id}`;
+        strategy = "id";
+      } else if (el.getAttribute("role")) {
+        const role = el.getAttribute("role");
+        const name = el.getAttribute("aria-label") ?? el.getAttribute("name") ?? "";
+        if (name) {
+          selector = `[role="${role}"][aria-label="${name}"]`;
+          strategy = "role";
+        } else {
+          selector = `[role="${role}"]`;
+          strategy = "role";
+        }
+      } else if (el.getAttribute("aria-label")) {
+        selector = `[aria-label="${el.getAttribute("aria-label")}"]`;
+        strategy = "aria-label";
+      } else {
+        const parts = [];
+        let current = el;
+        while (current && current !== document.body) {
+          let part = current.tagName.toLowerCase();
+          if (current.className && typeof current.className === "string") {
+            const classes = current.className.split(/\s+/).filter(
+              (c) => c && !c.startsWith("_") && c.length < 30
+            );
+            if (classes.length > 0) {
+              part += `.${classes[0]}`;
+            }
+          }
+          parts.unshift(part);
+          current = current.parentElement;
+          if (parts.length >= 4) break;
+        }
+        selector = parts.join(" > ");
+        strategy = "css-path";
+      }
+      let suggestedActionType;
+      if (tagName === "button" || tagName === "a" || el.getAttribute("role") === "button") {
+        suggestedActionType = "click";
+      } else if (tagName === "input" || tagName === "textarea") {
+        const type = el.getAttribute("type") ?? "text";
+        if (type === "checkbox" || type === "radio") {
+          suggestedActionType = "click";
+        } else {
+          suggestedActionType = "fill";
+        }
+      } else if (tagName === "select") {
+        suggestedActionType = "select";
+      }
+      return { selector, strategy, suggestedActionType, tagName, textContent };
+    });
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function installClickTracker(page) {
+  try {
+    await page.evaluate(() => {
+      document.addEventListener("click", (e) => {
+        document.__bbLastClicked = e.target;
+      }, { capture: true });
+    });
+  } catch {
+  }
+}
+
+// src/cost.ts
+var MODEL_PRICING = {
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-haiku-4-20250514": { input: 0.8, output: 4 },
+  "claude-opus-4-20250514": { input: 15, output: 75 },
+  // Aliases
+  "sonnet": { input: 3, output: 15 },
+  "haiku": { input: 0.8, output: 4 },
+  "opus": { input: 15, output: 75 }
+};
+var DEFAULT_MODEL3 = "claude-sonnet-4-20250514";
+var TOKEN_PROFILE = {
+  /** act() — screenshot + DOM context → action decision */
+  actInput: 2e3,
+  actOutput: 200,
+  /** extract() — screenshot + extraction schema → structured result */
+  extractInput: 3e3,
+  extractOutput: 500,
+  /** summary — all step results → narrative summary (once per run) */
+  summaryInput: 2e3,
+  summaryOutput: 500
+};
+function estimateCost(inputTokens, outputTokens, model) {
+  const resolvedModel = model ?? DEFAULT_MODEL3;
+  const pricing = MODEL_PRICING[resolvedModel] ?? MODEL_PRICING[DEFAULT_MODEL3];
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  const totalDollars = inputCost + outputCost;
+  const cents = Math.round(totalDollars * 100 * 100) / 100;
+  return {
+    cents,
+    formatted: `$${totalDollars.toFixed(4)}`,
+    tokens: { inputTokens, outputTokens },
+    model: resolvedModel
+  };
+}
+function estimateTestCost(stepCount, model) {
+  const inputTokens = stepCount * (TOKEN_PROFILE.actInput + TOKEN_PROFILE.extractInput) + TOKEN_PROFILE.summaryInput;
+  const outputTokens = stepCount * (TOKEN_PROFILE.actOutput + TOKEN_PROFILE.extractOutput) + TOKEN_PROFILE.summaryOutput;
+  return estimateCost(inputTokens, outputTokens, model);
+}
+function estimateBatchCost(testCases, model) {
+  let totalInput = 0;
+  let totalOutput = 0;
+  for (const tc of testCases) {
+    totalInput += tc.stepCount * (TOKEN_PROFILE.actInput + TOKEN_PROFILE.extractInput) + TOKEN_PROFILE.summaryInput;
+    totalOutput += tc.stepCount * (TOKEN_PROFILE.actOutput + TOKEN_PROFILE.extractOutput) + TOKEN_PROFILE.summaryOutput;
+  }
+  return estimateCost(totalInput, totalOutput, model);
+}
+function getTokenEstimate(stepCount) {
+  return {
+    inputTokens: stepCount * (TOKEN_PROFILE.actInput + TOKEN_PROFILE.extractInput) + TOKEN_PROFILE.summaryInput,
+    outputTokens: stepCount * (TOKEN_PROFILE.actOutput + TOKEN_PROFILE.extractOutput) + TOKEN_PROFILE.summaryOutput
+  };
+}
+
 // src/runner.ts
+var AI_OPERATION_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_RETRY_DELAY_MS = 2e3;
+function isRetryableError(error) {
+  const patterns = [
+    /timed?\s*out/i,
+    /ECONNREFUSED/i,
+    /ECONNRESET/i,
+    /ENOTFOUND/i,
+    /net::ERR_/i,
+    /navigation failed/i,
+    /page crashed/i,
+    /context was destroyed/i,
+    /target closed/i,
+    /session closed/i,
+    /browser disconnected/i,
+    /execution context/i
+  ];
+  return patterns.some((p) => p.test(error));
+}
+async function withTimeout(promise, timeoutMs, operation) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
 async function runTest(config) {
   const anthropic = new import_sdk.default({ apiKey: config.anthropicApiKey });
   const startTime = Date.now();
@@ -209,60 +961,71 @@ async function runTest(config) {
     headless: true
   };
   config.onStatusChange?.("initializing");
-  const session = await createStagehandSession(browserConfig, config.anthropicApiKey);
-  const { stagehand, page } = session;
+  let session;
   const stepResults = [];
   let pendingConsoleLogs = [];
   let pendingNetworkErrors = [];
   let stepStartTime = Date.now();
-  const rawPage = page;
-  rawPage.on("console", (msg) => {
-    const level = msg.type?.() ?? msg.type ?? "log";
-    const mappedLevel = level === "error" ? "error" : level === "warn" || level === "warning" ? "warning" : level === "info" ? "info" : level === "debug" ? "debug" : "log";
-    pendingConsoleLogs.push({
-      level: mappedLevel,
-      text: (typeof msg.text === "function" ? msg.text() : String(msg.text ?? msg)).slice(0, 2e3),
-      source: typeof msg.location === "function" ? msg.location()?.url : void 0,
-      timestamp: Date.now() - stepStartTime
-    });
-  });
-  rawPage.on("requestfailed", (req) => {
-    const url = typeof req.url === "function" ? req.url() : String(req.url ?? "");
-    const method = typeof req.method === "function" ? req.method() : String(req.method ?? "GET");
-    const failure = typeof req.failure === "function" ? req.failure() : req.failure;
-    pendingNetworkErrors.push({
-      method,
-      url: url.slice(0, 500),
-      status: 0,
-      statusText: failure?.errorText ?? "Request failed",
-      timestamp: Date.now() - stepStartTime
-    });
-  });
-  rawPage.on("response", (res) => {
-    const status = typeof res.status === "function" ? res.status() : Number(res.status ?? 0);
-    if (status >= 400) {
-      const url = typeof res.url === "function" ? res.url() : String(res.url ?? "");
-      const statusText = typeof res.statusText === "function" ? res.statusText() : String(res.statusText ?? "");
-      const req = typeof res.request === "function" ? res.request() : res.request;
-      const method = req ? typeof req.method === "function" ? req.method() : String(req.method ?? "GET") : "GET";
-      pendingNetworkErrors.push({
-        method,
-        url: url.slice(0, 500),
-        status,
-        statusText,
-        timestamp: Date.now() - stepStartTime
+  try {
+    session = await createStagehandSession(browserConfig, config.anthropicApiKey);
+    const { stagehand, page } = session;
+    await suppressBugBearWidget(stagehand);
+    const rawPage = page;
+    try {
+      rawPage.on("console", (msg) => {
+        const level = msg.type?.() ?? msg.type ?? "log";
+        const mappedLevel = level === "error" ? "error" : level === "warn" || level === "warning" ? "warning" : level === "info" ? "info" : level === "debug" ? "debug" : "log";
+        pendingConsoleLogs.push({
+          level: mappedLevel,
+          text: (typeof msg.text === "function" ? msg.text() : String(msg.text ?? msg)).slice(0, 2e3),
+          source: typeof msg.location === "function" ? msg.location()?.url : void 0,
+          timestamp: Date.now() - stepStartTime
+        });
       });
+    } catch {
     }
-  });
-  try {
-    if (config.auth?.type === "form-login") {
+    try {
+      rawPage.on("requestfailed", (req) => {
+        const url = typeof req.url === "function" ? req.url() : String(req.url ?? "");
+        const method = typeof req.method === "function" ? req.method() : String(req.method ?? "GET");
+        const failure = typeof req.failure === "function" ? req.failure() : req.failure;
+        pendingNetworkErrors.push({
+          method,
+          url: url.slice(0, 500),
+          status: 0,
+          statusText: failure?.errorText ?? "Request failed",
+          timestamp: Date.now() - stepStartTime
+        });
+      });
+    } catch {
+    }
+    try {
+      rawPage.on("response", (res) => {
+        const status = typeof res.status === "function" ? res.status() : Number(res.status ?? 0);
+        if (status >= 400) {
+          const url = typeof res.url === "function" ? res.url() : String(res.url ?? "");
+          const statusText = typeof res.statusText === "function" ? res.statusText() : String(res.statusText ?? "");
+          const req = typeof res.request === "function" ? res.request() : res.request;
+          const method = req ? typeof req.method === "function" ? req.method() : String(req.method ?? "GET") : "GET";
+          pendingNetworkErrors.push({
+            method,
+            url: url.slice(0, 500),
+            status,
+            statusText,
+            timestamp: Date.now() - stepStartTime
+          });
+        }
+      });
+    } catch {
+    }
+    if (config.auth?.type === "form-login" || config.auth?.type === "supabase-native") {
       config.onStatusChange?.("authenticating");
       await injectAuth(page, config.auth, stagehand);
     }
     config.onStatusChange?.("navigating");
     const targetUrl = config.testCase.targetRoute ? `${config.targetUrl.replace(/\/$/, "")}${config.testCase.targetRoute}` : config.targetUrl;
     await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeoutMs: 3e4 });
-    if (config.auth && config.auth.type !== "form-login") {
+    if (config.auth && config.auth.type !== "form-login" && config.auth.type !== "supabase-native") {
       config.onStatusChange?.("authenticating");
       await injectAuth(page, config.auth, stagehand);
       if (config.auth.type === "localStorage") {
@@ -276,79 +1039,143 @@ async function runTest(config) {
     }
     await page.waitForLoadState("networkidle").catch(() => {
     });
+    await page.evaluate(() => {
+      window.__bugbear_suppress = true;
+      try {
+        localStorage.setItem("__bugbear_suppress", "true");
+      } catch {
+      }
+    }).catch(() => {
+    });
+    await installClickTracker(page);
     pendingConsoleLogs = [];
     pendingNetworkErrors = [];
     config.onStatusChange?.("executing");
     const steps = config.testCase.steps;
+    const maxRetries = config.retry?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryDelayMs = config.retry?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    const resilientMode = config.resilientMode ?? true;
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      stepStartTime = Date.now();
-      pendingConsoleLogs = [];
-      pendingNetworkErrors = [];
-      const screenshotBefore = await page.screenshot({ type: "png" });
-      let error;
-      let screenshotAfter = screenshotBefore;
-      let actSucceeded = false;
-      try {
-        await stagehand.act(step.action);
-        actSucceeded = true;
-        await page.waitForLoadState("networkidle").catch(() => {
-        });
-        await page.waitForTimeout(500);
-        screenshotAfter = await page.screenshot({ type: "png" });
-      } catch (err) {
-        error = err instanceof Error ? err.message : String(err);
+      const retryHistory = [];
+      let finalResult;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        stepStartTime = Date.now();
+        pendingConsoleLogs = [];
+        pendingNetworkErrors = [];
+        const screenshotBefore = await page.screenshot({ type: "png" });
+        let error;
+        let screenshotAfter = screenshotBefore;
+        let actSucceeded = false;
+        const actionResult = await executeAction(page, stagehand, step);
+        error = actionResult.error;
+        actSucceeded = !error;
+        if (actSucceeded) {
+          await page.waitForLoadState("networkidle").catch(() => {
+          });
+          await page.waitForTimeout(step.waitMs ?? 500);
+        }
         screenshotAfter = await page.screenshot({ type: "png" }).catch(() => screenshotBefore);
+        let evaluation = {
+          passed: false,
+          confidence: 0,
+          actualResult: error ?? "Action execution failed"
+        };
+        if (actSucceeded) {
+          try {
+            const visionResult = await withTimeout(
+              evaluateStep({
+                anthropic,
+                screenshotBefore,
+                screenshotAfter,
+                action: step.action,
+                expectedResult: step.expectedResult,
+                evaluationHint: step.evaluationHint,
+                model: config.model
+              }),
+              AI_OPERATION_TIMEOUT_MS,
+              "Vision evaluation"
+            );
+            evaluation = {
+              passed: visionResult.passed,
+              confidence: visionResult.confidence,
+              actualResult: visionResult.actualResult
+            };
+          } catch (evalErr) {
+            evaluation = {
+              passed: false,
+              confidence: 0.2,
+              actualResult: `Vision evaluation error: ${evalErr instanceof Error ? evalErr.message : String(evalErr)}`
+            };
+          }
+        }
+        let discoveredActions = [];
+        if (actSucceeded && !actionResult.deterministic) {
+          const discovered = await discoverSelector(page);
+          if (discovered) {
+            discoveredActions = [{
+              type: discovered.suggestedActionType ?? "click",
+              selector: discovered.selector,
+              description: `Discovered via ${discovered.strategy}: ${discovered.tagName}${discovered.textContent ? ` "${discovered.textContent.slice(0, 50)}"` : ""}`
+            }];
+          }
+        }
+        const consoleLogs = pendingConsoleLogs.slice(0, 50);
+        const networkErrors = pendingNetworkErrors.slice(0, 30);
+        finalResult = {
+          stepNumber: step.stepNumber,
+          action: step.action,
+          expectedResult: step.expectedResult,
+          actualResult: evaluation.actualResult,
+          passed: evaluation.passed,
+          confidence: evaluation.confidence,
+          screenshotBefore,
+          screenshotAfter,
+          actionsTaken: discoveredActions,
+          error,
+          durationMs: Date.now() - stepStartTime,
+          consoleLogs,
+          networkErrors,
+          retryCount: attempt,
+          retryHistory,
+          skipped: false
+        };
+        const shouldRetry = !evaluation.passed && error && isRetryableError(error) && attempt < maxRetries;
+        if (!shouldRetry) break;
+        retryHistory.push({
+          attempt,
+          error,
+          confidence: evaluation.confidence,
+          timestamp: Date.now()
+        });
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
       }
-      let evaluation = {
-        passed: false,
-        confidence: 0,
-        actualResult: error ?? "Action execution failed"
-      };
-      if (actSucceeded) {
+      if (resilientMode && finalResult && !finalResult.passed) {
+        finalResult.skipped = true;
+        finalResult.skipReason = "Step failed, recovered page state";
         try {
-          const verificationSchema = import_zod.z.object({
-            passed: import_zod.z.boolean().describe("Whether the expected result was achieved"),
-            confidence: import_zod.z.number().min(0).max(1).describe("Confidence in the assessment (0.9+ = very sure, 0.7-0.9 = likely, below 0.7 = uncertain)"),
-            actualResult: import_zod.z.string().describe("Description of what actually happened on the page")
+          config.onStatusChange?.("navigating");
+          await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeoutMs: 3e4 });
+          await page.waitForLoadState("networkidle").catch(() => {
+          });
+          await installClickTracker(page);
+          await page.evaluate(() => {
+            window.__bugbear_suppress = true;
+            try {
+              localStorage.setItem("__bugbear_suppress", "true");
+            } catch {
+            }
+          }).catch(() => {
           });
-          const verification = await stagehand.extract(
-            `You are evaluating a QA test step. The action "${step.action}" was just performed. Check if this expected result was achieved: "${step.expectedResult}". Look at the current page state and describe what actually happened. Be precise and factual in your assessment.`,
-            verificationSchema
-          );
-          evaluation = {
-            passed: verification.passed,
-            confidence: verification.confidence,
-            actualResult: verification.actualResult
-          };
-        } catch (evalErr) {
-          evaluation = {
-            passed: false,
-            confidence: 0.2,
-            actualResult: `Verification error: ${evalErr instanceof Error ? evalErr.message : String(evalErr)}`
-          };
+          pendingConsoleLogs = [];
+          pendingNetworkErrors = [];
+          config.onStatusChange?.("executing");
+        } catch (recoveryErr) {
+          finalResult.skipReason = `Step failed, recovery also failed: ${recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr)}`;
         }
       }
-      const consoleLogs = pendingConsoleLogs.slice(0, 50);
-      const networkErrors = pendingNetworkErrors.slice(0, 30);
-      const result = {
-        stepNumber: step.stepNumber,
-        action: step.action,
-        expectedResult: step.expectedResult,
-        actualResult: evaluation.actualResult,
-        passed: evaluation.passed,
-        confidence: evaluation.confidence,
-        screenshotBefore,
-        screenshotAfter,
-        actionsTaken: [],
-        // Stagehand handles actions internally
-        error,
-        durationMs: Date.now() - stepStartTime,
-        consoleLogs,
-        networkErrors
-      };
-      stepResults.push(result);
-      config.onStepComplete?.(result, i, steps.length);
+      stepResults.push(finalResult);
+      config.onStepComplete?.(finalResult, i, steps.length);
     }
     config.onStatusChange?.("completed");
     const model = config.model ?? "claude-sonnet-4-20250514";
@@ -362,11 +1189,7 @@ async function runTest(config) {
       totalDurationMs: Date.now() - startTime,
       summary,
       screenshotUrls: [],
-      tokenUsage: {
-        // Stagehand tracks tokens internally; these are approximate
-        inputTokens: steps.length * 3e3,
-        outputTokens: steps.length * 500
-      },
+      tokenUsage: getTokenEstimate(steps.length),
       browserSessionId: session.sessionId
     };
   } catch (err) {
@@ -378,30 +1201,689 @@ async function runTest(config) {
       totalDurationMs: Date.now() - startTime,
       summary: `Test execution failed: ${err instanceof Error ? err.message : String(err)}`,
       screenshotUrls: [],
-      tokenUsage: {
-        inputTokens: stepResults.length * 3e3,
-        outputTokens: stepResults.length * 500
-      },
-      browserSessionId: session.sessionId
+      tokenUsage: getTokenEstimate(stepResults.length),
+      browserSessionId: session?.sessionId ?? "unknown"
     };
   } finally {
-    await session.close();
+    if (session?.page) {
+      const rawPage = session.page;
+      rawPage.removeAllListeners?.("console");
+      rawPage.removeAllListeners?.("requestfailed");
+      rawPage.removeAllListeners?.("response");
+    }
+    await session?.close();
   }
 }
 function determineOverallResult(steps) {
   if (steps.length === 0) return "error";
-  const allPassed = steps.every((s) => s.passed);
-  const allFailed = steps.every((s) => !s.passed);
-  const hasErrors = steps.some((s) => s.error);
-  if (allPassed) return "passed";
-  if (allFailed || hasErrors) return "failed";
+  const nonSkipped = steps.filter((s) => !s.skipped);
+  const skippedCount = steps.length - nonSkipped.length;
+  if (nonSkipped.length === 0) return "error";
+  const allNonSkippedPassed = nonSkipped.every((s) => s.passed);
+  const hasErrors = nonSkipped.some((s) => s.error);
+  if (skippedCount > 0 && allNonSkippedPassed) return "passed_with_skips";
+  if (allNonSkippedPassed) return "passed";
+  if (nonSkipped.every((s) => !s.passed) || hasErrors) return "failed";
   return "partial";
 }
+
+// src/explorer.ts
+var import_sdk2 = __toESM(require("@anthropic-ai/sdk"));
+var DEFAULT_MODEL4 = "anthropic/claude-sonnet-4-20250514";
+var AI_OPERATION_TIMEOUT_MS2 = 6e4;
+async function withTimeout2(promise, timeoutMs, operation) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function runExploration(config) {
+  const {
+    targetUrl,
+    featureDescription,
+    actionBudget,
+    auth,
+    browserConfig,
+    anthropicApiKey,
+    model = DEFAULT_MODEL4,
+    onActionComplete
+  } = config;
+  const anthropic = new import_sdk2.default({ apiKey: anthropicApiKey });
+  const startTime = Date.now();
+  const actions = [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const session = await createStagehandSession(browserConfig, anthropicApiKey);
+  const { stagehand, page } = session;
+  await suppressBugBearWidget(stagehand);
+  try {
+    await page.goto(targetUrl, { waitUntil: "networkidle", timeoutMs: 3e4 });
+    if (auth) {
+      await injectAuth(page, auth, stagehand);
+      await page.waitForLoadState("networkidle").catch(() => {
+      });
+    }
+    const networkCapture = createNetworkCapture(page);
+    let consoleLogs = [];
+    let actionStartTime = Date.now();
+    const rawPage = page;
+    rawPage.on("console", (msg) => {
+      const level = msg.type?.() ?? msg.type ?? "log";
+      if (["error", "warning", "warn"].includes(level)) {
+        consoleLogs.push({
+          level: level === "warn" ? "warning" : level,
+          text: (typeof msg.text === "function" ? msg.text() : String(msg.text ?? msg)).slice(0, 500),
+          source: typeof msg.location === "function" ? msg.location()?.url : void 0,
+          timestamp: Date.now() - actionStartTime
+        });
+      }
+    });
+    const actionLog = [];
+    for (let i = 0; i < actionBudget; i++) {
+      actionStartTime = Date.now();
+      consoleLogs = [];
+      const observations = await withTimeout2(
+        stagehand.observe(),
+        AI_OPERATION_TIMEOUT_MS2,
+        "Page observation"
+      );
+      const decisionResponse = await withTimeout2(
+        anthropic.messages.create({
+          model: model.replace("anthropic/", ""),
+          max_tokens: 300,
+          system: buildDecisionPrompt(featureDescription, actionBudget - i, actionLog),
+          messages: [
+            {
+              role: "user",
+              content: `Current page URL: ${page.url()}
+
+Visible interactive elements:
+${formatObservations(observations)}
+
+What single action should I perform next?`
+            }
+          ]
+        }),
+        AI_OPERATION_TIMEOUT_MS2,
+        "Action decision"
+      );
+      const actionText = extractText(decisionResponse);
+      totalInputTokens += decisionResponse.usage.input_tokens;
+      totalOutputTokens += decisionResponse.usage.output_tokens;
+      if (actionText.toLowerCase().includes("[done]") || actionText.toLowerCase().includes("no more actions")) {
+        break;
+      }
+      const screenshotBefore = await page.screenshot({ type: "png" });
+      networkCapture.start();
+      try {
+        await stagehand.act(actionText);
+      } catch (actError) {
+        networkCapture.stop();
+        const screenshotAfter2 = await page.screenshot({ type: "png" });
+        const action2 = {
+          actionNumber: i + 1,
+          action: actionText,
+          category: "broken_interaction",
+          severity: "medium",
+          confidence: 0.9,
+          description: `Action failed: ${actError instanceof Error ? actError.message : String(actError)}`,
+          screenshotBefore,
+          screenshotAfter: screenshotAfter2,
+          networkRequests: networkCapture.getRequests(),
+          consoleLogs: [...consoleLogs],
+          durationMs: Date.now() - actionStartTime
+        };
+        actions.push(action2);
+        actionLog.push(`[${i + 1}] ${actionText} -> FAILED: ${action2.description}`);
+        onActionComplete?.(action2, i);
+        continue;
+      }
+      await page.waitForLoadState("networkidle").catch(() => {
+      });
+      await page.waitForTimeout(500);
+      networkCapture.stop();
+      const screenshotAfter = await page.screenshot({ type: "png" });
+      const capturedRequests = networkCapture.getRequests();
+      const networkErrors = networkCapture.getErrors();
+      const evalResponse = await withTimeout2(
+        anthropic.messages.create({
+          model: model.replace("anthropic/", ""),
+          max_tokens: 400,
+          system: buildEvaluationPrompt(),
+          messages: [
+            {
+              role: "user",
+              content: buildEvaluationContext(actionText, consoleLogs, networkErrors, page.url())
+            }
+          ]
+        }),
+        AI_OPERATION_TIMEOUT_MS2,
+        "Action evaluation"
+      );
+      totalInputTokens += evalResponse.usage.input_tokens;
+      totalOutputTokens += evalResponse.usage.output_tokens;
+      const evaluation = parseEvaluation2(extractText(evalResponse));
+      const action = {
+        actionNumber: i + 1,
+        action: actionText,
+        category: evaluation.category,
+        severity: evaluation.severity,
+        confidence: evaluation.confidence,
+        description: evaluation.description,
+        screenshotBefore,
+        screenshotAfter,
+        networkRequests: capturedRequests,
+        consoleLogs: [...consoleLogs],
+        domContext: evaluation.domContext,
+        durationMs: Date.now() - actionStartTime
+      };
+      actions.push(action);
+      const logEntry = evaluation.category === "normal" ? `[${i + 1}] ${actionText} -> OK` : `[${i + 1}] ${actionText} -> FINDING (${evaluation.category}): ${evaluation.description}`;
+      actionLog.push(logEntry);
+      onActionComplete?.(action, i);
+    }
+    const { generateExplorationReport: generateExplorationReport2 } = await Promise.resolve().then(() => (init_report_generator(), report_generator_exports));
+    const report = await generateExplorationReport2(anthropic, {
+      projectName: "",
+      featureDescription,
+      targetUrl,
+      actions,
+      model: model.replace("anthropic/", "")
+    });
+    totalInputTokens += report.tokenUsage.inputTokens;
+    totalOutputTokens += report.tokenUsage.outputTokens;
+    const findings = actions.filter((a) => a.category !== "normal");
+    return {
+      overallResult: findings.length > 0 ? "findings" : "clean",
+      actions,
+      report: report.report,
+      totalDurationMs: Date.now() - startTime,
+      tokenUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+      browserSessionId: session.sessionId
+    };
+  } catch (error) {
+    return {
+      overallResult: "error",
+      actions,
+      report: {
+        projectName: "",
+        featureDescription,
+        targetUrl,
+        exploredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        duration: `${Math.round((Date.now() - startTime) / 1e3)}s`,
+        actionsUsed: actions.length,
+        actionBudget,
+        findings: [],
+        tested: [],
+        notTested: [{ description: "Exploration aborted due to error", reason: String(error) }],
+        summary: `Exploration failed after ${actions.length} actions: ${error instanceof Error ? error.message : String(error)}`,
+        suggestedPrompt: ""
+      },
+      totalDurationMs: Date.now() - startTime,
+      tokenUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+      browserSessionId: session.sessionId
+    };
+  } finally {
+    if (session.page) {
+      const rawPage = session.page;
+      rawPage.removeAllListeners?.("console");
+    }
+    await session.close();
+  }
+}
+function buildDecisionPrompt(featureDescription, remainingBudget, actionLog) {
+  return `You are an exploratory QA tester examining the feature: "${featureDescription}".
+Your goal is to find bugs by interacting with the page like a real user would.
+
+Strategy for choosing your next action:
+1. Try the happy path first (normal usage)
+2. Then try edge cases: empty inputs, very long text, special characters
+3. Click buttons and links to verify they work
+4. Submit forms with missing required fields
+5. Look for visual problems: overlapping text, broken layouts, missing images
+
+You have ${remainingBudget} actions left. Prioritize high-risk interactions.
+${actionLog.length > 0 ? `
+Actions already taken:
+${actionLog.join("\n")}` : ""}
+
+DO NOT repeat an action you've already performed.
+Respond with a single action description. If there's nothing left to test, respond with "[DONE]".`;
+}
+function buildEvaluationPrompt() {
+  return `You are evaluating the result of a QA test action. Categorize what happened.
+
+Respond in this exact JSON format:
+{
+  "category": "normal" | "console_error" | "broken_interaction" | "visual_anomaly" | "input_handling",
+  "severity": "critical" | "high" | "medium" | "low",
+  "confidence": 0.0-1.0,
+  "description": "What happened",
+  "expectedBehavior": "What should have happened",
+  "domSelector": "CSS selector of the element involved (if applicable)"
+}
+
+Category definitions:
+- normal: Expected behavior, no issues found
+- console_error: JavaScript exception or failed network request (4xx/5xx)
+- broken_interaction: Action had no visible effect, button didn't respond, navigation failed
+- visual_anomaly: Layout break, text overflow, missing/broken images, overlapping elements
+- input_handling: Missing validation, accepted clearly invalid input, no error feedback
+
+Only report genuine issues. If behavior seems correct, use "normal".
+For "normal" results, severity and domSelector are not required.`;
+}
+function buildEvaluationContext(action, consoleLogs, networkErrors, currentUrl) {
+  let context = `Action performed: "${action}"
+Current URL: ${currentUrl}
+`;
+  if (consoleLogs.length > 0) {
+    context += `
+Console output:
+${consoleLogs.map((l) => `[${l.level}] ${l.text}`).join("\n")}
+`;
+  }
+  if (networkErrors.length > 0) {
+    context += `
+Failed network requests:
+${networkErrors.map((e) => `${e.method} ${e.url} -> ${e.status} ${e.statusText}`).join("\n")}
+`;
+  }
+  return context;
+}
+function formatObservations(observations) {
+  return observations.slice(0, 30).map((o, i) => `${i + 1}. [${o.selector}] ${o.description}`).join("\n");
+}
+function extractText(response) {
+  const block = response.content[0];
+  return block.type === "text" ? block.text : "";
+}
+function parseEvaluation2(text) {
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error("No JSON found");
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      category: parsed.category || "normal",
+      severity: parsed.severity,
+      confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+      description: parsed.description || text,
+      expectedBehavior: parsed.expectedBehavior,
+      domContext: parsed.domSelector ? { selector: parsed.domSelector, elementText: "", nearbyText: "" } : void 0
+    };
+  } catch {
+    return { category: "normal", confidence: 0.3, description: text };
+  }
+}
+
+// src/index.ts
+init_report_generator();
+
+// src/report-triager.ts
+var DEFAULT_MODEL5 = "claude-sonnet-4-20250514";
+async function triageReport(input) {
+  const model = input.model ?? DEFAULT_MODEL5;
+  const { report, recentReports } = input;
+  const prompt = buildTriagePrompt(report, recentReports);
+  const response = await input.anthropic.messages.create({
+    model,
+    max_tokens: 1024,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+  return parseTriageResult(text);
+}
+function buildTriagePrompt(report, recentReports) {
+  const sections = [];
+  sections.push(`REPORT TITLE: ${report.title ?? "(no title)"}`);
+  sections.push(`DESCRIPTION: ${report.description}`);
+  if (report.report_source) {
+    sections.push(`SOURCE: ${report.report_source}`);
+  }
+  if (report.app_context && Object.keys(report.app_context).length > 0) {
+    const ctx = report.app_context;
+    const parts = [];
+    if (ctx.currentRoute) parts.push(`Route: ${ctx.currentRoute}`);
+    if (ctx.currentUrl) parts.push(`URL: ${ctx.currentUrl}`);
+    if (ctx.componentName) parts.push(`Component: ${ctx.componentName}`);
+    if (ctx.userAction) parts.push(`User action: ${ctx.userAction}`);
+    if (parts.length > 0) {
+      sections.push(`APP CONTEXT:
+${parts.join("\n")}`);
+    }
+  }
+  if (report.enhanced_context) {
+    const enhanced = report.enhanced_context;
+    const consoleLogs = enhanced.consoleLogs;
+    if (consoleLogs && consoleLogs.length > 0) {
+      const errors = consoleLogs.filter((l) => l.level === "error" || l.level === "warning").slice(0, 10).map((l) => `[${l.level}] ${l.text}`).join("\n");
+      if (errors) {
+        sections.push(`CONSOLE ERRORS:
+${errors}`);
+      }
+    }
+    const networkErrors = enhanced.networkErrors;
+    if (networkErrors && networkErrors.length > 0) {
+      const netErrors = networkErrors.slice(0, 10).map((e) => `${e.method} ${e.url} \u2192 ${e.status}`).join("\n");
+      sections.push(`NETWORK ERRORS:
+${netErrors}`);
+    }
+  }
+  if (report.device_info && Object.keys(report.device_info).length > 0) {
+    const device = report.device_info;
+    const parts = [];
+    if (device.platform) parts.push(`Platform: ${device.platform}`);
+    if (device.browser) parts.push(`Browser: ${device.browser}`);
+    if (device.os) parts.push(`OS: ${device.os}`);
+    if (device.screenSize) parts.push(`Screen: ${device.screenSize}`);
+    if (parts.length > 0) {
+      sections.push(`DEVICE:
+${parts.join(", ")}`);
+    }
+  }
+  if (report.error_fingerprint) {
+    sections.push(`ERROR FINGERPRINT: ${report.error_fingerprint}`);
+  }
+  let recentSection = "";
+  if (recentReports.length > 0) {
+    const recentLines = recentReports.map((r) => {
+      const desc = r.description.slice(0, 150);
+      const fp = r.error_fingerprint ? ` [fingerprint: ${r.error_fingerprint}]` : "";
+      return `- ID: ${r.id} | "${r.title ?? "(no title)"}" | ${desc}${fp}`;
+    });
+    recentSection = `
+RECENT REPORTS (check for duplicates):
+${recentLines.join("\n")}`;
+  }
+  return `You are a QA triage specialist. Analyze this bug report and provide structured triage.
+
+${sections.join("\n\n")}
+${recentSection}
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON):
+{
+  "suggested_severity": "critical" | "high" | "medium" | "low",
+  "severity_confidence": 0.0-1.0,
+  "suggested_category": "ui_ux" | "functional" | "crash" | "security" | "other",
+  "category_confidence": 0.0-1.0,
+  "root_cause_analysis": "Brief analysis of the likely root cause",
+  "duplicate_of": null or "uuid-of-matching-report",
+  "duplicate_confidence": 0.0-1.0,
+  "triage_notes": "Summary of triage reasoning"
+}
+
+Severity guide:
+- critical: App crash, data loss, security vulnerability, blocks core workflow
+- high: Major feature broken, significant UX degradation, affects many users
+- medium: Feature partially broken, workaround exists, moderate impact
+- low: Minor cosmetic issue, edge case, minimal user impact
+
+Category guide:
+- crash: App crashes, unhandled exceptions, white screen of death
+- security: Auth bypass, data exposure, injection vulnerabilities
+- functional: Feature doesn't work as expected, logic errors, broken flows
+- ui_ux: Visual glitches, layout issues, confusing UX, accessibility problems
+- other: Performance, documentation, configuration issues
+
+Duplicate detection:
+- Compare error fingerprints first (exact match = very high confidence)
+- Then compare descriptions semantically (similar symptoms on same route/feature)
+- Only flag as duplicate if confidence \u2265 0.80`;
+}
+var VALID_SEVERITIES = ["critical", "high", "medium", "low"];
+var VALID_CATEGORIES = ["ui_ux", "functional", "crash", "security", "other"];
+function parseTriageResult(text) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    return validateTriageResult(parsed);
+  } catch {
+    const jsonMatch = text.match(/\{[\s\S]*"suggested_severity"[\s\S]*"suggested_category"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return validateTriageResult(parsed);
+      } catch {
+      }
+    }
+  }
+  return {
+    suggested_severity: "medium",
+    severity_confidence: 0.3,
+    suggested_category: "other",
+    category_confidence: 0.3,
+    root_cause_analysis: `Triage returned unparseable response: ${text.slice(0, 200)}`,
+    duplicate_of: null,
+    duplicate_confidence: 0,
+    triage_notes: "Auto-triage failed to parse AI response"
+  };
+}
+function validateTriageResult(parsed) {
+  const severity = VALID_SEVERITIES.includes(parsed.suggested_severity) ? parsed.suggested_severity : "medium";
+  const category = VALID_CATEGORIES.includes(parsed.suggested_category) ? parsed.suggested_category : "other";
+  return {
+    suggested_severity: severity,
+    severity_confidence: clampConfidence(parsed.severity_confidence),
+    suggested_category: category,
+    category_confidence: clampConfidence(parsed.category_confidence),
+    root_cause_analysis: typeof parsed.root_cause_analysis === "string" ? parsed.root_cause_analysis : "No analysis provided",
+    duplicate_of: typeof parsed.duplicate_of === "string" ? parsed.duplicate_of : null,
+    duplicate_confidence: clampConfidence(parsed.duplicate_confidence),
+    triage_notes: typeof parsed.triage_notes === "string" ? parsed.triage_notes : "No notes provided"
+  };
+}
+function clampConfidence(value) {
+  if (typeof value !== "number") return 0.5;
+  return Math.max(0, Math.min(1, value));
+}
+
+// src/failure-analyzer.ts
+var DEFAULT_MODEL6 = "claude-sonnet-4-20250514";
+async function analyzeFailure(input) {
+  const model = input.model ?? DEFAULT_MODEL6;
+  const { step, result, discoveredSelector, consoleLogs, networkErrors } = input;
+  const content = [];
+  content.push({ type: "text", text: "BEFORE screenshot (page state before the failed action):" });
+  content.push({
+    type: "image",
+    source: { type: "base64", media_type: "image/png", data: result.screenshotBefore.toString("base64") }
+  });
+  content.push({ type: "text", text: "AFTER screenshot (page state after the failed action):" });
+  content.push({
+    type: "image",
+    source: { type: "base64", media_type: "image/png", data: result.screenshotAfter.toString("base64") }
+  });
+  content.push({ type: "text", text: buildFailurePrompt(step, result, discoveredSelector, consoleLogs, networkErrors) });
+  const response = await input.anthropic.messages.create({
+    model,
+    max_tokens: 1024,
+    messages: [{ role: "user", content }]
+  });
+  const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+  return parseFailureAnalysis(text, step);
+}
+var STEP_TO_RUN = {
+  real_bug: "bug",
+  test_maintenance: "test_issue",
+  ai_limitation: "ai_limitation",
+  flaky: "flaky",
+  unknown: "unknown"
+};
+function rollupFailureClassification(stepClassifications) {
+  if (stepClassifications.length === 0) return "unknown";
+  if (stepClassifications.some((c) => c === "real_bug")) return "bug";
+  if (stepClassifications.every((c) => c === "ai_limitation")) return "ai_limitation";
+  if (stepClassifications.every((c) => c === "test_maintenance")) return "test_issue";
+  if (stepClassifications.every((c) => c === "flaky")) return "flaky";
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of stepClassifications) {
+    counts.set(c, (counts.get(c) ?? 0) + 1);
+  }
+  let best = "unknown";
+  let bestCount = 0;
+  for (const [cls, count] of counts) {
+    if (count > bestCount) {
+      bestCount = count;
+      best = cls;
+    }
+  }
+  return STEP_TO_RUN[best];
+}
+function buildFailurePrompt(step, result, discoveredSelector, consoleLogs, networkErrors) {
+  const sections = [];
+  sections.push(`FAILED STEP #${step.stepNumber}: ${step.action}`);
+  sections.push(`EXPECTED: ${step.expectedResult}`);
+  sections.push(`ACTUAL: ${result.actualResult}`);
+  if (step.selector) sections.push(`SELECTOR USED: ${step.selector}`);
+  if (step.actionType) sections.push(`ACTION TYPE: ${step.actionType}`);
+  if (result.error) sections.push(`ERROR: ${result.error}`);
+  if (discoveredSelector) {
+    sections.push(`DISCOVERED SELECTOR (what Stagehand actually clicked): ${discoveredSelector.selector} (via ${discoveredSelector.strategy})${discoveredSelector.textContent ? ` \u2014 text: "${discoveredSelector.textContent}"` : ""}`);
+  }
+  if (consoleLogs && consoleLogs.length > 0) {
+    const errors = consoleLogs.filter((l) => l.level === "error" || l.level === "warning").slice(0, 8).map((l) => `[${l.level}] ${l.text}`).join("\n");
+    if (errors) sections.push(`CONSOLE ERRORS:
+${errors}`);
+  }
+  if (networkErrors && networkErrors.length > 0) {
+    const netErrors = networkErrors.slice(0, 8).map((e) => `${e.method} ${e.url} \u2192 ${e.status} ${e.statusText}`).join("\n");
+    sections.push(`NETWORK ERRORS:
+${netErrors}`);
+  }
+  return `You are a QA failure analyst. A test step failed. Analyze the before/after screenshots and the context below to classify this failure.
+
+${sections.join("\n\n")}
+
+Classify into ONE of these categories:
+- **real_bug**: The application has an actual defect. Indicators: API errors (4xx/5xx), JavaScript exceptions, missing/broken UI elements that SHOULD be there, incorrect behavior, data not saving.
+- **test_maintenance**: The test is stale \u2014 the app changed but the test wasn't updated. Indicators: element moved/renamed, selector no longer matches, page restructured but app works correctly, the discovered selector differs from the test's selector.
+- **ai_limitation**: The AI executor itself could not complete this step \u2014 NOT an app bug. Indicators: already logged in so can't reach the login page, a QA/testing widget or overlay appeared and blocked the real UI, the test requires measuring something the AI can't (contrast ratios, pixel measurements), the AI landed on a completely wrong page and never reached the test target, authentication redirect prevented navigation, a popup or modal unrelated to the test blocked interaction.
+- **flaky**: Timing or intermittent issue. Indicators: timeout errors, "element not found" but the element IS visible in screenshots, network hiccup, race condition.
+- **unknown**: Can't determine with confidence.
+
+For **test_maintenance** failures, suggest a corrected step (selector, action, value).
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON):
+{
+  "classification": "real_bug" | "test_maintenance" | "ai_limitation" | "flaky" | "unknown",
+  "confidence": 0.0-1.0,
+  "reasoning": "Brief explanation of why this classification",
+  "suggested_fix": null | {
+    "corrected_action": "Updated natural language action (if changed)",
+    "corrected_selector": "Updated CSS selector (if selector changed)",
+    "corrected_actionType": "Updated action type (if changed)",
+    "corrected_value": "Updated value (if changed)"
+  }
+}`;
+}
+var VALID_CLASSIFICATIONS = ["real_bug", "test_maintenance", "ai_limitation", "flaky", "unknown"];
+function parseFailureAnalysis(text, step) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    return validateFailureAnalysis(parsed, step);
+  } catch {
+    const jsonMatch = text.match(/\{[\s\S]*"classification"[\s\S]*"confidence"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return validateFailureAnalysis(parsed, step);
+      } catch {
+      }
+    }
+  }
+  return {
+    classification: "unknown",
+    confidence: 0.3,
+    reasoning: `Failure analysis returned unparseable response: ${text.slice(0, 200)}`
+  };
+}
+function validateFailureAnalysis(parsed, step) {
+  const classification = VALID_CLASSIFICATIONS.includes(parsed.classification) ? parsed.classification : "unknown";
+  const result = {
+    classification,
+    confidence: clampConfidence2(parsed.confidence),
+    reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "No reasoning provided"
+  };
+  if (parsed.suggested_fix && typeof parsed.suggested_fix === "object") {
+    const fix = parsed.suggested_fix;
+    result.suggested_fix = {
+      stepNumber: step.stepNumber,
+      original_action: step.action,
+      corrected_action: typeof fix.corrected_action === "string" ? fix.corrected_action : void 0,
+      corrected_selector: typeof fix.corrected_selector === "string" ? fix.corrected_selector : void 0,
+      corrected_actionType: typeof fix.corrected_actionType === "string" ? fix.corrected_actionType : void 0,
+      corrected_value: typeof fix.corrected_value === "string" ? fix.corrected_value : void 0
+    };
+  }
+  return result;
+}
+function clampConfidence2(value) {
+  if (typeof value !== "number") return 0.5;
+  return Math.max(0, Math.min(1, value));
+}
+
+// src/concurrency.ts
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+    this.current = 0;
+    this.queue = [];
+    if (max < 1) throw new Error("Semaphore max must be >= 1");
+  }
+  async acquire() {
+    if (this.current < this.max) {
+      this.current++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.current--;
+    }
+  }
+  /** Number of slots currently in use */
+  get active() {
+    return this.current;
+  }
+  /** Number of waiters in the queue */
+  get waiting() {
+    return this.queue.length;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Semaphore,
+  analyzeFailure,
+  authenticateSupabase,
   createStagehandSession,
+  discoverSelector,
+  estimateBatchCost,
+  estimateCost,
+  estimateTestCost,
+  evaluateStep,
+  executeAction,
+  generateExplorationReport,
   generateRunSummary,
+  getTokenEstimate,
   injectAuth,
-  runTest
+  injectSupabaseAuth,
+  installClickTracker,
+  performSupabaseAuth,
+  rollupFailureClassification,
+  runExploration,
+  runTest,
+  suppressBugBearWidget,
+  triageReport,
+  verifySupabaseSession
 });
 //# sourceMappingURL=index.js.map