@hasna/testers 0.0.33 → 0.0.35

package/dist/cli/index.js

@@ -2100,6 +2100,56 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/types/index.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringMap(value) {
+  if (!isRecord(value))
+    return;
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function cleanupValue(value) {
+  if (value === "delete" || value === "stop" || value === "keep")
+    return value;
+  return;
+}
+function workflowExecutionFromValue(value) {
+  const input = isRecord(value) ? value : {};
+  const rawTarget = stringValue(input["target"]) ?? "local";
+  if (rawTarget === "local") {
+    const timeoutMs2 = numberValue(input["timeoutMs"]);
+    return timeoutMs2 === undefined ? { target: "local" } : { target: "local", timeoutMs: timeoutMs2 };
+  }
+  if (rawTarget !== "sandbox" && rawTarget !== "connector:e2b") {
+    throw new Error(`Unsupported workflow execution target: ${rawTarget}`);
+  }
+  const provider = rawTarget === "connector:e2b" ? "e2b" : stringValue(input["provider"]) ?? stringValue(input["connector"]);
+  const sandboxImage = stringValue(input["sandboxImage"]) ?? stringValue(input["sandboxTemplate"]);
+  const sandboxRemoteDir = stringValue(input["sandboxRemoteDir"]);
+  const sandboxCleanup = cleanupValue(input["sandboxCleanup"]);
+  const setupCommand = stringValue(input["setupCommand"]);
+  const packageSpec = stringValue(input["packageSpec"]);
+  const timeoutMs = numberValue(input["timeoutMs"]);
+  const env = stringMap(input["env"]);
+  return {
+    target: "sandbox",
+    ...provider ? { provider } : {},
+    ...sandboxImage ? { sandboxImage } : {},
+    ...sandboxRemoteDir ? { sandboxRemoteDir } : {},
+    ...sandboxCleanup ? { sandboxCleanup } : {},
+    ...setupCommand ? { setupCommand } : {},
+    ...packageSpec ? { packageSpec } : {},
+    ...timeoutMs !== undefined ? { timeoutMs } : {},
+    ...env ? { env } : {}
+  };
+}
 function workflowFromRow(row) {
   return {
     id: row.id,
@@ -2109,7 +2159,7 @@ function workflowFromRow(row) {
     scenarioFilter: JSON.parse(row.scenario_filter || "{}"),
     personaIds: JSON.parse(row.persona_ids || "[]"),
     goal: row.goal ? JSON.parse(row.goal) : null,
-    execution: JSON.parse(row.execution || '{"target":"local"}'),
+    execution: workflowExecutionFromValue(JSON.parse(row.execution || '{"target":"local"}')),
     settings: JSON.parse(row.settings || "{}"),
     enabled: row.enabled === 1,
     createdAt: row.created_at,
@@ -14074,6 +14124,7 @@ __export(exports_ai_client, {
   createClientForModel: () => createClientForModel,
   createClient: () => createClient,
   callOpenAICompatible: () => callOpenAICompatible,
+  buildScenarioUserMessage: () => buildScenarioUserMessage,
   BROWSER_TOOLS: () => BROWSER_TOOLS
 });
 import Anthropic2 from "@anthropic-ai/sdk";
@@ -14486,7 +14537,6 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
         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)
@@ -14551,7 +14601,6 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
       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";
@@ -14628,7 +14677,28 @@ ${JSON.stringify(har, null, 2)}` };
       }
       case "browser_a11y": {
         const level = toolInput.level ?? "AA";
-        const snapshot = await page.accessibility.snapshot();
+        const snapshot = await page.evaluate(() => {
+          function readRole(el) {
+            return el.getAttribute("role") ?? el.tagName.toLowerCase();
+          }
+          function readName(el) {
+            const labelledBy = el.getAttribute("aria-labelledby");
+            if (labelledBy) {
+              const labelledText = labelledBy.split(/\s+/).map((id) => document.getElementById(id)?.textContent?.trim()).filter(Boolean).join(" ");
+              if (labelledText)
+                return labelledText;
+            }
+            return el.getAttribute("aria-label") ?? el.getAttribute("alt") ?? el.textContent?.trim() ?? "";
+          }
+          function walk(el) {
+            return {
+              role: readRole(el),
+              name: readName(el),
+              children: Array.from(el.children).map((child) => walk(child))
+            };
+          }
+          return document.body ? walk(document.body) : null;
+        });
         if (!snapshot)
           return { result: "Error: could not capture accessibility tree" };
         const issues = [];
@@ -14670,6 +14740,38 @@ ${filtered.join(`
     return { result: `Error executing ${toolName}: ${message}` };
   }
 }
+function resolveStartUrl(baseUrl, targetPath) {
+  try {
+    return new URL(targetPath, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
+  } catch {
+    return `${baseUrl.replace(/\/+$/, "")}/${targetPath.replace(/^\/+/, "")}`;
+  }
+}
+function buildScenarioUserMessage(scenario, baseUrl) {
+  const userParts = [
+    `**Scenario:** ${scenario.name}`,
+    `**Description:** ${scenario.description}`
+  ];
+  if (baseUrl) {
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+    userParts.push(`**Base URL:** ${normalizedBaseUrl}`);
+    if (scenario.targetPath) {
+      userParts.push(`**Start URL:** ${resolveStartUrl(normalizedBaseUrl, scenario.targetPath)}`);
+    }
+    userParts.push("**Navigation Boundary:** Treat the Base URL as the application under test. Resolve relative paths and in-app navigation against this origin. Do not navigate to another host unless a step explicitly includes an absolute external URL.");
+  }
+  if (scenario.targetPath) {
+    userParts.push(`**Target Path:** ${scenario.targetPath}`);
+  }
+  if (scenario.steps.length > 0) {
+    userParts.push("**Steps:**");
+    for (let i = 0;i < scenario.steps.length; i++) {
+      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
+    }
+  }
+  return userParts.join(`
+`);
+}
 async function runAgentLoop(options) {
   const {
     client,
@@ -14679,6 +14781,7 @@ async function runAgentLoop(options) {
     model,
     runId,
     sessionId,
+    baseUrl,
     maxTurns = 30,
     onStep,
     persona,
@@ -14726,21 +14829,7 @@ Instructions: ${persona.instructions}` : "",
     "- Verify both positive and negative states"
   ].join(`
 `) + personaSection;
-  const userParts = [
-    `**Scenario:** ${scenario.name}`,
-    `**Description:** ${scenario.description}`
-  ];
-  if (scenario.targetPath) {
-    userParts.push(`**Target Path:** ${scenario.targetPath}`);
-  }
-  if (scenario.steps.length > 0) {
-    userParts.push("**Steps:**");
-    for (let i = 0;i < scenario.steps.length; i++) {
-      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
-    }
-  }
-  const userMessage = userParts.join(`
-`);
+  const userMessage = buildScenarioUserMessage(scenario, baseUrl);
   const screenshots = [];
   let tokensUsed = 0;
   let stepNumber = 0;
@@ -14803,7 +14892,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, sessionId, a11y });
+        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber, sessionId: sessionId ?? runId, a11y });
         if (onStep) {
           onStep({ type: "tool_result", toolName: toolBlock.name, toolResult: execResult.result, stepNumber });
         }
@@ -17494,6 +17583,381 @@ var init_failure_pipeline = __esm(() => {
   init_todos_connector();
 });
 
+// src/lib/a11y-audit.ts
+async function runA11yAudit(page, options = {}) {
+  const { level = "AA", rules, exclude = [] } = options;
+  await page.addScriptTag({ url: "https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.9.1/axe.min.js" });
+  const config = {
+    runOnly: {
+      type: level === "AAA" ? "standard" : "tag",
+      values: level === "AAA" ? undefined : [level, "best-practice"]
+    }
+  };
+  if (rules && rules.length > 0) {
+    config.rules = Object.fromEntries(rules.map((r) => [r, { enabled: true }]));
+  }
+  if (exclude.length > 0) {
+    config.exclude = exclude;
+  }
+  const result = await page.evaluate(async (auditConfig) => {
+    const axeResult = await window.axe.run(auditConfig);
+    return axeResult;
+  }, config);
+  const violations = (result.violations ?? []).map((v) => ({
+    id: v.id,
+    impact: v.impact,
+    description: v.description,
+    help: v.help,
+    helpUrl: v.helpUrl,
+    nodes: (v.nodes ?? []).map((n) => ({
+      html: n.html,
+      target: n.target,
+      failureSummary: n.failureSummary
+    }))
+  }));
+  const passes = (result.passes ?? []).map((p) => ({
+    id: p.id,
+    description: p.description
+  }));
+  const incomplete = (result.incomplete ?? []).map((i) => ({
+    id: i.id,
+    description: i.description,
+    impact: i.impact
+  }));
+  const criticalCount = violations.filter((v) => v.impact === "critical").length;
+  const seriousCount = violations.filter((v) => v.impact === "serious").length;
+  const moderateCount = violations.filter((v) => v.impact === "moderate").length;
+  const minorCount = violations.filter((v) => v.impact === "minor").length;
+  return {
+    violations,
+    passes,
+    incomplete,
+    url: page.url(),
+    timestamp: new Date().toISOString(),
+    totalViolations: violations.length,
+    criticalCount,
+    seriousCount,
+    moderateCount,
+    minorCount
+  };
+}
+
+// src/lib/assertions.ts
+async function evaluateAssertions(page, assertions, context = {}) {
+  const results = [];
+  for (const assertion of assertions) {
+    try {
+      const result = await evaluateOne(page, assertion, context);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        assertion,
+        passed: false,
+        actual: "",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+async function evaluateOne(page, assertion, context) {
+  switch (assertion.type) {
+    case "visible": {
+      const visible = await page.locator(assertion.selector).isVisible();
+      return {
+        assertion,
+        passed: visible,
+        actual: String(visible)
+      };
+    }
+    case "not_visible": {
+      const visible = await page.locator(assertion.selector).isVisible();
+      return {
+        assertion,
+        passed: !visible,
+        actual: String(visible)
+      };
+    }
+    case "text_contains": {
+      const text = await page.locator(assertion.selector).textContent() ?? "";
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: text.includes(expected),
+        actual: text
+      };
+    }
+    case "text_equals": {
+      const text = await page.locator(assertion.selector).textContent() ?? "";
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: text.trim() === expected.trim(),
+        actual: text
+      };
+    }
+    case "element_count": {
+      const count = await page.locator(assertion.selector).count();
+      const expected = Number(assertion.expected ?? 0);
+      return {
+        assertion,
+        passed: count === expected,
+        actual: String(count)
+      };
+    }
+    case "no_console_errors": {
+      if (context.consoleErrors !== undefined) {
+        const errors = context.consoleErrors.filter(Boolean);
+        return {
+          assertion,
+          passed: errors.length === 0,
+          actual: errors.length === 0 ? "No console errors captured" : errors.slice(0, 3).join(" | ")
+        };
+      }
+      const errorElements = await page.locator('[role="alert"], .error, .error-message, [data-testid="error"]').count();
+      return {
+        assertion,
+        passed: errorElements === 0,
+        actual: `${errorElements} error element(s) found`
+      };
+    }
+    case "no_a11y_violations": {
+      try {
+        const auditResult = await runA11yAudit(page);
+        const hasIssues = auditResult.violations.length > 0;
+        return {
+          assertion,
+          passed: !hasIssues,
+          actual: hasIssues ? `${auditResult.totalViolations} violation(s): ${auditResult.violations.map((v) => v.id).join(", ")}` : "No accessibility violations found"
+        };
+      } catch (err) {
+        return {
+          assertion,
+          passed: false,
+          actual: "",
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+    case "url_contains": {
+      const url = page.url();
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: url.includes(expected),
+        actual: url
+      };
+    }
+    case "title_contains": {
+      const title = await page.title();
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: title.includes(expected),
+        actual: title
+      };
+    }
+    case "cookie_exists": {
+      const cookieName = assertion.expected;
+      const cookies = await page.context().cookies();
+      const found = cookies.some((c) => c.name === cookieName);
+      return {
+        assertion,
+        passed: found,
+        actual: found ? `Cookie "${cookieName}" exists` : `Cookie "${cookieName}" not found`
+      };
+    }
+    case "cookie_not_exists": {
+      const cookieName = assertion.expected;
+      const cookies = await page.context().cookies();
+      const found = cookies.some((c) => c.name === cookieName);
+      return {
+        assertion,
+        passed: !found,
+        actual: found ? `Cookie "${cookieName}" found (unexpected)` : `Cookie "${cookieName}" does not exist`
+      };
+    }
+    case "cookie_value": {
+      const [cookieName, expectedValue] = assertion.expected.split("=", 2);
+      const cookies = await page.context().cookies();
+      const cookie = cookies.find((c) => c.name === cookieName);
+      const actualValue = cookie?.value ?? "";
+      return {
+        assertion,
+        passed: actualValue === expectedValue,
+        actual: cookie ? `${cookieName}=${actualValue}` : `Cookie "${cookieName}" not found`
+      };
+    }
+    case "local_storage_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => localStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value !== null,
+        actual: value !== null ? `Key "${key}" exists with value "${value}"` : `Key "${key}" not found in localStorage`
+      };
+    }
+    case "local_storage_not_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => localStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value === null,
+        actual: value !== null ? `Key "${key}" exists (unexpected)` : `Key "${key}" does not exist in localStorage`
+      };
+    }
+    case "local_storage_value": {
+      const [lsKey, expectedValue] = assertion.expected.split("=", 2);
+      const value = await page.evaluate((k) => localStorage.getItem(k), lsKey ?? "");
+      return {
+        assertion,
+        passed: value === expectedValue,
+        actual: value !== null ? `${lsKey}=${value}` : `Key "${lsKey}" not found in localStorage`
+      };
+    }
+    case "session_storage_value": {
+      const [ssKey, expectedValue] = assertion.expected.split("=", 2);
+      const value = await page.evaluate((k) => sessionStorage.getItem(k), ssKey ?? "");
+      return {
+        assertion,
+        passed: value === expectedValue,
+        actual: value !== null ? `${ssKey}=${value}` : `Key "${ssKey}" not found in sessionStorage`
+      };
+    }
+    case "session_storage_not_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => sessionStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value === null,
+        actual: value !== null ? `Key "${key}" exists (unexpected)` : `Key "${key}" does not exist in sessionStorage`
+      };
+    }
+    default: {
+      return {
+        assertion,
+        passed: false,
+        actual: "",
+        error: `Unknown assertion type: ${assertion.type}`
+      };
+    }
+  }
+}
+function parseAssertionString(str) {
+  const trimmed = str.trim();
+  if (trimmed === "no-console-errors") {
+    return { type: "no_console_errors", description: "No console errors" };
+  }
+  if (trimmed.startsWith("url:contains:")) {
+    const expected = trimmed.slice("url:contains:".length);
+    return { type: "url_contains", expected, description: `URL contains "${expected}"` };
+  }
+  if (trimmed.startsWith("title:contains:")) {
+    const expected = trimmed.slice("title:contains:".length);
+    return { type: "title_contains", expected, description: `Title contains "${expected}"` };
+  }
+  if (trimmed.startsWith("count:")) {
+    const rest = trimmed.slice("count:".length);
+    const eqIdx = rest.indexOf(" eq:");
+    if (eqIdx === -1) {
+      throw new Error(`Invalid count assertion format: ${str}. Expected "count:<selector> eq:<number>"`);
+    }
+    const selector = rest.slice(0, eqIdx);
+    const expected = parseInt(rest.slice(eqIdx + " eq:".length), 10);
+    return { type: "element_count", selector, expected, description: `${selector} count equals ${expected}` };
+  }
+  if (trimmed.startsWith("text:")) {
+    const rest = trimmed.slice("text:".length);
+    const containsIdx = rest.indexOf(" contains:");
+    const equalsIdx = rest.indexOf(" equals:");
+    if (containsIdx !== -1) {
+      const selector = rest.slice(0, containsIdx);
+      const expected = rest.slice(containsIdx + " contains:".length);
+      return { type: "text_contains", selector, expected, description: `${selector} text contains "${expected}"` };
+    }
+    if (equalsIdx !== -1) {
+      const selector = rest.slice(0, equalsIdx);
+      const expected = rest.slice(equalsIdx + " equals:".length);
+      return { type: "text_equals", selector, expected, description: `${selector} text equals "${expected}"` };
+    }
+    throw new Error(`Invalid text assertion format: ${str}. Expected "text:<selector> contains:<text>" or "text:<selector> equals:<text>"`);
+  }
+  if (trimmed.startsWith("selector:")) {
+    const rest = trimmed.slice("selector:".length);
+    const lastSpace = rest.lastIndexOf(" ");
+    if (lastSpace === -1) {
+      throw new Error(`Invalid selector assertion format: ${str}. Expected "selector:<selector> visible" or "selector:<selector> not-visible"`);
+    }
+    const selector = rest.slice(0, lastSpace);
+    const action = rest.slice(lastSpace + 1);
+    if (action === "visible") {
+      return { type: "visible", selector, description: `${selector} is visible` };
+    }
+    if (action === "not-visible") {
+      return { type: "not_visible", selector, description: `${selector} is not visible` };
+    }
+    throw new Error(`Unknown selector action: "${action}". Expected "visible" or "not-visible"`);
+  }
+  if (trimmed.startsWith("cookie:exists:")) {
+    const name = trimmed.slice("cookie:exists:".length);
+    return { type: "cookie_exists", expected: name, description: `Cookie "${name}" exists` };
+  }
+  if (trimmed.startsWith("cookie:not-exists:")) {
+    const name = trimmed.slice("cookie:not-exists:".length);
+    return { type: "cookie_not_exists", expected: name, description: `Cookie "${name}" does not exist` };
+  }
+  if (trimmed.startsWith("cookie:value:")) {
+    const valueStr = trimmed.slice("cookie:value:".length);
+    return { type: "cookie_value", expected: valueStr, description: `Cookie value is "${valueStr}"` };
+  }
+  if (trimmed.startsWith("local:exists:")) {
+    const key = trimmed.slice("local:exists:".length);
+    return { type: "local_storage_exists", expected: key, description: `LocalStorage key "${key}" exists` };
+  }
+  if (trimmed.startsWith("local:not-exists:")) {
+    const key = trimmed.slice("local:not-exists:".length);
+    return { type: "local_storage_not_exists", expected: key, description: `LocalStorage key "${key}" does not exist` };
+  }
+  if (trimmed.startsWith("local:value:")) {
+    const valueStr = trimmed.slice("local:value:".length);
+    return { type: "local_storage_value", expected: valueStr, description: `LocalStorage value is "${valueStr}"` };
+  }
+  if (trimmed.startsWith("session:value:")) {
+    const valueStr = trimmed.slice("session:value:".length);
+    return { type: "session_storage_value", expected: valueStr, description: `SessionStorage value is "${valueStr}"` };
+  }
+  if (trimmed.startsWith("session:not-exists:")) {
+    const key = trimmed.slice("session:not-exists:".length);
+    return { type: "session_storage_not_exists", expected: key, description: `SessionStorage key "${key}" does not exist` };
+  }
+  throw new Error(`Cannot parse assertion: "${str}". See --help for assertion formats.`);
+}
+function allAssertionsPassed(results) {
+  return results.every((r) => r.passed);
+}
+function formatAssertionResults(results) {
+  if (results.length === 0)
+    return "No assertions.";
+  const lines = [];
+  for (const r of results) {
+    const icon = r.passed ? "PASS" : "FAIL";
+    const desc = r.assertion.description || `${r.assertion.type}${r.assertion.selector ? ` ${r.assertion.selector}` : ""}`;
+    let line = `  [${icon}] ${desc}`;
+    if (!r.passed) {
+      line += ` (actual: ${r.actual})`;
+      if (r.error)
+        line += ` \u2014 ${r.error}`;
+    }
+    lines.push(line);
+  }
+  const passed = results.filter((r) => r.passed).length;
+  lines.push(`
+  ${passed}/${results.length} assertions passed.`);
+  return lines.join(`
+`);
+}
+var init_assertions = () => {};
+
 // src/db/flows.ts
 var exports_flows = {};
 __export(exports_flows, {
@@ -17652,7 +18116,9 @@ __export(exports_runner, {
   runSingleScenario: () => runSingleScenario,
   runByFilter: () => runByFilter,
   runBatch: () => runBatch,
-  onRunEvent: () => onRunEvent
+  resolveScenariosForRun: () => resolveScenariosForRun,
+  onRunEvent: () => onRunEvent,
+  applyStructuredAssertionsToResult: () => applyStructuredAssertionsToResult
 });
 import { mkdirSync as mkdirSync8 } from "fs";
 import { join as join13 } from "path";
@@ -17664,6 +18130,54 @@ function emit(event) {
   if (eventHandler)
     eventHandler(event);
 }
+function assertionDescription(result) {
+  return result.assertion.description || `${result.assertion.type}${result.assertion.selector ? ` ${result.assertion.selector}` : ""}`;
+}
+function summarizeAssertionResult(result) {
+  const description = assertionDescription(result);
+  if (result.passed)
+    return description;
+  const suffix = result.error ? `; ${result.error}` : "";
+  return `${description} (actual: ${result.actual}${suffix})`;
+}
+async function applyStructuredAssertionsToResult(input) {
+  const assertions = input.scenario.assertions ?? [];
+  if (assertions.length === 0) {
+    return {
+      status: input.status,
+      reasoning: input.reasoning,
+      assertionsPassed: [],
+      assertionsFailed: [],
+      assertionResults: []
+    };
+  }
+  const results = await evaluateAssertions(input.page, assertions, {
+    consoleErrors: input.consoleErrors
+  });
+  const assertionsPassed = results.filter((r) => r.passed).map(summarizeAssertionResult);
+  const assertionsFailed = results.filter((r) => !r.passed).map(summarizeAssertionResult);
+  const assertionResults = results.map((result) => ({
+    type: result.assertion.type,
+    description: assertionDescription(result),
+    passed: result.passed,
+    actual: result.actual,
+    ...result.error ? { error: result.error } : {}
+  }));
+  const assertionsOk = allAssertionsPassed(results);
+  const status = assertionsOk || input.status !== "passed" ? input.status : "failed";
+  const assertionHeading = assertionsOk ? "Structured assertions passed:" : "Structured assertions failed:";
+  const reasoningParts = [input.reasoning, `${assertionHeading}
+${formatAssertionResults(results)}`].map((part) => part.trim()).filter(Boolean);
+  return {
+    status,
+    reasoning: reasoningParts.join(`
+
+`),
+    assertionsPassed,
+    assertionsFailed,
+    assertionResults
+  };
+}
 function withTimeout(promise, ms, label) {
   return new Promise((resolve, reject) => {
     const warningAt = Math.floor(ms * 0.8);
@@ -17834,6 +18348,7 @@ async function runSingleScenario(scenario, runId, options) {
       model,
       runId,
       sessionId: result.id,
+      baseUrl: options.url,
       maxTurns: effectiveOptions.minimal ? 10 : 30,
       a11y: effectiveOptions.a11y,
       persona: persona ? {
@@ -17916,27 +18431,46 @@ async function runSingleScenario(scenario, runId, options) {
     closeSession(result.id);
     const lightpandaNote = options.engine === "lightpanda" ? " (Running with Lightpanda \u2014 no screenshots)" : options.engine === "bun" ? " (Running with Bun.WebView \u2014 native, ~11x faster)" : "";
     const networkMeta = networkErrors.length > 0 ? { networkErrors: networkErrors.slice(0, 20) } : {};
-    let updatedResult = updateResult(result.id, {
+    const baseReasoning = agentResult.reasoning ? agentResult.reasoning + lightpandaNote : lightpandaNote || "";
+    const assertionOutcome = await applyStructuredAssertionsToResult({
+      page,
+      scenario,
+      consoleErrors,
       status: agentResult.status,
-      reasoning: agentResult.reasoning ? agentResult.reasoning + lightpandaNote : lightpandaNote || undefined,
+      reasoning: baseReasoning
+    });
+    const structuredAssertionMeta = assertionOutcome.assertionResults.length > 0 ? {
+      structuredAssertions: {
+        passed: assertionOutcome.assertionsPassed,
+        failed: assertionOutcome.assertionsFailed,
+        results: assertionOutcome.assertionResults
+      }
+    } : {};
+    let updatedResult = updateResult(result.id, {
+      status: assertionOutcome.status,
+      reasoning: assertionOutcome.reasoning || undefined,
       stepsCompleted: agentResult.stepsCompleted,
       durationMs: Date.now() - new Date(result.createdAt).getTime(),
       tokensUsed: agentResult.tokensUsed,
       costCents: estimateCost(model, agentResult.tokensUsed),
-      metadata: { consoleLogs, ...networkErrors.length > 0 ? networkMeta : {} }
+      metadata: {
+        consoleLogs,
+        ...networkErrors.length > 0 ? networkMeta : {},
+        ...structuredAssertionMeta
+      }
     });
-    if (agentResult.status === "failed" || agentResult.status === "error") {
-      const failureAnalysis = analyzeFailure(null, agentResult.reasoning ?? null);
+    if (assertionOutcome.status === "failed" || assertionOutcome.status === "error") {
+      const failureAnalysis = analyzeFailure(null, assertionOutcome.reasoning ?? null);
       if (failureAnalysis) {
         updatedResult = updateResult(result.id, { failureAnalysis });
       }
     }
-    if (agentResult.status === "passed") {
+    if (assertionOutcome.status === "passed") {
       try {
         updateScenarioPassedCache(scenario.id, options.url);
       } catch {}
     }
-    const eventType = agentResult.status === "passed" ? "scenario:pass" : "scenario:fail";
+    const eventType = assertionOutcome.status === "passed" ? "scenario:pass" : "scenario:fail";
     emit({ type: eventType, scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
     return updatedResult;
   } catch (error) {
@@ -17961,7 +18495,8 @@ async function runSingleScenario(scenario, runId, options) {
   } finally {
     if (harPath) {
       try {
-        updateResult(result.id, { metadata: { harPath } });
+        const existing = getResult(result.id);
+        updateResult(result.id, { metadata: { ...existing?.metadata ?? {}, harPath } });
       } catch {}
     }
     if (browser) {
@@ -18133,22 +18668,31 @@ async function runBatch(scenarios, options) {
   }
   return { run: finalRun, results };
 }
-async function runByFilter(options) {
-  let scenarios;
+function findScenarioInList(scenarios, id) {
+  return scenarios.find((scenario) => scenario.id === id || scenario.shortId === id || scenario.id.startsWith(id)) ?? null;
+}
+function resolveScenariosForRun(options) {
   if (options.scenarioIds && options.scenarioIds.length > 0) {
-    const all = listScenarios({ projectId: options.projectId });
-    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
-    if (scenarios.length === 0 && options.projectId) {
-      const global2 = listScenarios({});
-      scenarios = global2.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
+    const scoped = listScenarios({ projectId: options.projectId });
+    const resolved = [];
+    const seen = new Set;
+    for (const id of options.scenarioIds) {
+      const scenario = findScenarioInList(scoped, id) ?? getScenario(id);
+      if (scenario && !seen.has(scenario.id)) {
+        resolved.push(scenario);
+        seen.add(scenario.id);
+      }
     }
-  } else {
-    scenarios = listScenarios({
-      projectId: options.projectId,
-      tags: options.tags,
-      priority: options.priority
-    });
+    return resolved;
   }
+  return listScenarios({
+    projectId: options.projectId,
+    tags: options.tags,
+    priority: options.priority
+  });
+}
+async function runByFilter(options) {
+  const scenarios = resolveScenariosForRun(options);
   if (scenarios.length === 0) {
     const config = loadConfig();
     const model = resolveModel(options.model ?? config.defaultModel);
@@ -18161,17 +18705,7 @@ async function runByFilter(options) {
 function startRunAsync(options) {
   const config = loadConfig();
   const model = resolveModel(options.model ?? config.defaultModel);
-  let scenarios;
-  if (options.scenarioIds && options.scenarioIds.length > 0) {
-    const all = listScenarios({ projectId: options.projectId });
-    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
-  } else {
-    scenarios = listScenarios({
-      projectId: options.projectId,
-      tags: options.tags,
-      priority: options.priority
-    });
-  }
+  const scenarios = resolveScenariosForRun(options);
   if (!options.skipBudgetCheck) {
     const cap = options.maxCostCents ?? config.defaultMaxCostCents;
     if (cap !== undefined && cap > 0 && scenarios.length > 0) {
@@ -18275,6 +18809,7 @@ var init_runner = __esm(() => {
   init_session_tracker();
   init_webhooks();
   init_failure_pipeline();
+  init_assertions();
 });
 
 // src/lib/reporter.ts
@@ -25414,18 +25949,7 @@ function normalizeFilter(input) {
   };
 }
 function normalizeExecution(input) {
-  const target = input?.target ?? "local";
-  if (target === "connector:e2b") {
-    return {
-      target,
-      connector: input?.connector ?? "e2b",
-      operation: input?.operation ?? "run",
-      sandboxTemplate: input?.sandboxTemplate,
-      timeoutMs: input?.timeoutMs,
-      env: input?.env
-    };
-  }
-  return { ...DEFAULT_EXECUTION, timeoutMs: input?.timeoutMs };
+  return input ? workflowExecutionFromValue(input) : DEFAULT_EXECUTION;
 }
 function createTestingWorkflow(input) {
   const db2 = getDatabase();
@@ -26029,11 +26553,11 @@ import { existsSync as existsSync42, writeFileSync as writeFileSync32, readFileS
 import { join as join42 } from "path";
 import { Database as Database4 } from "bun:sqlite";
 import { existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname4, join as join18, resolve as resolve3 } from "path";
-import { existsSync as existsSync22, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join19, resolve as resolve2 } from "path";
+import { existsSync as existsSync22, writeFileSync as writeFileSync7 } from "fs";
 import { join as join22 } from "path";
 import { execSync as execSync3, execFileSync } from "child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync8, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync7, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join32, dirname as dirname22 } from "path";
 import { hostname } from "os";
@@ -26204,12 +26728,12 @@ function getDbPath2() {
     return process.env["PROJECTS_DB_PATH"];
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join18(home, ".hasna", "projects", "projects.db");
+  return join19(home, ".hasna", "projects", "projects.db");
 }
 function ensureDir2(filePath) {
   if (filePath === ":memory:")
     return;
-  const dir = dirname4(resolve3(filePath));
+  const dir = dirname4(resolve2(filePath));
   if (!existsSync16(dir)) {
     mkdirSync13(dir, { recursive: true });
   }
@@ -26249,7 +26773,7 @@ function gitInit(project) {
   execSync3("git init", { cwd: path, stdio: "pipe" });
   const gitignorePath = join22(path, ".gitignore");
   if (!existsSync22(gitignorePath)) {
-    writeFileSync6(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
+    writeFileSync7(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
   }
   const projectJson = {
     id,
@@ -26258,7 +26782,7 @@ function gitInit(project) {
     created_at: project.created_at,
     integrations: project.integrations ?? {}
   };
-  writeFileSync6(join22(path, ".project.json"), JSON.stringify(projectJson, null, 2) + `
+  writeFileSync7(join22(path, ".project.json"), JSON.stringify(projectJson, null, 2) + `
 `, "utf-8");
   execSync3("git add .gitignore .project.json", { cwd: path, stdio: "pipe" });
   execSync3(`git commit -m "chore: init project ${name}"`, {
@@ -26270,7 +26794,7 @@ function gitInit(project) {
 function getConfig() {
   if (existsSync32(CONFIG_PATH3)) {
     try {
-      const user = JSON.parse(readFileSync8(CONFIG_PATH3, "utf-8"));
+      const user = JSON.parse(readFileSync7(CONFIG_PATH3, "utf-8"));
       return { ...DEFAULTS, ...user };
     } catch {
       return { ...DEFAULTS };
@@ -42345,11 +42869,11 @@ More information can be found at: https://a.co/c895JFp`);
     var numberSelector = (obj, key, type2) => {
       if (!(key in obj))
         return;
-      const numberValue = parseInt(obj[key], 10);
-      if (Number.isNaN(numberValue)) {
+      const numberValue2 = parseInt(obj[key], 10);
+      if (Number.isNaN(numberValue2)) {
         throw new TypeError(`Cannot load ${type2} '${key}'. Expected number, got '${obj[key]}'.`);
       }
-      return numberValue;
+      return numberValue2;
     };
     exports.SelectorType = undefined;
     (function(SelectorType2) {
@@ -57095,7 +57619,7 @@ __export(exports_openapi_import, {
   importFromOpenAPI: () => importFromOpenAPI,
   importApiChecksFromOpenAPI: () => importApiChecksFromOpenAPI
 });
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 function parseSpec(content) {
   try {
     return JSON.parse(content);
@@ -57124,7 +57648,7 @@ function parseOpenAPISpec(filePathOrUrl) {
   if (filePathOrUrl.startsWith("http")) {
     throw new Error("URL fetching not supported yet. Download the spec file first.");
   }
-  content = readFileSync9(filePathOrUrl, "utf-8");
+  content = readFileSync8(filePathOrUrl, "utf-8");
   const spec = parseSpec(content);
   const isOpenAPI3 = !!spec.openapi;
   const isSwagger2 = !!spec.swagger;
@@ -57187,7 +57711,7 @@ function parseOpenAPISpecAsChecks(filePathOrUrl) {
   if (filePathOrUrl.startsWith("http")) {
     throw new Error("URL fetching not supported yet. Download the spec file first.");
   }
-  content = readFileSync9(filePathOrUrl, "utf-8");
+  content = readFileSync8(filePathOrUrl, "utf-8");
   const spec = parseSpec(content);
   if (!spec.openapi && !spec.swagger) {
     throw new Error("Not a valid OpenAPI 3.x or Swagger 2.0 spec");
@@ -57527,7 +58051,7 @@ async function recordSession(url, options) {
   await Promise.race([
     page.waitForEvent("close").catch(() => {}),
     context.waitForEvent("close").catch(() => {}),
-    new Promise((resolve4) => setTimeout(resolve4, timeout))
+    new Promise((resolve3) => setTimeout(resolve3, timeout))
   ]);
   clearInterval(pollInterval);
   try {
@@ -75898,7 +76422,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve4(value) {
+async function resolve3(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -77585,7 +78109,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     try {
       const { value } = await getFromApi({
         url: `${this.config.baseURL}/config`,
-        headers: await resolve4(this.config.headers()),
+        headers: await resolve3(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayAvailableModelsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -77603,7 +78127,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       const baseUrl = new URL(this.config.baseURL);
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/credits`,
-        headers: await resolve4(this.config.headers()),
+        headers: await resolve3(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayCreditsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -77649,7 +78173,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       }
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
-        headers: await resolve4(this.config.headers()),
+        headers: await resolve3(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewaySpendReportResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -77671,7 +78195,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       const baseUrl = new URL(this.config.baseURL);
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/generation?id=${encodeURIComponent(params.id)}`,
-        headers: await resolve4(this.config.headers()),
+        headers: await resolve3(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayGenerationInfoResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -77704,7 +78228,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -77712,7 +78236,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue: rawResponse
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve4(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve3(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createJsonResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -77735,11 +78259,11 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve4(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve3(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createEventSourceResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -77824,7 +78348,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     providerOptions
   }) {
     var _a92;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -77832,7 +78356,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
         body: {
           values,
           ...providerOptions ? { providerOptions } : {}
@@ -77888,7 +78412,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal
   }) {
     var _a92, _b92, _c2, _d2;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -77896,7 +78420,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
         body: {
           prompt,
           n: n2,
@@ -77971,11 +78495,11 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal
   }) {
     var _a92;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const { responseHeaders, value: responseBody } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders), { accept: "text/event-stream" }),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders), { accept: "text/event-stream" }),
         body: {
           prompt,
           n: n2,
@@ -78098,7 +78622,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal,
     providerOptions
   }) {
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -78106,7 +78630,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
         body: {
           documents,
           query,
@@ -87524,7 +88048,7 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
   const schema = asSchema(inputSchema);
   return {
     name: "object",
-    responseFormat: resolve4(schema.jsonSchema).then((jsonSchema2) => ({
+    responseFormat: resolve3(schema.jsonSchema).then((jsonSchema2) => ({
       type: "json",
       schema: jsonSchema2,
       ...name21 != null && { name: name21 },
@@ -87585,7 +88109,7 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
   const elementSchema = asSchema(inputElementSchema);
   return {
     name: "array",
-    responseFormat: resolve4(elementSchema.jsonSchema).then((jsonSchema2) => {
+    responseFormat: resolve3(elementSchema.jsonSchema).then((jsonSchema2) => {
       const { $schema, ...itemSchema } = jsonSchema2;
       return {
         type: "json",
@@ -90482,9 +91006,9 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
     ...options
   }) {
     var _a21, _b16, _c2, _d2, _e2;
-    const resolvedBody = await resolve4(this.body);
-    const resolvedHeaders = await resolve4(this.headers);
-    const resolvedCredentials = await resolve4(this.credentials);
+    const resolvedBody = await resolve3(this.body);
+    const resolvedHeaders = await resolve3(this.headers);
+    const resolvedCredentials = await resolve3(this.credentials);
     const baseHeaders = {
       ...normalizeHeaders(resolvedHeaders),
       ...normalizeHeaders(options.headers)
@@ -90532,9 +91056,9 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
   }
   async reconnectToStream(options) {
     var _a21, _b16, _c2, _d2, _e2;
-    const resolvedBody = await resolve4(this.body);
-    const resolvedHeaders = await resolve4(this.headers);
-    const resolvedCredentials = await resolve4(this.credentials);
+    const resolvedBody = await resolve3(this.body);
+    const resolvedHeaders = await resolve3(this.headers);
+    const resolvedCredentials = await resolve3(this.credentials);
     const baseHeaders = {
       ...normalizeHeaders(resolvedHeaders),
       ...normalizeHeaders(options.headers)
@@ -92755,7 +93279,7 @@ __export(exports_session_converter, {
   convertSessionToScenario: () => convertSessionToScenario,
   convertSessionFile: () => convertSessionFile
 });
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { extname } from "path";
 function parseRrwebSession(events) {
   const result = [];
@@ -92941,7 +93465,7 @@ ${condensed}`;
   };
 }
 async function convertSessionFile(filePath, format, options) {
-  const raw = readFileSync10(filePath, "utf-8");
+  const raw = readFileSync9(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -92975,7 +93499,7 @@ function detectSessionFormat(filePath) {
   if (ext === ".har")
     return "har";
   try {
-    const content = readFileSync10(filePath, "utf-8").trim();
+    const content = readFileSync9(filePath, "utf-8").trim();
     const parsed = JSON.parse(content);
     if (Array.isArray(parsed) && parsed[0]?.type !== undefined && typeof parsed[0]?.timestamp === "number") {
       return "rrweb";
@@ -93419,7 +93943,7 @@ import chalk6 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/testers",
-  version: "0.0.33",
+  version: "0.0.35",
   description: "AI-powered QA testing CLI \u2014 spawns cheap AI agents to test web apps with headless browsers",
   type: "module",
   main: "dist/index.js",
@@ -93443,10 +93967,10 @@ var package_default = {
   ],
   scripts: {
     build: "bun run build:dashboard && bun run build:cli && bun run build:mcp && bun run build:server && bun run build:lib && bun run build:types",
-    "build:cli": "bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-    "build:mcp": "bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-    "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-    "build:lib": "bun build src/index.ts --outdir dist --target bun --external playwright --external @anthropic-ai/sdk --external @modelcontextprotocol/sdk --external @hasna/browser",
+    "build:cli": "bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+    "build:mcp": "bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+    "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+    "build:lib": "bun build src/index.ts --outdir dist --target bun --external playwright --external @anthropic-ai/sdk --external @modelcontextprotocol/sdk --external @hasna/browser --external @hasna/sandboxes",
     "build:types": "NODE_OPTIONS='--max-old-space-size=8192' tsc --emitDeclarationOnly --outDir dist --skipLibCheck || true",
     "build:dashboard": "cd dashboard && bun run build",
     "build:ext": "cd extension && bun run build",
@@ -93460,10 +93984,11 @@ var package_default = {
   },
   dependencies: {
     "@anthropic-ai/sdk": "^0.52.0",
-    "@hasna/browser": "^0.4.5",
+    "@hasna/browser": "^0.4.12",
     "@hasna/cloud": "^0.1.24",
     "@hasna/contacts": "^0.6.8",
     "@hasna/projects": "^0.1.42",
+    "@hasna/sandboxes": "^0.1.27",
     "@modelcontextprotocol/sdk": "^1.12.1",
     ai: "^6.0.175",
     chalk: "^5.4.1",
@@ -93516,9 +94041,9 @@ init_todos_connector();
 init_browser();
 import { render, Box, Text, useInput, useApp } from "ink";
 import React, { useState } from "react";
-import { readFileSync as readFileSync11, readdirSync as readdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync6, writeFileSync as writeFileSync8 } from "fs";
 import { createInterface } from "readline";
-import { join as join19, resolve as resolve5 } from "path";
+import { join as join20, resolve as resolve4 } from "path";
 
 // src/lib/init.ts
 init_paths();
@@ -95247,9 +95772,13 @@ init_flows();
 init_workflows();
 
 // src/lib/workflow-runner.ts
+init_database();
 init_workflows();
 init_personas();
 init_runner();
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir } from "os";
+import { join as join16 } from "path";
 function buildWorkflowRunPlan(workflow, options) {
   const runOptions = {
     url: options.url,
@@ -95266,10 +95795,10 @@ function buildWorkflowRunPlan(workflow, options) {
   return {
     workflow,
     runOptions,
-    connectorCommand: workflow.execution.target === "connector:e2b" ? buildConnectorCommand(workflow.execution, runOptions) : null
+    sandbox: workflow.execution.target === "sandbox" ? buildSandboxPlan(workflow, workflow.execution, runOptions) : null
   };
 }
-async function runTestingWorkflow(workflowId, options) {
+async function runTestingWorkflow(workflowId, options, dependencies = {}) {
   const workflow = getTestingWorkflow(workflowId);
   if (!workflow)
     throw new Error(`Testing workflow not found: ${workflowId}`);
@@ -95279,13 +95808,25 @@ async function runTestingWorkflow(workflowId, options) {
   const plan = buildWorkflowRunPlan(workflow, options);
   if (options.dryRun)
     return { run: null, results: [], plan };
-  if (workflow.execution.target === "connector:e2b") {
-    const connectorResult = await runViaConnector(plan);
-    return { run: null, results: [], plan, connectorResult };
+  if (workflow.execution.target === "sandbox") {
+    const sandboxResult = await runViaSandbox(plan, dependencies);
+    return { run: null, results: [], plan, sandboxResult };
   }
-  const { run, results } = await runByFilter(plan.runOptions);
+  const runLocal = dependencies.runByFilter ?? runByFilter;
+  const { run, results } = await runLocal(plan.runOptions);
   return { run, results, plan };
 }
+function createWorkflowDatabaseBundle(workflow, plan) {
+  if (!plan.sandbox)
+    throw new Error(`Workflow is not configured for sandbox execution: ${workflow.name}`);
+  const localDir = mkdtempSync(join16(tmpdir(), `testers-workflow-${workflow.id.slice(0, 8)}-`));
+  writeFileSync4(join16(localDir, "testers.db"), getDatabase().serialize());
+  return {
+    localDir,
+    remoteDir: plan.sandbox.stateRemoteDir,
+    cleanup: () => rmSync(localDir, { recursive: true, force: true })
+  };
+}
 function validatePersonaIds(workflow) {
   for (const personaId of workflow.personaIds) {
     if (!getPersona(personaId)) {
@@ -95293,46 +95834,109 @@ function validatePersonaIds(workflow) {
     }
   }
 }
-function buildConnectorCommand(execution, runOptions) {
-  const connector = execution.connector ?? "e2b";
-  const operation = execution.operation ?? "run";
-  const payload = JSON.stringify({
-    operation,
-    template: execution.sandboxTemplate,
+function buildSandboxPlan(workflow, execution, runOptions) {
+  const remoteDir = execution.sandboxRemoteDir ?? `/tmp/testers-workflow-${workflow.id.slice(0, 8)}`;
+  const stateRemoteDir = `${remoteDir.replace(/\/+$/, "")}/.testers-state`;
+  return {
+    provider: execution.provider,
+    image: execution.sandboxImage,
+    name: `testers-${workflow.id.slice(0, 8)}`,
+    remoteDir,
+    stateRemoteDir,
+    cleanup: execution.sandboxCleanup ?? "delete",
     timeoutMs: execution.timeoutMs,
-    env: execution.env ?? {},
-    command: [
-      "bunx",
-      "@hasna/testers",
-      "run",
-      runOptions.url,
-      ...runOptions.scenarioIds?.length ? ["--scenario", runOptions.scenarioIds.join(",")] : [],
-      ...runOptions.tags?.length ? runOptions.tags.flatMap((tag) => ["--tag", tag]) : [],
-      ...runOptions.priority ? ["--priority", runOptions.priority] : [],
-      ...runOptions.projectId ? ["--project", runOptions.projectId] : [],
-      ...runOptions.model ? ["--model", runOptions.model] : [],
-      "--json"
-    ]
-  });
-  return ["connectors", "run", connector, operation, payload];
+    env: execution.env,
+    command: buildSandboxCommand({
+      runOptions,
+      remoteDir,
+      dbPath: `${stateRemoteDir}/testers.db`,
+      setupCommand: execution.setupCommand,
+      packageSpec: execution.packageSpec ?? "@hasna/testers"
+    })
+  };
 }
-async function runViaConnector(plan) {
-  if (!plan.connectorCommand)
-    throw new Error("Workflow does not have a connector command");
-  const proc = Bun.spawn(plan.connectorCommand, {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: process.env
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  if (exitCode !== 0) {
-    throw new Error(`Connector execution failed (${exitCode}): ${stderr || stdout}`);
+function buildSandboxCommand(input) {
+  const args = [
+    "bunx",
+    input.packageSpec,
+    "run",
+    input.runOptions.url,
+    ...input.runOptions.scenarioIds?.length ? ["--scenario", input.runOptions.scenarioIds.join(",")] : [],
+    ...input.runOptions.tags?.length ? input.runOptions.tags.flatMap((tag) => ["--tag", tag]) : [],
+    ...input.runOptions.priority ? ["--priority", input.runOptions.priority] : [],
+    ...input.runOptions.projectId ? ["--project", input.runOptions.projectId] : [],
+    ...input.runOptions.model ? ["--model", input.runOptions.model] : [],
+    ...input.runOptions.headed ? ["--headed"] : [],
+    ...input.runOptions.parallel ? ["--parallel", String(input.runOptions.parallel)] : [],
+    ...input.runOptions.timeout ? ["--timeout", String(input.runOptions.timeout)] : [],
+    ...input.runOptions.personaIds?.length ? ["--persona", input.runOptions.personaIds.join(",")] : [],
+    "--no-auto-generate",
+    "--json"
+  ];
+  return [
+    "set -euo pipefail",
+    `mkdir -p ${shellQuote(input.remoteDir)}`,
+    `cd ${shellQuote(input.remoteDir)}`,
+    input.setupCommand,
+    `HASNA_TESTERS_DB_PATH=${shellQuote(input.dbPath)} ${args.map(shellQuote).join(" ")}`
+  ].filter(Boolean).join(`
+`);
+}
+async function runViaSandbox(plan, dependencies) {
+  if (!plan.sandbox)
+    throw new Error("Workflow does not have a sandbox plan");
+  const sandboxes = await resolveSandboxesRuntime(dependencies);
+  const createBundle = dependencies.createDatabaseBundle ?? createWorkflowDatabaseBundle;
+  const bundle = createBundle(plan.workflow, plan);
+  try {
+    const raw = await sandboxes.runCommandInSandbox({
+      command: plan.sandbox.command,
+      provider: plan.sandbox.provider,
+      name: plan.sandbox.name,
+      image: plan.sandbox.image,
+      sandboxTimeout: plan.sandbox.timeoutMs,
+      commandTimeoutMs: plan.sandbox.timeoutMs,
+      projectId: plan.workflow.projectId ?? undefined,
+      config: {
+        source: "testers",
+        workflowId: plan.workflow.id,
+        workflowName: plan.workflow.name
+      },
+      sandboxEnvVars: plan.sandbox.env,
+      cleanup: plan.sandbox.cleanup,
+      upload: {
+        localDir: bundle.localDir,
+        remoteDir: bundle.remoteDir
+      }
+    });
+    const exitCode = raw.result.exit_code ?? raw.result.exitCode ?? 0;
+    const stdout = raw.result.stdout ?? "";
+    const stderr = raw.result.stderr ?? "";
+    if (exitCode !== 0) {
+      throw new Error(`Sandbox workflow execution failed (${exitCode}): ${stderr || stdout}`);
+    }
+    return {
+      sandboxId: raw.sandbox.id,
+      sessionId: raw.session.id,
+      exitCode,
+      stdout,
+      stderr,
+      cleanup: raw.cleanup
+    };
+  } finally {
+    bundle.cleanup?.();
   }
-  return stdout.trim();
+}
+async function resolveSandboxesRuntime(dependencies) {
+  if (dependencies.sandboxes)
+    return dependencies.sandboxes;
+  if (dependencies.createSandboxesSDK)
+    return dependencies.createSandboxesSDK();
+  const mod = await import("@hasna/sandboxes");
+  return mod.createSandboxesSDK();
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 
 // src/db/environments.ts
@@ -95405,111 +96009,19 @@ function getDefaultEnvironment() {
 
 // src/cli/index.tsx
 init_ci();
-
-// src/lib/assertions.ts
-function parseAssertionString(str) {
-  const trimmed = str.trim();
-  if (trimmed === "no-console-errors") {
-    return { type: "no_console_errors", description: "No console errors" };
-  }
-  if (trimmed.startsWith("url:contains:")) {
-    const expected = trimmed.slice("url:contains:".length);
-    return { type: "url_contains", expected, description: `URL contains "${expected}"` };
-  }
-  if (trimmed.startsWith("title:contains:")) {
-    const expected = trimmed.slice("title:contains:".length);
-    return { type: "title_contains", expected, description: `Title contains "${expected}"` };
-  }
-  if (trimmed.startsWith("count:")) {
-    const rest = trimmed.slice("count:".length);
-    const eqIdx = rest.indexOf(" eq:");
-    if (eqIdx === -1) {
-      throw new Error(`Invalid count assertion format: ${str}. Expected "count:<selector> eq:<number>"`);
-    }
-    const selector = rest.slice(0, eqIdx);
-    const expected = parseInt(rest.slice(eqIdx + " eq:".length), 10);
-    return { type: "element_count", selector, expected, description: `${selector} count equals ${expected}` };
-  }
-  if (trimmed.startsWith("text:")) {
-    const rest = trimmed.slice("text:".length);
-    const containsIdx = rest.indexOf(" contains:");
-    const equalsIdx = rest.indexOf(" equals:");
-    if (containsIdx !== -1) {
-      const selector = rest.slice(0, containsIdx);
-      const expected = rest.slice(containsIdx + " contains:".length);
-      return { type: "text_contains", selector, expected, description: `${selector} text contains "${expected}"` };
-    }
-    if (equalsIdx !== -1) {
-      const selector = rest.slice(0, equalsIdx);
-      const expected = rest.slice(equalsIdx + " equals:".length);
-      return { type: "text_equals", selector, expected, description: `${selector} text equals "${expected}"` };
-    }
-    throw new Error(`Invalid text assertion format: ${str}. Expected "text:<selector> contains:<text>" or "text:<selector> equals:<text>"`);
-  }
-  if (trimmed.startsWith("selector:")) {
-    const rest = trimmed.slice("selector:".length);
-    const lastSpace = rest.lastIndexOf(" ");
-    if (lastSpace === -1) {
-      throw new Error(`Invalid selector assertion format: ${str}. Expected "selector:<selector> visible" or "selector:<selector> not-visible"`);
-    }
-    const selector = rest.slice(0, lastSpace);
-    const action = rest.slice(lastSpace + 1);
-    if (action === "visible") {
-      return { type: "visible", selector, description: `${selector} is visible` };
-    }
-    if (action === "not-visible") {
-      return { type: "not_visible", selector, description: `${selector} is not visible` };
-    }
-    throw new Error(`Unknown selector action: "${action}". Expected "visible" or "not-visible"`);
-  }
-  if (trimmed.startsWith("cookie:exists:")) {
-    const name = trimmed.slice("cookie:exists:".length);
-    return { type: "cookie_exists", expected: name, description: `Cookie "${name}" exists` };
-  }
-  if (trimmed.startsWith("cookie:not-exists:")) {
-    const name = trimmed.slice("cookie:not-exists:".length);
-    return { type: "cookie_not_exists", expected: name, description: `Cookie "${name}" does not exist` };
-  }
-  if (trimmed.startsWith("cookie:value:")) {
-    const valueStr = trimmed.slice("cookie:value:".length);
-    return { type: "cookie_value", expected: valueStr, description: `Cookie value is "${valueStr}"` };
-  }
-  if (trimmed.startsWith("local:exists:")) {
-    const key = trimmed.slice("local:exists:".length);
-    return { type: "local_storage_exists", expected: key, description: `LocalStorage key "${key}" exists` };
-  }
-  if (trimmed.startsWith("local:not-exists:")) {
-    const key = trimmed.slice("local:not-exists:".length);
-    return { type: "local_storage_not_exists", expected: key, description: `LocalStorage key "${key}" does not exist` };
-  }
-  if (trimmed.startsWith("local:value:")) {
-    const valueStr = trimmed.slice("local:value:".length);
-    return { type: "local_storage_value", expected: valueStr, description: `LocalStorage value is "${valueStr}"` };
-  }
-  if (trimmed.startsWith("session:value:")) {
-    const valueStr = trimmed.slice("session:value:".length);
-    return { type: "session_storage_value", expected: valueStr, description: `SessionStorage value is "${valueStr}"` };
-  }
-  if (trimmed.startsWith("session:not-exists:")) {
-    const key = trimmed.slice("session:not-exists:".length);
-    return { type: "session_storage_not_exists", expected: key, description: `SessionStorage key "${key}" does not exist` };
-  }
-  throw new Error(`Cannot parse assertion: "${str}". See --help for assertion formats.`);
-}
-
-// src/cli/index.tsx
+init_assertions();
 init_paths();
 init_sessions();
 import { existsSync as existsSync17, mkdirSync as mkdirSync14 } from "fs";
 
 // src/lib/repo-discovery.ts
 init_paths();
-import { existsSync as existsSync14, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4, mkdirSync as mkdirSync11, unlinkSync } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync5, mkdirSync as mkdirSync11, unlinkSync } from "fs";
 import { createHash } from "crypto";
-import { join as join16, resolve, relative as relative2 } from "path";
+import { join as join17, resolve, relative as relative2 } from "path";
 function getCacheDir() {
   const testersDir = getTestersDir();
-  const cacheDir = join16(testersDir, "repo-index");
+  const cacheDir = join17(testersDir, "repo-index");
   if (!existsSync14(cacheDir)) {
     mkdirSync11(cacheDir, { recursive: true });
   }
@@ -95519,11 +96031,11 @@ function pathHash(repoPath) {
   return createHash("sha256").update(repoPath).digest("hex").slice(0, 16);
 }
 function getCachePath(repoPath) {
-  return join16(getCacheDir(), `${pathHash(repoPath)}.json`);
+  return join17(getCacheDir(), `${pathHash(repoPath)}.json`);
 }
 function isCacheStale(cached, repoPath) {
   for (const spec of cached.specs) {
-    const fullPath = join16(repoPath, spec.file);
+    const fullPath = join17(repoPath, spec.file);
     if (!existsSync14(fullPath))
       return true;
     try {
@@ -95535,11 +96047,11 @@ function isCacheStale(cached, repoPath) {
     }
   }
   if (cached.configPath) {
-    const configFullPath = join16(repoPath, cached.configPath);
+    const configFullPath = join17(repoPath, cached.configPath);
     if (!existsSync14(configFullPath))
       return true;
     try {
-      const stat = statSync(configFullPath);
+      statSync(configFullPath);
       const age = Date.now() - new Date(cached.snapshotAt).getTime();
       if (age > 3600000)
         return true;
@@ -95562,14 +96074,14 @@ function loadCache(repoPath) {
 }
 function saveCache(snapshot) {
   const cachePath = getCachePath(snapshot.repoPath);
-  writeFileSync4(cachePath, JSON.stringify(snapshot, null, 2), "utf-8");
+  writeFileSync5(cachePath, JSON.stringify(snapshot, null, 2), "utf-8");
 }
 function detectPackageManager(repoPath) {
   const result = {
-    npm: existsSync14(join16(repoPath, "package-lock.json")),
-    yarn: existsSync14(join16(repoPath, "yarn.lock")),
-    pnpm: existsSync14(join16(repoPath, "pnpm-lock.yaml")),
-    bun: existsSync14(join16(repoPath, "bun.lockb")) || existsSync14(join16(repoPath, "bun.lock")),
+    npm: existsSync14(join17(repoPath, "package-lock.json")),
+    yarn: existsSync14(join17(repoPath, "yarn.lock")),
+    pnpm: existsSync14(join17(repoPath, "pnpm-lock.yaml")),
+    bun: existsSync14(join17(repoPath, "bun.lockb")) || existsSync14(join17(repoPath, "bun.lock")),
     preferred: "npm"
   };
   if (result.bun)
@@ -95583,7 +96095,7 @@ function detectPackageManager(repoPath) {
   return result;
 }
 function detectDevScripts(repoPath) {
-  const pkgPath = join16(repoPath, "package.json");
+  const pkgPath = join17(repoPath, "package.json");
   if (!existsSync14(pkgPath)) {
     return { dev: null, test: null, seed: null, build: null };
   }
@@ -95610,7 +96122,7 @@ function findPlaywrightConfig(repoPath) {
     "playwright-ct.config.js"
   ];
   for (const name of candidates) {
-    if (existsSync14(join16(repoPath, name)))
+    if (existsSync14(join17(repoPath, name)))
       return name;
   }
   return null;
@@ -95619,7 +96131,7 @@ 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 = join16(repoPath, configPath);
+  const fullPath = join17(repoPath, configPath);
   let content;
   try {
     content = readFileSync6(fullPath, "utf-8");
@@ -95630,8 +96142,9 @@ function extractTestGlobPatterns(configPath, repoPath) {
   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);
+  const testMatchBody = testMatchArray?.[1];
+  if (testMatchBody) {
+    const items = testMatchBody.match(/['"`]([^'"`]+)['"`]/g);
     if (items) {
       for (const item of items) {
         patterns.push(item.replace(/['"`]/g, ""));
@@ -95639,8 +96152,9 @@ function extractTestGlobPatterns(configPath, repoPath) {
     }
   }
   const testMatchSingle = content.match(/testMatch\s*[:=]\s*['"`]([^'"`]+)['"`]/);
-  if (testMatchSingle) {
-    patterns.push(testMatchSingle[1]);
+  const singleTestMatch = testMatchSingle?.[1];
+  if (singleTestMatch) {
+    patterns.push(singleTestMatch);
   }
   if (testDir && patterns.length === 0) {
     patterns.push(`${testDir}/**/*.spec.ts`, `${testDir}/**/*.test.ts`, `${testDir}/**/*.spec.js`, `${testDir}/**/*.test.js`);
@@ -95666,7 +96180,7 @@ function findSpecFiles(repoPath, globPatterns) {
   for (const pattern of globPatterns) {
     const dirsToSearch = ["", ".", "tests", "e2e", "test", "__tests__", "specs", "src"];
     for (const dir of dirsToSearch) {
-      const searchDir = dir ? join16(repoPath, dir) : repoPath;
+      const searchDir = dir ? join17(repoPath, dir) : repoPath;
       if (!existsSync14(searchDir))
         continue;
       try {
@@ -95700,7 +96214,7 @@ function walkDir(dir) {
   try {
     const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join16(dir, entry.name);
+      const fullPath = join17(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -95718,7 +96232,7 @@ function matchesGlob(filePath, pattern) {
   return new RegExp(regex).test(filePath);
 }
 function detectSuggestedUrl(repoPath) {
-  const pkgPath = join16(repoPath, "package.json");
+  const pkgPath = join17(repoPath, "package.json");
   if (!existsSync14(pkgPath))
     return null;
   try {
@@ -95738,10 +96252,10 @@ function detectSuggestedUrl(repoPath) {
   return null;
 }
 function checkPlaywrightBrowserInstalled(repoPath) {
-  const cacheDir = join16(repoPath, "node_modules", ".cache", "ms-playwright");
+  const cacheDir = join17(repoPath, "node_modules", ".cache", "ms-playwright");
   if (existsSync14(cacheDir))
     return true;
-  const globalCache = join16(repoPath, ".cache", "ms-playwright");
+  const globalCache = join17(repoPath, ".cache", "ms-playwright");
   if (existsSync14(globalCache))
     return true;
   return false;
@@ -95758,7 +96272,7 @@ function getInstallCommand(pm) {
       return "bun install";
   }
 }
-function getPlaywrightInstallCommand(pm) {
+function getPlaywrightInstallCommand(_pm) {
   return "npx playwright install";
 }
 function discoverRepo(opts) {
@@ -95773,7 +96287,7 @@ function discoverRepo(opts) {
   let configRaw = null;
   if (configPath) {
     try {
-      configRaw = readFileSync6(join16(repoPath, configPath), "utf-8");
+      configRaw = readFileSync6(join17(repoPath, configPath), "utf-8");
     } catch {
       configRaw = null;
     }
@@ -95782,7 +96296,7 @@ function discoverRepo(opts) {
   const specs = findSpecFiles(repoPath, globPatterns);
   const packageManager = detectPackageManager(repoPath);
   const devScripts = detectDevScripts(repoPath);
-  const playwrightInstalled = existsSync14(join16(repoPath, "node_modules", "playwright")) || existsSync14(join16(repoPath, "node_modules", "@playwright", "test"));
+  const playwrightInstalled = existsSync14(join17(repoPath, "node_modules", "playwright")) || existsSync14(join17(repoPath, "node_modules", "@playwright", "test"));
   const browsersInstalled = checkPlaywrightBrowserInstalled(repoPath);
   const configExists = configPath !== null;
   const specsFound = specs.length > 0;
@@ -95851,7 +96365,7 @@ function clearDiscoveryCache(repoPath) {
   } else {
     for (const file of readdirSync3(cacheDir)) {
       if (file.endsWith(".json")) {
-        unlinkSync(join16(cacheDir, file));
+        unlinkSync(join17(cacheDir, file));
       }
     }
   }
@@ -95875,10 +96389,10 @@ init_runs();
 init_database();
 init_paths();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync12, writeFileSync as writeFileSync5 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, writeFileSync as writeFileSync6 } from "fs";
+import { join as join18 } from "path";
 function resolvePlaywrightCmd(repoPath) {
-  const localPw = join17(repoPath, "node_modules", ".bin", "playwright");
+  const localPw = join18(repoPath, "node_modules", ".bin", "playwright");
   if (existsSync15(localPw)) {
     return [localPw, "test"];
   }
@@ -95897,7 +96411,7 @@ function buildPlaywrightArgs(specFiles, extraArgs = []) {
 }
 function runPlaywright(repoPath, workingDir, specFiles, extraArgs, timeoutMs) {
   const cmd = resolvePlaywrightCmd(repoPath);
-  const args = buildPlaywrightArgs(specFiles, extraArgs, workingDir);
+  const args = buildPlaywrightArgs(specFiles, extraArgs);
   const startTime = Date.now();
   try {
     const result = execSync2(`${cmd.join(" ")} ${args.join(" ")}`, {
@@ -95925,7 +96439,7 @@ function runPlaywright(repoPath, workingDir, specFiles, extraArgs, timeoutMs) {
     };
   }
 }
-function parsePlaywrightJsonOutput(stdout, stderr) {
+function parsePlaywrightJsonOutput(stdout, _stderr) {
   const testResults = [];
   try {
     const obj = JSON.parse(stdout);
@@ -96030,19 +96544,21 @@ async function runRepoTests(opts) {
   const workingDir = opts.snapshot.workingDir;
   const repoPath = snapshot.repoPath;
   const url = opts.url ?? snapshot.suggestedUrl ?? "http://localhost:3000";
-  const run = createRun({
+  const initialRun = createRun({
     projectId: opts.projectId,
     url,
     model: opts.model ?? "repo-native",
     headed: false,
-    parallel: 1,
-    metadata: {
+    parallel: 1
+  });
+  const run = updateRun(initialRun.id, {
+    metadata: JSON.stringify({
       runType: "repo-native",
       repoPath,
       configPath: snapshot.configPath,
       cacheKey: snapshot.cacheKey,
       label: opts.label
-    }
+    })
   });
   const specResults = [];
   const startTime = Date.now();
@@ -96072,10 +96588,10 @@ async function runRepoTests(opts) {
     }
     const resultRecord = { id: resultId };
     if (result.stdout || result.stderr) {
-      const reportersDir = join17(getTestersDir(), "repo-run-output");
+      const reportersDir = join18(getTestersDir(), "repo-run-output");
       mkdirSync12(reportersDir, { recursive: true });
-      const outputFile = join17(reportersDir, `${resultRecord.id}.log`);
-      writeFileSync5(outputFile, `=== stdout ===
+      const outputFile = join18(reportersDir, `${resultRecord.id}.log`);
+      writeFileSync6(outputFile, `=== stdout ===
 ${result.stdout}
 
 === stderr ===
@@ -96182,6 +96698,10 @@ function processSyncEnv() {
 // src/cli/index.tsx
 import { jsxDEV } from "react/jsx-dev-runtime";
 var PRIORITIES = ["low", "medium", "high", "critical"];
+function splitCsvOption(value) {
+  const items = value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+  return items.length > 0 ? items : undefined;
+}
 function AddForm({ onComplete }) {
   const { exit } = useApp();
   const [state, setState] = useState({
@@ -96455,25 +96975,30 @@ program2.command("prod-debug <target>").description("Create a safe production de
   }, config2.prodDebug);
   const output = opts.json ? JSON.stringify(plan, null, 2) : formatProdDebugPlan(plan);
   if (opts.output) {
-    writeFileSync7(resolve5(opts.output), output + `
+    writeFileSync8(resolve4(opts.output), output + `
 `);
   } else {
     log(output);
   }
 });
 var CONFIG_DIR5 = getTestersDir();
-var CONFIG_PATH4 = join19(CONFIG_DIR5, "config.json");
+var CONFIG_PATH4 = join20(CONFIG_DIR5, "config.json");
 function getActiveProject() {
   try {
     if (existsSync17(CONFIG_PATH4)) {
-      const raw = JSON.parse(readFileSync11(CONFIG_PATH4, "utf-8"));
+      const raw = JSON.parse(readFileSync10(CONFIG_PATH4, "utf-8"));
       return raw.activeProject ?? undefined;
     }
   } catch {}
   return;
 }
 function resolveProject2(optProject) {
-  return optProject ?? getActiveProject();
+  if (optProject)
+    return optProject;
+  const activeProject = getActiveProject();
+  if (!activeProject)
+    return;
+  return getProject(activeProject) ? activeProject : undefined;
 }
 program2.command("add [name]").alias("create").description("Create a new test scenario (interactive if no name/flags given)").option("-d, --description <text>", "Scenario description", "").option("-s, --steps <step>", "Test step (repeatable)", (val, acc) => {
   acc.push(val);
@@ -96658,7 +97183,7 @@ program2.command("delete <id>").description("Delete a scenario").option("-y, --y
     }
     if (!opts.yes) {
       process.stdout.write(chalk6.yellow(`Delete scenario ${scenario.shortId} "${scenario.name}"? [y/N] `));
-      const answer = await new Promise((resolve6) => {
+      const answer = await new Promise((resolve5) => {
         let buf = "";
         process.stdin.setRawMode?.(true);
         process.stdin.resume();
@@ -96668,7 +97193,7 @@ program2.command("delete <id>").description("Delete a scenario").option("-y, --y
           process.stdin.pause();
           process.stdout.write(`
 `);
-          resolve6(buf);
+          resolve5(buf);
         });
       });
       if (answer !== "y" && answer !== "yes") {
@@ -96697,7 +97222,7 @@ program2.command("remove <id>").alias("uninstall").description("Remove a scenari
     }
     if (!opts.yes) {
       process.stdout.write(chalk6.yellow(`Remove scenario ${scenario.shortId} "${scenario.name}"? [y/N] `));
-      const answer = await new Promise((resolve6) => {
+      const answer = await new Promise((resolve5) => {
         let buf = "";
         process.stdin.setRawMode?.(true);
         process.stdin.resume();
@@ -96707,7 +97232,7 @@ program2.command("remove <id>").alias("uninstall").description("Remove a scenari
           process.stdin.pause();
           process.stdout.write(`
 `);
-          resolve6(buf);
+          resolve5(buf);
         });
       });
       if (answer !== "y" && answer !== "yes") {
@@ -96753,6 +97278,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
       logError(chalk6.red("No URL provided. Pass a URL argument, use --env <name>, or set a default environment with 'testers env use <name>'."));
       process.exit(2);
     }
+    const scenarioIds = splitCsvOption(opts.scenario);
     if (!opts.dryRun) {
       const hasAnthropic = Boolean(process.env["ANTHROPIC_API_KEY"]);
       const hasOpenAI = Boolean(process.env["OPENAI_API_KEY"]);
@@ -96823,7 +97349,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
         tags: opts.tag.length > 0 ? opts.tag : undefined,
         projectId
       }).filter((s2) => {
-        if (opts.scenario && s2.id !== opts.scenario && s2.shortId !== opts.scenario)
+        if (scenarioIds && !scenarioIds.includes(s2.id) && !scenarioIds.includes(s2.shortId))
           return false;
         if (opts.priority && s2.priority !== opts.priority)
           return false;
@@ -96872,7 +97398,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
       const { runId, scenarioCount } = startRunAsync({
         url: url2,
         tags: opts.tag.length > 0 ? opts.tag : undefined,
-        scenarioIds: opts.scenario ? [opts.scenario] : undefined,
+        scenarioIds,
         priority: opts.priority,
         model: opts.model,
         headed: opts.headed,
@@ -96906,7 +97432,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
 `);
           }
         };
-        await new Promise((resolve6) => {
+        await new Promise((resolve5) => {
           const poll = setInterval(() => {
             const run3 = getRun(runId);
             if (!run3)
@@ -96914,7 +97440,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
             renderTable();
             if (DONE_STATUSES.has(run3.status)) {
               clearInterval(poll);
-              resolve6();
+              resolve5();
             }
           }, POLL_INTERVAL);
         });
@@ -97007,7 +97533,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
       if (opts.json || opts.output) {
         const jsonOutput = formatJSON(run3, results2);
         if (opts.output) {
-          writeFileSync7(opts.output, jsonOutput, "utf-8");
+          writeFileSync8(opts.output, jsonOutput, "utf-8");
           log(chalk6.green(`Results written to ${opts.output}`));
         }
         if (opts.json) {
@@ -97030,7 +97556,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
       }
       process.exit(getExitCode(run3));
     }
-    const noFilters = !opts.scenario && opts.tag.length === 0 && !opts.priority;
+    const noFilters = !scenarioIds && opts.tag.length === 0 && !opts.priority;
     if (noFilters && !opts.json && !opts.output) {
       const allScenarios = listScenarios({ projectId });
       log(chalk6.bold(`  Running all ${allScenarios.length} scenarios...`));
@@ -97094,7 +97620,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
     const { run: run2, results } = await runByFilter({
       url: url2,
       tags: opts.tag.length > 0 ? opts.tag : undefined,
-      scenarioIds: diffScenarioIds ?? (opts.scenario ? [opts.scenario] : undefined),
+      scenarioIds: diffScenarioIds ?? scenarioIds,
       priority: opts.priority,
       model: opts.model,
       headed: opts.headed,
@@ -97116,7 +97642,7 @@ program2.command("run [url] [description]").alias("test").description("Run test
     if (opts.json || opts.output) {
       const jsonOutput = formatJSON(run2, results);
       if (opts.output) {
-        writeFileSync7(opts.output, jsonOutput, "utf-8");
+        writeFileSync8(opts.output, jsonOutput, "utf-8");
         log(chalk6.green(`Results written to ${opts.output}`));
       }
       if (opts.json) {
@@ -97306,7 +97832,7 @@ program2.command("screenshots <id>").description("List screenshots for a run or
 });
 program2.command("import <dir>").description("Import markdown test files as scenarios").action((dir) => {
   try {
-    const absDir = resolve5(dir);
+    const absDir = resolve4(dir);
     const files = readdirSync6(absDir).filter((f2) => f2.endsWith(".md"));
     if (files.length === 0) {
       log(chalk6.dim("No .md files found in directory."));
@@ -97314,7 +97840,7 @@ program2.command("import <dir>").description("Import markdown test files as scen
     }
     let imported = 0;
     for (const file2 of files) {
-      const content = readFileSync11(join19(absDir, file2), "utf-8");
+      const content = readFileSync10(join20(absDir, file2), "utf-8");
       const lines = content.split(`
 `);
       let name21 = file2.replace(/\.md$/, "");
@@ -97369,8 +97895,8 @@ program2.command("export [format]").description("Export scenarios as JSON (defau
     if (fmt === "json") {
       const outputPath = opts.output ?? "testers-export.json";
       const data = JSON.stringify(scenarios, null, 2);
-      writeFileSync7(outputPath, data, "utf-8");
-      log(chalk6.green(`Exported ${scenarios.length} scenario(s) to ${resolve5(outputPath)}`));
+      writeFileSync8(outputPath, data, "utf-8");
+      log(chalk6.green(`Exported ${scenarios.length} scenario(s) to ${resolve4(outputPath)}`));
       return;
     }
     const outputDir = opts.output ?? ".";
@@ -97402,13 +97928,13 @@ program2.command("export [format]").description("Export scenarios as JSON (defau
         lines.push("");
       }
       const safeFilename = s2.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-      const filePath = join19(outputDir, `${s2.shortId}-${safeFilename}.md`);
-      writeFileSync7(filePath, lines.join(`
+      const filePath = join20(outputDir, `${s2.shortId}-${safeFilename}.md`);
+      writeFileSync8(filePath, lines.join(`
 `), "utf-8");
       log(chalk6.dim(`  ${s2.shortId}: ${s2.name} \u2192 ${filePath}`));
     }
     log(chalk6.green(`
-Exported ${scenarios.length} scenario(s) as markdown to ${resolve5(outputDir)}`));
+Exported ${scenarios.length} scenario(s) as markdown to ${resolve4(outputDir)}`));
   } catch (error40) {
     logError(chalk6.red(`Error: ${error40 instanceof Error ? error40.message : String(error40)}`));
     process.exit(1);
@@ -97427,7 +97953,7 @@ program2.command("status").description("Show database and auth status").action((
   try {
     const config2 = loadConfig();
     const hasApiKey = !!config2.anthropicApiKey || !!process.env["ANTHROPIC_API_KEY"];
-    const dbPath = join19(getTestersDir(), "testers.db");
+    const dbPath = join20(getTestersDir(), "testers.db");
     log("");
     log(chalk6.bold("  Open Testers Status"));
     log("");
@@ -97581,11 +98107,11 @@ projectCmd.command("use <name>").description("Set active project (find or create
     let config2 = {};
     if (existsSync17(CONFIG_PATH4)) {
       try {
-        config2 = JSON.parse(readFileSync11(CONFIG_PATH4, "utf-8"));
+        config2 = JSON.parse(readFileSync10(CONFIG_PATH4, "utf-8"));
       } catch {}
     }
     config2.activeProject = project.id;
-    writeFileSync7(CONFIG_PATH4, JSON.stringify(config2, null, 2), "utf-8");
+    writeFileSync8(CONFIG_PATH4, JSON.stringify(config2, null, 2), "utf-8");
     if (opts.json) {
       log(JSON.stringify({ activeProject: project.id, project }, null, 2));
       return;
@@ -97599,7 +98125,7 @@ projectCmd.command("use <name>").description("Set active project (find or create
 var repoCmd = program2.command("repo").description("Discover and run repo-native Playwright tests");
 repoCmd.command("discover [path]").alias("scan").description("Discover Playwright tests in a repo").option("--refresh", "Force a fresh scan, ignoring cache", false).option("--json", "Output as JSON", false).option("--base-url <url>", "Override the suggested base URL").action((path, opts) => {
   try {
-    const repoPath = resolve5(path ?? process.cwd());
+    const repoPath = resolve4(path ?? process.cwd());
     const snapshot = discoverRepo({
       repoPath,
       refresh: opts.refresh,
@@ -97665,7 +98191,7 @@ repoCmd.command("discover [path]").alias("scan").description("Discover Playwrigh
 });
 repoCmd.command("prepare [path]").alias("prep").description("Install dependencies and browsers for repo tests").option("--all", "Run all prep steps (install, browsers, build, seed)", false).option("--install", "Install dependencies", false).option("--browsers", "Install Playwright browsers", false).option("--build", "Build the app", false).option("--seed", "Seed the database", false).option("--refresh", "Force fresh discovery scan", false).option("--json", "Output as JSON", false).action((path, opts) => {
   try {
-    const repoPath = resolve5(path ?? process.cwd());
+    const repoPath = resolve4(path ?? process.cwd());
     const snapshot = discoverRepo({ repoPath, refresh: opts.refresh });
     const steps = [];
     if (opts.all) {
@@ -97743,7 +98269,7 @@ repoCmd.command("run [path]").description("Run discovered Playwright tests nativ
   return acc;
 }, []).option("--timeout <ms>", "Timeout per spec file", "300000").option("--url <url>", "Dev server URL").option("--project <id>", "Project ID for result storage").option("--label <text>", "Run label").option("--json", "Output as JSON", false).action(async (path, opts) => {
   try {
-    const repoPath = resolve5(path ?? process.cwd());
+    const repoPath = resolve4(path ?? process.cwd());
     const snapshot = discoverRepo({
       repoPath,
       refresh: opts.refresh,
@@ -97809,7 +98335,7 @@ repoCmd.command("run [path]").description("Run discovered Playwright tests nativ
 repoCmd.command("cache [path]").description("Manage discovery cache").option("--clear", "Clear discovery cache", false).option("--status", "Show cache status", false).action((path, opts) => {
   try {
     if (opts.clear) {
-      const repoPath2 = path ? resolve5(path) : undefined;
+      const repoPath2 = path ? resolve4(path) : undefined;
       clearDiscoveryCache(repoPath2);
       if (repoPath2) {
         log(chalk6.green("Discovery cache cleared for this repo."));
@@ -97819,7 +98345,7 @@ repoCmd.command("cache [path]").description("Manage discovery cache").option("--
       return;
     }
     if (opts.status) {
-      const repoPath2 = resolve5(path ?? process.cwd());
+      const repoPath2 = resolve4(path ?? process.cwd());
       const info2 = getDiscoveryCacheInfo(repoPath2);
       if (!info2) {
         log(chalk6.dim("No discovery cache for this repo."));
@@ -97833,7 +98359,7 @@ repoCmd.command("cache [path]").description("Manage discovery cache").option("--
       log("");
       return;
     }
-    const repoPath = resolve5(path ?? process.cwd());
+    const repoPath = resolve4(path ?? process.cwd());
     const info = getDiscoveryCacheInfo(repoPath);
     if (!info) {
       log(chalk6.dim("No discovery cache. Run 'testers repo discover' to create one."));
@@ -97922,8 +98448,8 @@ sessionCmd.command("show <id>").description("Show details of a recorded session"
 });
 sessionCmd.command("import <file>").description("Import a session JSON file exported from the Chrome extension").action(async (file2) => {
   try {
-    const { readFileSync: readFileSync12 } = await import("fs");
-    const raw = readFileSync12(file2, "utf-8");
+    const { readFileSync: readFileSync11 } = await import("fs");
+    const raw = readFileSync11(file2, "utf-8");
     const data = JSON.parse(raw);
     const items = Array.isArray(data) ? data : [data];
     const { createSession: createSession2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
@@ -98163,7 +98689,7 @@ program2.command("daemon").description("Start the scheduler daemon").option("--i
         } catch (err) {
           logError(chalk6.red(`Daemon error: ${err instanceof Error ? err.message : String(err)}`));
         }
-        await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+        await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
       }
     };
     process.on("SIGINT", () => {
@@ -98192,12 +98718,12 @@ program2.command("ci [provider]").description("Print or write a CI workflow (def
   }
   const workflow = generateGitHubActionsWorkflow();
   if (opts.output) {
-    const outPath = resolve5(opts.output);
+    const outPath = resolve4(opts.output);
     const outDir = outPath.replace(/\/[^/]*$/, "");
     if (outDir && !existsSync17(outDir)) {
       mkdirSync14(outDir, { recursive: true });
     }
-    writeFileSync7(outPath, workflow, "utf-8");
+    writeFileSync8(outPath, workflow, "utf-8");
     log(chalk6.green(`Workflow written to ${outPath}`));
     return;
   }
@@ -98228,12 +98754,12 @@ program2.command("init").description("Initialize a new testing project").option(
       log(`    ${chalk6.dim(s2.shortId)} ${s2.name} ${chalk6.dim(`[${s2.tags.join(", ")}]`)}`);
     }
     if (opts.ci === "github") {
-      const workflowDir = join19(process.cwd(), ".github", "workflows");
+      const workflowDir = join20(process.cwd(), ".github", "workflows");
       if (!existsSync17(workflowDir)) {
         mkdirSync14(workflowDir, { recursive: true });
       }
-      const workflowPath = join19(workflowDir, "testers.yml");
-      writeFileSync7(workflowPath, generateGitHubActionsWorkflow(), "utf-8");
+      const workflowPath = join20(workflowDir, "testers.yml");
+      writeFileSync8(workflowPath, generateGitHubActionsWorkflow(), "utf-8");
       log(`  CI:         ${chalk6.green("GitHub Actions workflow written to .github/workflows/testers.yml")}`);
     } else if (opts.ci) {
       log(chalk6.yellow(`  Unknown CI provider: ${opts.ci}. Supported: github`));
@@ -98242,7 +98768,7 @@ program2.command("init").description("Initialize a new testing project").option(
     if (opts.yes)
       return;
     const rl2 = createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (q2) => new Promise((resolve6) => rl2.question(q2, resolve6));
+    const ask = (q2) => new Promise((resolve5) => rl2.question(q2, resolve5));
     try {
       const envAnswer = await ask("  Would you like to configure environments? [y/N] ");
       if (envAnswer.trim().toLowerCase() === "y") {
@@ -98427,8 +98953,8 @@ program2.command("report [run-id]").description("Generate HTML test report or co
         format
       });
       if (opts.output && opts.output !== "report.html") {
-        writeFileSync7(opts.output, content, "utf-8");
-        const absPath2 = resolve5(opts.output);
+        writeFileSync8(opts.output, content, "utf-8");
+        const absPath2 = resolve4(opts.output);
         log(chalk6.green(`Compliance report written to ${absPath2}`));
       } else {
         log(content);
@@ -98441,8 +98967,8 @@ program2.command("report [run-id]").description("Generate HTML test report or co
     } else {
       html = generateHtmlReport(runId);
     }
-    writeFileSync7(opts.output, html, "utf-8");
-    const absPath = resolve5(opts.output);
+    writeFileSync8(opts.output, html, "utf-8");
+    const absPath = resolve4(opts.output);
     log(chalk6.green(`Report generated: ${absPath}`));
     if (opts.open) {
       const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
@@ -99251,7 +99777,7 @@ program2.command("doctor").description("Check system setup and configuration").a
     log(chalk6.red("\u2717") + " ANTHROPIC_API_KEY is not set (required for AI-powered tests)");
     allPassed = false;
   }
-  const dbPath = join19(getTestersDir(), "testers.db");
+  const dbPath = join20(getTestersDir(), "testers.db");
   try {
     const { Database: Database5 } = await import("bun:sqlite");
     const db2 = new Database5(dbPath, { create: true });
@@ -99303,7 +99829,7 @@ program2.command("serve").description("Start the Open Testers web dashboard").op
   try {
     const port = parseInt(opts.port, 10);
     const url2 = `http://localhost:${port}`;
-    const serverBin = join19(resolve5(process.execPath, ".."), "..", "dist", "server", "index.js");
+    const serverBin = join20(resolve4(process.execPath, ".."), "..", "dist", "server", "index.js");
     const { join: pathJoin, resolve: pathResolve, dirname: dirname7 } = await import("path");
     const { fileURLToPath: fileURLToPath2 } = await import("url");
     const serverPath = pathJoin(dirname7(fileURLToPath2(import.meta.url)), "..", "server", "index.js");
@@ -99719,7 +100245,7 @@ workflowCmd.command("create <name>").description("Save a reusable testing workfl
 }, []).option("--priority <level>", "Scenario priority").option("--persona <ids>", "Comma-separated persona IDs").option("--goal <prompt>", "Goal prompt for the agentic testing loop").option("--success <criteria>", "Success criteria (repeatable)", (val, acc) => {
   acc.push(val);
   return acc;
-}, []).option("--max-iterations <n>", "Goal-loop iteration cap", "10").option("--target <target>", "Execution target: local or connector:e2b", "local").option("--e2b-template <name>", "E2B sandbox template name").option("--connector-operation <name>", "Connector operation for E2B", "run").option("--timeout <ms>", "Workflow timeout").option("--json", "Output as JSON", false).action((name21, opts) => {
+}, []).option("--max-iterations <n>", "Goal-loop iteration cap", "10").option("--target <target>", "Execution target: local or sandbox", "local").option("--sandbox-provider <provider>", "Sandbox provider: e2b, daytona, or modal").option("--sandbox-image <image>", "Sandbox image/template").option("--sandbox-remote-dir <path>", "Remote working directory for sandbox runs").option("--sandbox-cleanup <mode>", "Sandbox cleanup mode: delete, stop, or keep", "delete").option("--sandbox-setup-command <command>", "Shell command to run before testers in the sandbox").option("--sandbox-package <spec>", "Package spec to execute in the sandbox", "@hasna/testers").option("--e2b-template <name>", "Legacy alias for --sandbox-image").option("--timeout <ms>", "Workflow timeout").option("--json", "Output as JSON", false).action((name21, opts) => {
   try {
     const workflow = createTestingWorkflow({
       name: name21,
@@ -99738,9 +100264,12 @@ workflowCmd.command("create <name>").description("Save a reusable testing workfl
       } : null,
       execution: {
         target: opts.target,
-        connector: opts.target === "connector:e2b" ? "e2b" : undefined,
-        operation: opts.connectorOperation,
-        sandboxTemplate: opts.e2bTemplate,
+        provider: opts.sandboxProvider ?? (opts.target === "connector:e2b" ? "e2b" : undefined),
+        sandboxImage: opts.sandboxImage ?? opts.e2bTemplate,
+        sandboxRemoteDir: opts.sandboxRemoteDir,
+        sandboxCleanup: opts.sandboxCleanup,
+        setupCommand: opts.sandboxSetupCommand,
+        packageSpec: opts.sandboxPackage,
         timeoutMs: opts.timeout ? parseInt(opts.timeout, 10) : undefined
       }
     });
@@ -99772,7 +100301,7 @@ workflowCmd.command("list").description("List saved testing workflows").option("
   log(chalk6.bold("  Testing Workflows"));
   log("");
   for (const workflow of workflows) {
-    const target = workflow.execution.target === "connector:e2b" ? chalk6.cyan("e2b") : chalk6.green("local");
+    const target = workflow.execution.target === "sandbox" ? chalk6.cyan(`sandbox${workflow.execution.provider ? `:${workflow.execution.provider}` : ""}`) : chalk6.green("local");
     log(`  ${chalk6.dim(workflow.id.slice(0, 8))}  ${workflow.name}  ${target}  ${chalk6.dim(workflow.personaIds.length ? `${workflow.personaIds.length} personas` : "no personas")}`);
   }
   log("");
@@ -99984,7 +100513,7 @@ personaCmd.command("delete <id>").description("Delete a persona").option("-y, --
     }
     if (!opts.yes) {
       process.stdout.write(chalk6.yellow(`Delete persona ${persona.shortId} "${persona.name}"? [y/N] `));
-      const answer = await new Promise((resolve6) => {
+      const answer = await new Promise((resolve5) => {
         let buf = "";
         process.stdin.setRawMode?.(true);
         process.stdin.resume();
@@ -99994,7 +100523,7 @@ personaCmd.command("delete <id>").description("Delete a persona").option("-y, --
           process.stdin.pause();
           process.stdout.write(`
 `);
-          resolve6(buf);
+          resolve5(buf);
         });
       });
       if (answer !== "y" && answer !== "yes") {
@@ -100155,7 +100684,7 @@ evalCmd.command("rag <url>").description("Run RAG quality evaluation \u2014 fait
     let ragTestCases = [];
     if (opts.docs) {
       try {
-        const raw = readFileSync11(opts.docs, "utf-8");
+        const raw = readFileSync10(opts.docs, "utf-8");
         ragTestCases = JSON.parse(raw);
       } catch {
         logError(chalk6.red(`Failed to read docs file: ${opts.docs}`));
@@ -100245,9 +100774,9 @@ Created golden answer check ${chalk6.bold(golden2.shortId)}`));
     }
     const ask = (prompt) => {
       const rl2 = createInterface({ input: process.stdin, output: process.stdout });
-      return new Promise((resolve6) => rl2.question(prompt, (ans) => {
+      return new Promise((resolve5) => rl2.question(prompt, (ans) => {
         rl2.close();
-        resolve6(ans.trim());
+        resolve5(ans.trim());
       }));
     };
     const question = await ask("Question (what this endpoint should answer): ");
@@ -100408,9 +100937,9 @@ program2.command("run-many <url>").description("Run scenarios \xD7 personas matr
 });
 program2.command("run-script <file>").description("Run a hybrid test script (.ts) that exports an array of HybridScenario objects").option("--url <url>", "Base URL to run against").option("--json", "Output as JSON", false).action(async (file2, opts) => {
   try {
-    const { resolve: resolve6 } = await import("path");
+    const { resolve: resolve5 } = await import("path");
     const { runHybridScenario: runHybridScenario2 } = await Promise.resolve().then(() => (init_hybrid_runner(), exports_hybrid_runner));
-    const scriptPath = resolve6(process.cwd(), file2);
+    const scriptPath = resolve5(process.cwd(), file2);
     const mod = await import(scriptPath);
     const scenarios = mod.scenarios ?? mod.default ?? [];
     if (!Array.isArray(scenarios) || scenarios.length === 0) {