@hasna/testers 0.0.34 → 0.0.35

package/dist/index.js

@@ -17,6 +17,72 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // 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,
+    projectId: row.project_id,
+    name: row.name,
+    description: row.description,
+    scenarioFilter: JSON.parse(row.scenario_filter || "{}"),
+    personaIds: JSON.parse(row.persona_ids || "[]"),
+    goal: row.goal ? JSON.parse(row.goal) : null,
+    execution: workflowExecutionFromValue(JSON.parse(row.execution || '{"target":"local"}')),
+    settings: JSON.parse(row.settings || "{}"),
+    enabled: row.enabled === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
 function projectFromRow(row) {
   return {
     id: row.id,
@@ -10456,7 +10522,7 @@ __export(exports_flows, {
   addDependency: () => addDependency
 });
 function addDependency(scenarioId, dependsOn) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const visited = new Set;
   const queue = [dependsOn];
   while (queue.length > 0) {
@@ -10467,37 +10533,37 @@ function addDependency(scenarioId, dependsOn) {
     if (visited.has(current))
       continue;
     visited.add(current);
-    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    const deps = db3.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
     for (const dep of deps) {
       if (!visited.has(dep.depends_on)) {
         queue.push(dep.depends_on);
       }
     }
   }
-  db2.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
+  db3.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
 }
 function removeDependency(scenarioId, dependsOn) {
-  const db2 = getDatabase();
-  const result = db2.query("DELETE FROM scenario_dependencies WHERE scenario_id = ? AND depends_on = ?").run(scenarioId, dependsOn);
+  const db3 = getDatabase();
+  const result = db3.query("DELETE FROM scenario_dependencies WHERE scenario_id = ? AND depends_on = ?").run(scenarioId, dependsOn);
   return result.changes > 0;
 }
 function getDependencies(scenarioId) {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(scenarioId);
+  const db3 = getDatabase();
+  const rows = db3.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(scenarioId);
   return rows.map((r) => r.depends_on);
 }
 function getDependents(scenarioId) {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT scenario_id FROM scenario_dependencies WHERE depends_on = ?").all(scenarioId);
+  const db3 = getDatabase();
+  const rows = db3.query("SELECT scenario_id FROM scenario_dependencies WHERE depends_on = ?").all(scenarioId);
   return rows.map((r) => r.scenario_id);
 }
 function getTransitiveDependencies(scenarioId) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const visited = new Set;
   const queue = [scenarioId];
   while (queue.length > 0) {
     const current = queue.shift();
-    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    const deps = db3.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
     for (const dep of deps) {
       if (!visited.has(dep.depends_on)) {
         visited.add(dep.depends_on);
@@ -10508,7 +10574,7 @@ function getTransitiveDependencies(scenarioId) {
   return Array.from(visited);
 }
 function topologicalSort(scenarioIds) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const idSet = new Set(scenarioIds);
   const inDegree = new Map;
   const dependents = new Map;
@@ -10517,7 +10583,7 @@ function topologicalSort(scenarioIds) {
     dependents.set(id, []);
   }
   for (const id of scenarioIds) {
-    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(id);
+    const deps = db3.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(id);
     for (const dep of deps) {
       if (idSet.has(dep.depends_on)) {
         inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
@@ -10547,43 +10613,43 @@ function topologicalSort(scenarioIds) {
   return sorted;
 }
 function createFlow(input) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const id = uuid();
   const timestamp = now();
-  db2.query(`
+  db3.query(`
     INSERT INTO flows (id, project_id, name, description, scenario_ids, created_at, updated_at)
     VALUES (?, ?, ?, ?, ?, ?, ?)
   `).run(id, input.projectId ?? null, input.name, input.description ?? null, JSON.stringify(input.scenarioIds), timestamp, timestamp);
   return getFlow(id);
 }
 function getFlow(id) {
-  const db2 = getDatabase();
-  let row = db2.query("SELECT * FROM flows WHERE id = ?").get(id);
+  const db3 = getDatabase();
+  let row = db3.query("SELECT * FROM flows WHERE id = ?").get(id);
   if (row)
     return flowFromRow(row);
   const fullId = resolvePartialId("flows", id);
   if (fullId) {
-    row = db2.query("SELECT * FROM flows WHERE id = ?").get(fullId);
+    row = db3.query("SELECT * FROM flows WHERE id = ?").get(fullId);
     if (row)
       return flowFromRow(row);
   }
   return null;
 }
 function listFlows(projectId) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   if (projectId) {
-    const rows2 = db2.query("SELECT * FROM flows WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+    const rows2 = db3.query("SELECT * FROM flows WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
     return rows2.map(flowFromRow);
   }
-  const rows = db2.query("SELECT * FROM flows ORDER BY created_at DESC").all();
+  const rows = db3.query("SELECT * FROM flows ORDER BY created_at DESC").all();
   return rows.map(flowFromRow);
 }
 function deleteFlow(id) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const flow = getFlow(id);
   if (!flow)
     return false;
-  const result = db2.query("DELETE FROM flows WHERE id = ?").run(flow.id);
+  const result = db3.query("DELETE FROM flows WHERE id = ?").run(flow.id);
   return result.changes > 0;
 }
 var init_flows = __esm(() => {
@@ -12092,7 +12158,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)
@@ -12157,7 +12222,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";
@@ -12234,7 +12298,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 = [];
@@ -12276,6 +12361,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,
@@ -12285,6 +12402,7 @@ async function runAgentLoop(options) {
     model,
     runId,
     sessionId,
+    baseUrl,
     maxTurns = 30,
     onStep,
     persona,
@@ -12332,21 +12450,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;
@@ -12409,7 +12513,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 });
         }
@@ -13608,6 +13712,127 @@ function updateLastRun(id, runId, nextRunAt) {
     UPDATE schedules SET last_run_id = ?, last_run_at = ?, next_run_at = ?, updated_at = ? WHERE id = ?
   `).run(runId, timestamp, nextRunAt, timestamp, id);
 }
+// src/db/workflows.ts
+init_types();
+init_database();
+var DEFAULT_EXECUTION = { target: "local" };
+function normalizeGoal(input) {
+  if (!input)
+    return null;
+  const prompt = input.prompt?.trim();
+  if (!prompt)
+    return null;
+  return {
+    prompt,
+    successCriteria: input.successCriteria ?? [],
+    maxIterations: input.maxIterations ?? 10
+  };
+}
+function normalizeFilter(input) {
+  return {
+    scenarioIds: input?.scenarioIds?.filter(Boolean),
+    tags: input?.tags?.filter(Boolean),
+    priority: input?.priority
+  };
+}
+function normalizeExecution(input) {
+  return input ? workflowExecutionFromValue(input) : DEFAULT_EXECUTION;
+}
+function createTestingWorkflow(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO testing_workflows
+      (id, project_id, name, description, scenario_filter, persona_ids, goal, execution, settings, enabled, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.projectId ?? null, input.name, input.description ?? null, JSON.stringify(normalizeFilter(input.scenarioFilter)), JSON.stringify(input.personaIds ?? []), JSON.stringify(normalizeGoal(input.goal)), JSON.stringify(normalizeExecution(input.execution)), JSON.stringify(input.settings ?? {}), input.enabled === false ? 0 : 1, timestamp, timestamp);
+  return getTestingWorkflow(id);
+}
+function getTestingWorkflow(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM testing_workflows WHERE id = ?").get(id);
+  if (row)
+    return workflowFromRow(row);
+  const fullId = resolvePartialId("testing_workflows", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM testing_workflows WHERE id = ?").get(fullId);
+    if (row)
+      return workflowFromRow(row);
+  }
+  row = db2.query("SELECT * FROM testing_workflows WHERE name = ?").get(id);
+  return row ? workflowFromRow(row) : null;
+}
+function listTestingWorkflows(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.enabled !== undefined) {
+    conditions.push("enabled = ?");
+    params.push(filter.enabled ? 1 : 0);
+  }
+  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db2.query(`SELECT * FROM testing_workflows${where} ORDER BY created_at DESC`).all(...params);
+  return rows.map(workflowFromRow);
+}
+function updateTestingWorkflow(id, input) {
+  const existing = getTestingWorkflow(id);
+  if (!existing)
+    throw new Error(`Testing workflow not found: ${id}`);
+  const fields = [];
+  const values = [];
+  if (input.name !== undefined) {
+    fields.push("name = ?");
+    values.push(input.name);
+  }
+  if (input.description !== undefined) {
+    fields.push("description = ?");
+    values.push(input.description);
+  }
+  if (input.scenarioFilter !== undefined) {
+    fields.push("scenario_filter = ?");
+    values.push(JSON.stringify(normalizeFilter(input.scenarioFilter)));
+  }
+  if (input.personaIds !== undefined) {
+    fields.push("persona_ids = ?");
+    values.push(JSON.stringify(input.personaIds));
+  }
+  if (input.goal !== undefined) {
+    fields.push("goal = ?");
+    values.push(JSON.stringify(normalizeGoal(input.goal)));
+  }
+  if (input.execution !== undefined) {
+    fields.push("execution = ?");
+    values.push(JSON.stringify(normalizeExecution(input.execution)));
+  }
+  if (input.settings !== undefined) {
+    fields.push("settings = ?");
+    values.push(JSON.stringify(input.settings));
+  }
+  if (input.enabled !== undefined) {
+    fields.push("enabled = ?");
+    values.push(input.enabled ? 1 : 0);
+  }
+  if (fields.length === 0)
+    return existing;
+  fields.push("updated_at = ?");
+  values.push(now(), existing.id);
+  db2().query(`UPDATE testing_workflows SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getTestingWorkflow(existing.id);
+}
+function deleteTestingWorkflow(id) {
+  const existing = getTestingWorkflow(id);
+  if (!existing)
+    return false;
+  return getDatabase().query("DELETE FROM testing_workflows WHERE id = ?").run(existing.id).changes > 0;
+}
+function db2() {
+  return getDatabase();
+}
 
 // src/index.ts
 init_flows();
@@ -14905,20 +15130,20 @@ function loadBudgetConfig() {
   };
 }
 function getCostSummary(options) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const period = options?.period ?? "month";
   const projectId = options?.projectId;
   const dateFilter = getDateFilter(period);
   const projectFilter = projectId ? "AND ru.project_id = ?" : "";
   const projectParams = projectId ? [projectId] : [];
-  const totalsRow = db2.query(`SELECT
+  const totalsRow = db3.query(`SELECT
         COALESCE(SUM(r.cost_cents), 0) as total_cost,
         COALESCE(SUM(r.tokens_used), 0) as total_tokens,
         COUNT(DISTINCT r.run_id) as run_count
       FROM results r
       JOIN runs ru ON r.run_id = ru.id
       WHERE 1=1 ${dateFilter} ${projectFilter}`).get(...projectParams);
-  const modelRows = db2.query(`SELECT
+  const modelRows = db3.query(`SELECT
         r.model,
         COALESCE(SUM(r.cost_cents), 0) as cost_cents,
         COALESCE(SUM(r.tokens_used), 0) as tokens,
@@ -14936,7 +15161,7 @@ function getCostSummary(options) {
       runs: row.runs
     };
   }
-  const scenarioRows = db2.query(`SELECT
+  const scenarioRows = db3.query(`SELECT
         r.scenario_id,
         COALESCE(s.name, r.scenario_id) as name,
         COALESCE(SUM(r.cost_cents), 0) as cost_cents,
@@ -15088,22 +15313,22 @@ function formatCostsJSON(summary) {
 // src/db/step-results.ts
 init_database();
 function createStepResult(input) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const id = uuid();
   const timestamp = now();
-  db2.query(`
+  db3.query(`
     INSERT INTO step_results (id, result_id, step_number, action, status, tool_name, tool_input, thinking, created_at)
     VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?)
   `).run(id, input.resultId, input.stepNumber, input.action, input.toolName ?? null, input.toolInput ? JSON.stringify(input.toolInput) : null, input.thinking ?? null, timestamp);
   return getStepResult(id);
 }
 function getStepResult(id) {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT * FROM step_results WHERE id = ?").get(id);
+  const db3 = getDatabase();
+  const row = db3.query("SELECT * FROM step_results WHERE id = ?").get(id);
   return row ? stepResultFromRow(row) : null;
 }
 function updateStepResult(id, updates) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const existing = getStepResult(id);
   if (!existing)
     return null;
@@ -15132,7 +15357,7 @@ function updateStepResult(id, updates) {
   if (sets.length === 0)
     return existing;
   params.push(id);
-  db2.query(`UPDATE step_results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  db3.query(`UPDATE step_results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
   return getStepResult(id);
 }
 function stepResultFromRow(row) {
@@ -15157,18 +15382,18 @@ function stepResultFromRow(row) {
 init_types();
 init_database();
 function getPersona(id) {
-  const db2 = getDatabase();
-  let row = db2.query("SELECT * FROM personas WHERE id = ?").get(id);
+  const db3 = getDatabase();
+  let row = db3.query("SELECT * FROM personas WHERE id = ?").get(id);
   if (row)
     return personaFromRow(row);
-  row = db2.query("SELECT * FROM personas WHERE short_id = ?").get(id);
+  row = db3.query("SELECT * FROM personas WHERE short_id = ?").get(id);
   if (row)
     return personaFromRow(row);
   return null;
 }
 function savePersonaAuthCookies(id, cookies) {
-  const db2 = getDatabase();
-  db2.query("UPDATE personas SET auth_cookies = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(cookies), now(), id);
+  const db3 = getDatabase();
+  db3.query("UPDATE personas SET auth_cookies = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(cookies), now(), id);
 }
 
 // src/lib/runner.ts
@@ -15192,9 +15417,9 @@ function lookupFromVault(key) {
   if (!existsSync9(vaultPath))
     return null;
   try {
-    const db2 = new Database2(vaultPath, { readonly: true });
-    const row = db2.query("SELECT value FROM secrets WHERE key = ?").get(key);
-    db2.close();
+    const db3 = new Database2(vaultPath, { readonly: true });
+    const row = db3.query("SELECT value FROM secrets WHERE key = ?").get(key);
+    db3.close();
     return row?.value ?? null;
   } catch {
     return null;
@@ -15458,21 +15683,21 @@ function fromRow(row) {
   };
 }
 function createWebhook(input) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const id = uuid();
   const events = input.events ?? ["failed"];
   const secret = input.secret ?? crypto.randomUUID().replace(/-/g, "");
-  db2.query(`
+  db3.query(`
     INSERT INTO webhooks (id, url, events, project_id, secret, active, created_at)
     VALUES (?, ?, ?, ?, ?, 1, ?)
   `).run(id, input.url, JSON.stringify(events), input.projectId ?? null, secret, now());
   return getWebhook(id);
 }
 function getWebhook(id) {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT * FROM webhooks WHERE id = ?").get(id);
+  const db3 = getDatabase();
+  const row = db3.query("SELECT * FROM webhooks WHERE id = ?").get(id);
   if (!row) {
-    const rows = db2.query("SELECT * FROM webhooks WHERE id LIKE ? || '%'").all(id);
+    const rows = db3.query("SELECT * FROM webhooks WHERE id LIKE ? || '%'").all(id);
     if (rows.length === 1)
       return fromRow(rows[0]);
     return null;
@@ -15480,7 +15705,7 @@ function getWebhook(id) {
   return fromRow(row);
 }
 function listWebhooks(projectId) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   let query = "SELECT * FROM webhooks WHERE active = 1";
   const params = [];
   if (projectId) {
@@ -15488,15 +15713,15 @@ function listWebhooks(projectId) {
     params.push(projectId);
   }
   query += " ORDER BY created_at DESC";
-  const rows = db2.query(query).all(...params);
+  const rows = db3.query(query).all(...params);
   return rows.map(fromRow);
 }
 function deleteWebhook(id) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const webhook = getWebhook(id);
   if (!webhook)
     return false;
-  db2.query("DELETE FROM webhooks WHERE id = ?").run(webhook.id);
+  db3.query("DELETE FROM webhooks WHERE id = ?").run(webhook.id);
   return true;
 }
 function signPayload(body, secret) {
@@ -15664,12 +15889,12 @@ function connectToTodos(options = {}) {
   if (!existsSync10(dbPath)) {
     throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
   }
-  const db2 = new Database3(dbPath, { readonly: options.readonly ?? true });
-  db2.exec("PRAGMA foreign_keys = ON");
-  return db2;
+  const db3 = new Database3(dbPath, { readonly: options.readonly ?? true });
+  db3.exec("PRAGMA foreign_keys = ON");
+  return db3;
 }
 function pullTasks(options = {}) {
-  const db2 = connectToTodos({ readonly: true });
+  const db3 = connectToTodos({ readonly: true });
   try {
     let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
     const params = [];
@@ -15684,14 +15909,14 @@ function pullTasks(options = {}) {
       params.push(options.priority);
     }
     if (options.projectName) {
-      const project = db2.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
+      const project = db3.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
       if (project) {
         query += " AND project_id = ?";
         params.push(project.id);
       }
     }
     query += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END";
-    const tasks = db2.query(query).all(...params);
+    const tasks = db3.query(query).all(...params);
     if (options.tags && options.tags.length > 0) {
       return tasks.filter((task) => {
         const taskTags = JSON.parse(task.tags || "[]");
@@ -15700,7 +15925,7 @@ function pullTasks(options = {}) {
     }
     return tasks;
   } finally {
-    db2.close();
+    db3.close();
   }
 }
 function taskToScenarioInput(task, projectId) {
@@ -15752,15 +15977,15 @@ function markTodoDone(taskId) {
   const dbPath = resolveTodosDbPath();
   if (!existsSync10(dbPath))
     return false;
-  const db2 = new Database3(dbPath);
+  const db3 = new Database3(dbPath);
   try {
-    const task = db2.query("SELECT id, version FROM tasks WHERE id LIKE ? || '%'").get(taskId);
+    const task = db3.query("SELECT id, version FROM tasks WHERE id LIKE ? || '%'").get(taskId);
     if (!task)
       return false;
-    db2.query("UPDATE tasks SET status = 'completed', completed_at = datetime('now'), version = version + 1, updated_at = datetime('now') WHERE id = ? AND version = ?").run(task.id, task.version);
+    db3.query("UPDATE tasks SET status = 'completed', completed_at = datetime('now'), version = version + 1, updated_at = datetime('now') WHERE id = ? AND version = ?").run(task.id, task.version);
     return true;
   } finally {
-    db2.close();
+    db3.close();
   }
 }
 
@@ -15771,9 +15996,9 @@ async function createFailureTasks(run, failedResults, scenarios) {
   const projectId = process.env["TESTERS_TODOS_PROJECT_ID"];
   if (!projectId)
     return { created: 0, skipped: 0 };
-  let db2 = null;
+  let db3 = null;
   try {
-    db2 = connectToTodos({ readonly: false });
+    db3 = connectToTodos({ readonly: false });
   } catch {
     return { created: 0, skipped: 0 };
   }
@@ -15784,7 +16009,7 @@ async function createFailureTasks(run, failedResults, scenarios) {
     for (const result of failedResults) {
       const scenario = scenarioMap.get(result.scenarioId);
       const title = `BUG: [testers] ${scenario?.name ?? result.scenarioId} failed`;
-      const existing = db2.query("SELECT id FROM tasks WHERE title = ? AND status NOT IN ('completed', 'cancelled') LIMIT 1").get(title);
+      const existing = db3.query("SELECT id FROM tasks WHERE title = ? AND status NOT IN ('completed', 'cancelled') LIMIT 1").get(title);
       if (existing) {
         skipped++;
         continue;
@@ -15805,7 +16030,7 @@ async function createFailureTasks(run, failedResults, scenarios) {
       ].filter(Boolean).join(`
 `);
       try {
-        db2.query(`
+        db3.query(`
           INSERT INTO tasks (id, short_id, title, description, status, priority, tags, project_id, version, created_at, updated_at)
           VALUES (?, ?, ?, ?, 'pending', 'high', ?, ?, 1, ?, ?)
         `).run(id, `BUG-${id.slice(0, 6)}`, title, description, JSON.stringify(["bug", "testers", "auto-created"]), projectId, now2, now2);
@@ -15815,7 +16040,7 @@ async function createFailureTasks(run, failedResults, scenarios) {
       }
     }
   } finally {
-    db2.close();
+    db3.close();
   }
   return { created, skipped };
 }
@@ -15894,6 +16119,291 @@ async function notifyRunToConversations(run, results, options) {
   } catch {}
 }
 
+// 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 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(`
+`);
+}
+
 // src/lib/runner.ts
 var eventHandler = null;
 function onRunEvent(handler) {
@@ -15903,6 +16413,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);
@@ -16073,6 +16631,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 ? {
@@ -16155,27 +16714,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) {
@@ -16200,7 +16778,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) {
@@ -16372,22 +16951,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 = resolveModel2(options.model ?? config.defaultModel);
@@ -16400,17 +16988,7 @@ async function runByFilter(options) {
 function startRunAsync(options) {
   const config = loadConfig();
   const model = resolveModel2(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) {
@@ -16495,6 +17073,170 @@ function estimateCost(model, tokens) {
   const costPer1M = costs[model] ?? 0.5;
   return tokens / 1e6 * costPer1M * 100;
 }
+// src/lib/workflow-runner.ts
+init_database();
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join14 } from "path";
+function buildWorkflowRunPlan(workflow, options) {
+  const runOptions = {
+    url: options.url,
+    model: options.model,
+    headed: options.headed,
+    parallel: options.parallel,
+    timeout: options.timeout ?? workflow.execution.timeoutMs,
+    projectId: workflow.projectId ?? undefined,
+    scenarioIds: workflow.scenarioFilter.scenarioIds,
+    tags: workflow.scenarioFilter.tags,
+    priority: workflow.scenarioFilter.priority,
+    personaIds: workflow.personaIds.length > 0 ? workflow.personaIds : undefined
+  };
+  return {
+    workflow,
+    runOptions,
+    sandbox: workflow.execution.target === "sandbox" ? buildSandboxPlan(workflow, workflow.execution, runOptions) : null
+  };
+}
+async function runTestingWorkflow(workflowId, options, dependencies = {}) {
+  const workflow = getTestingWorkflow(workflowId);
+  if (!workflow)
+    throw new Error(`Testing workflow not found: ${workflowId}`);
+  if (!workflow.enabled)
+    throw new Error(`Testing workflow is disabled: ${workflow.name}`);
+  validatePersonaIds(workflow);
+  const plan = buildWorkflowRunPlan(workflow, options);
+  if (options.dryRun)
+    return { run: null, results: [], plan };
+  if (workflow.execution.target === "sandbox") {
+    const sandboxResult = await runViaSandbox(plan, dependencies);
+    return { run: null, results: [], plan, sandboxResult };
+  }
+  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(join14(tmpdir(), `testers-workflow-${workflow.id.slice(0, 8)}-`));
+  writeFileSync3(join14(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)) {
+      throw new Error(`Persona not found for workflow ${workflow.name}: ${personaId}`);
+    }
+  }
+}
+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: buildSandboxCommand({
+      runOptions,
+      remoteDir,
+      dbPath: `${stateRemoteDir}/testers.db`,
+      setupCommand: execution.setupCommand,
+      packageSpec: execution.packageSpec ?? "@hasna/testers"
+    })
+  };
+}
+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?.();
+  }
+}
+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/lib/reporter.ts
 init_database();
 function useEmoji() {
@@ -16668,9 +17410,9 @@ function formatRunList(runs) {
 `);
 }
 function getScenarioRunStats(scenarioId) {
-  const db2 = getDatabase();
-  const lastRow = db2.query("SELECT status FROM results WHERE scenario_id = ? ORDER BY created_at DESC LIMIT 1").get(scenarioId);
-  const statsRow = db2.query("SELECT COUNT(*) as total, SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) as passed FROM results WHERE scenario_id = ?").get(scenarioId);
+  const db3 = getDatabase();
+  const lastRow = db3.query("SELECT status FROM results WHERE scenario_id = ? ORDER BY created_at DESC LIMIT 1").get(scenarioId);
+  const statsRow = db3.query("SELECT COUNT(*) as total, SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) as passed FROM results WHERE scenario_id = ?").get(scenarioId);
   return {
     lastStatus: lastRow ? lastRow.status : null,
     passRate: statsRow && statsRow.total > 0 ? `${statsRow.passed}/${statsRow.total}` : "\u2014"
@@ -16960,10 +17702,10 @@ class Scheduler {
 }
 // src/lib/init.ts
 init_paths();
-import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync9 } from "fs";
-import { join as join14, basename } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15, basename } from "path";
 function detectFramework(dir) {
-  const pkgPath = join14(dir, "package.json");
+  const pkgPath = join15(dir, "package.json");
   if (!existsSync11(pkgPath))
     return null;
   let pkg;
@@ -17191,7 +17933,7 @@ function initProject(options) {
     }
   }).filter((s) => s !== null);
   const configDir = getTestersDir();
-  const configPath = join14(configDir, "config.json");
+  const configPath = join15(configDir, "config.json");
   if (!existsSync11(configDir)) {
     mkdirSync9(configDir, { recursive: true });
   }
@@ -17202,7 +17944,7 @@ function initProject(options) {
     } catch {}
   }
   config.activeProject = project.id;
-  writeFileSync3(configPath, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(configPath, JSON.stringify(config, null, 2), "utf-8");
   return { project, scenarios, framework, url };
 }
 // src/lib/smoke.ts
@@ -17630,28 +18372,28 @@ function fromRow2(row) {
   };
 }
 function createAuthPreset(input) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const id = uuid();
   const timestamp = now();
-  db2.query(`
+  db3.query(`
     INSERT INTO auth_presets (id, name, email, password, login_path, metadata, created_at)
     VALUES (?, ?, ?, ?, ?, '{}', ?)
   `).run(id, input.name, input.email, input.password, input.loginPath ?? "/login", timestamp);
   return getAuthPreset(input.name);
 }
 function getAuthPreset(name) {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT * FROM auth_presets WHERE name = ?").get(name);
+  const db3 = getDatabase();
+  const row = db3.query("SELECT * FROM auth_presets WHERE name = ?").get(name);
   return row ? fromRow2(row) : null;
 }
 function listAuthPresets() {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT * FROM auth_presets ORDER BY created_at DESC").all();
+  const db3 = getDatabase();
+  const rows = db3.query("SELECT * FROM auth_presets ORDER BY created_at DESC").all();
   return rows.map(fromRow2);
 }
 function deleteAuthPreset(name) {
-  const db2 = getDatabase();
-  const result = db2.query("DELETE FROM auth_presets WHERE name = ?").run(name);
+  const db3 = getDatabase();
+  const result = db3.query("DELETE FROM auth_presets WHERE name = ?").run(name);
   return result.changes > 0;
 }
 // src/lib/report.ts
@@ -17947,12 +18689,12 @@ async function startWatcher(options) {
 }
 // src/lib/repo-discovery.ts
 init_paths();
-import { existsSync as existsSync13, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4, mkdirSync as mkdirSync10, unlinkSync } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync5, mkdirSync as mkdirSync10, unlinkSync } from "fs";
 import { createHash } from "crypto";
-import { join as join15, resolve as resolve2, relative as relative2 } from "path";
+import { join as join16, resolve as resolve2, relative as relative2 } from "path";
 function getCacheDir() {
   const testersDir = getTestersDir();
-  const cacheDir = join15(testersDir, "repo-index");
+  const cacheDir = join16(testersDir, "repo-index");
   if (!existsSync13(cacheDir)) {
     mkdirSync10(cacheDir, { recursive: true });
   }
@@ -17962,11 +18704,11 @@ function pathHash(repoPath) {
   return createHash("sha256").update(repoPath).digest("hex").slice(0, 16);
 }
 function getCachePath(repoPath) {
-  return join15(getCacheDir(), `${pathHash(repoPath)}.json`);
+  return join16(getCacheDir(), `${pathHash(repoPath)}.json`);
 }
 function isCacheStale(cached, repoPath) {
   for (const spec of cached.specs) {
-    const fullPath = join15(repoPath, spec.file);
+    const fullPath = join16(repoPath, spec.file);
     if (!existsSync13(fullPath))
       return true;
     try {
@@ -17978,11 +18720,11 @@ function isCacheStale(cached, repoPath) {
     }
   }
   if (cached.configPath) {
-    const configFullPath = join15(repoPath, cached.configPath);
+    const configFullPath = join16(repoPath, cached.configPath);
     if (!existsSync13(configFullPath))
       return true;
     try {
-      const stat = statSync(configFullPath);
+      statSync(configFullPath);
       const age = Date.now() - new Date(cached.snapshotAt).getTime();
       if (age > 3600000)
         return true;
@@ -18005,14 +18747,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: existsSync13(join15(repoPath, "package-lock.json")),
-    yarn: existsSync13(join15(repoPath, "yarn.lock")),
-    pnpm: existsSync13(join15(repoPath, "pnpm-lock.yaml")),
-    bun: existsSync13(join15(repoPath, "bun.lockb")) || existsSync13(join15(repoPath, "bun.lock")),
+    npm: existsSync13(join16(repoPath, "package-lock.json")),
+    yarn: existsSync13(join16(repoPath, "yarn.lock")),
+    pnpm: existsSync13(join16(repoPath, "pnpm-lock.yaml")),
+    bun: existsSync13(join16(repoPath, "bun.lockb")) || existsSync13(join16(repoPath, "bun.lock")),
     preferred: "npm"
   };
   if (result.bun)
@@ -18026,7 +18768,7 @@ function detectPackageManager(repoPath) {
   return result;
 }
 function detectDevScripts(repoPath) {
-  const pkgPath = join15(repoPath, "package.json");
+  const pkgPath = join16(repoPath, "package.json");
   if (!existsSync13(pkgPath)) {
     return { dev: null, test: null, seed: null, build: null };
   }
@@ -18053,7 +18795,7 @@ function findPlaywrightConfig(repoPath) {
     "playwright-ct.config.js"
   ];
   for (const name of candidates) {
-    if (existsSync13(join15(repoPath, name)))
+    if (existsSync13(join16(repoPath, name)))
       return name;
   }
   return null;
@@ -18062,7 +18804,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 = join15(repoPath, configPath);
+  const fullPath = join16(repoPath, configPath);
   let content;
   try {
     content = readFileSync5(fullPath, "utf-8");
@@ -18073,8 +18815,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, ""));
@@ -18082,8 +18825,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`);
@@ -18109,7 +18853,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 ? join15(repoPath, dir) : repoPath;
+      const searchDir = dir ? join16(repoPath, dir) : repoPath;
       if (!existsSync13(searchDir))
         continue;
       try {
@@ -18143,7 +18887,7 @@ function walkDir(dir) {
   try {
     const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join15(dir, entry.name);
+      const fullPath = join16(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -18161,7 +18905,7 @@ function matchesGlob(filePath, pattern) {
   return new RegExp(regex).test(filePath);
 }
 function detectSuggestedUrl(repoPath) {
-  const pkgPath = join15(repoPath, "package.json");
+  const pkgPath = join16(repoPath, "package.json");
   if (!existsSync13(pkgPath))
     return null;
   try {
@@ -18181,10 +18925,10 @@ function detectSuggestedUrl(repoPath) {
   return null;
 }
 function checkPlaywrightBrowserInstalled(repoPath) {
-  const cacheDir = join15(repoPath, "node_modules", ".cache", "ms-playwright");
+  const cacheDir = join16(repoPath, "node_modules", ".cache", "ms-playwright");
   if (existsSync13(cacheDir))
     return true;
-  const globalCache = join15(repoPath, ".cache", "ms-playwright");
+  const globalCache = join16(repoPath, ".cache", "ms-playwright");
   if (existsSync13(globalCache))
     return true;
   return false;
@@ -18201,7 +18945,7 @@ function getInstallCommand(pm) {
       return "bun install";
   }
 }
-function getPlaywrightInstallCommand(pm) {
+function getPlaywrightInstallCommand(_pm) {
   return "npx playwright install";
 }
 function discoverRepo(opts) {
@@ -18216,7 +18960,7 @@ function discoverRepo(opts) {
   let configRaw = null;
   if (configPath) {
     try {
-      configRaw = readFileSync5(join15(repoPath, configPath), "utf-8");
+      configRaw = readFileSync5(join16(repoPath, configPath), "utf-8");
     } catch {
       configRaw = null;
     }
@@ -18225,7 +18969,7 @@ function discoverRepo(opts) {
   const specs = findSpecFiles(repoPath, globPatterns);
   const packageManager = detectPackageManager(repoPath);
   const devScripts = detectDevScripts(repoPath);
-  const playwrightInstalled = existsSync13(join15(repoPath, "node_modules", "playwright")) || existsSync13(join15(repoPath, "node_modules", "@playwright", "test"));
+  const playwrightInstalled = existsSync13(join16(repoPath, "node_modules", "playwright")) || existsSync13(join16(repoPath, "node_modules", "@playwright", "test"));
   const browsersInstalled = checkPlaywrightBrowserInstalled(repoPath);
   const configExists = configPath !== null;
   const specsFound = specs.length > 0;
@@ -18294,7 +19038,7 @@ function clearDiscoveryCache(repoPath) {
   } else {
     for (const file of readdirSync3(cacheDir)) {
       if (file.endsWith(".json")) {
-        unlinkSync(join15(cacheDir, file));
+        unlinkSync(join16(cacheDir, file));
       }
     }
   }
@@ -18317,10 +19061,10 @@ init_runs();
 init_database();
 init_paths();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, writeFileSync as writeFileSync5 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "fs";
+import { join as join17 } from "path";
 function resolvePlaywrightCmd(repoPath) {
-  const localPw = join16(repoPath, "node_modules", ".bin", "playwright");
+  const localPw = join17(repoPath, "node_modules", ".bin", "playwright");
   if (existsSync14(localPw)) {
     return [localPw, "test"];
   }
@@ -18339,7 +19083,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(" ")}`, {
@@ -18367,7 +19111,7 @@ function runPlaywright(repoPath, workingDir, specFiles, extraArgs, timeoutMs) {
     };
   }
 }
-function parsePlaywrightJsonOutput(stdout, stderr) {
+function parsePlaywrightJsonOutput(stdout, _stderr) {
   const testResults = [];
   try {
     const obj = JSON.parse(stdout);
@@ -18472,19 +19216,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();
@@ -18496,12 +19242,12 @@ async function runRepoTests(opts) {
     specResults.push(result);
     const resultId = uuid();
     const timestamp = now();
-    const db2 = getDatabase();
-    db2.exec("PRAGMA foreign_keys = OFF");
+    const db3 = getDatabase();
+    db3.exec("PRAGMA foreign_keys = OFF");
     try {
       const reasoning = result.status === "passed" ? "All tests passed" : (result.error ?? "").slice(0, 500) || null;
       const errorStr = result.status !== "passed" ? result.error ?? null : null;
-      db2.query(`
+      db3.query(`
         INSERT INTO results (id, run_id, scenario_id, status, reasoning, error, steps_completed, steps_total, duration_ms, model, tokens_used, cost_cents, metadata, created_at, persona_id, persona_name)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, NULL, NULL)
       `).run(resultId, run.id, "__repo__", result.status, reasoning, errorStr, result.testResults.filter((t) => t.status === "passed").length, result.testResults.length || 1, result.durationMs, "repo-native", JSON.stringify({
@@ -18510,14 +19256,14 @@ async function runRepoTests(opts) {
         testResults: result.testResults
       }), timestamp);
     } finally {
-      db2.exec("PRAGMA foreign_keys = ON");
+      db3.exec("PRAGMA foreign_keys = ON");
     }
     const resultRecord = { id: resultId };
     if (result.stdout || result.stderr) {
-      const reportersDir = join16(getTestersDir(), "repo-run-output");
+      const reportersDir = join17(getTestersDir(), "repo-run-output");
       mkdirSync11(reportersDir, { recursive: true });
-      const outputFile = join16(reportersDir, `${resultRecord.id}.log`);
-      writeFileSync5(outputFile, `=== stdout ===
+      const outputFile = join17(reportersDir, `${resultRecord.id}.log`);
+      writeFileSync6(outputFile, `=== stdout ===
 ${result.stdout}
 
 === stderr ===
@@ -19122,46 +19868,46 @@ async function postGitHubComment(run, results, options) {
 // src/db/sessions.ts
 init_database();
 function createSession(input) {
-  const db2 = getDatabase();
+  const db3 = getDatabase();
   const id = input.sessionId ?? uuid();
   const timestamp = now();
-  db2.query(`
+  db3.query(`
     INSERT INTO sessions (id, tab_id, url, title, entries, entry_count, error_count, console_count, nav_count, status, start_time, end_time, created_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(id, input.tabId, input.url ?? null, input.title ?? null, input.entries, input.entryCount, input.errorCount ?? 0, input.consoleCount ?? 0, input.navCount ?? 0, input.status, input.startTime, input.endTime ?? null, timestamp);
   return getSession(id);
 }
 function getSession(id) {
-  const db2 = getDatabase();
-  let row = db2.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  const db3 = getDatabase();
+  let row = db3.query("SELECT * FROM sessions WHERE id = ?").get(id);
   if (row)
     return sessionFromRow(row);
   const fullId = resolvePartialId("sessions", id);
   if (fullId) {
-    row = db2.query("SELECT * FROM sessions WHERE id = ?").get(fullId);
+    row = db3.query("SELECT * FROM sessions WHERE id = ?").get(fullId);
     if (row)
       return sessionFromRow(row);
   }
   return null;
 }
 function listSessions(limit = 50, offset = 0) {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT * FROM sessions ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  const db3 = getDatabase();
+  const rows = db3.query("SELECT * FROM sessions ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
   return rows.map(sessionFromRow);
 }
 function deleteSession(id) {
-  const db2 = getDatabase();
-  const result = db2.query("DELETE FROM sessions WHERE id = ?").run(id);
+  const db3 = getDatabase();
+  const result = db3.query("DELETE FROM sessions WHERE id = ?").run(id);
   return result.changes > 0;
 }
 function searchSessions(query, limit = 20) {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT * FROM sessions WHERE url LIKE ? OR title LIKE ? ORDER BY created_at DESC LIMIT ?").all(`%${query}%`, `%${query}%`, limit);
+  const db3 = getDatabase();
+  const rows = db3.query("SELECT * FROM sessions WHERE url LIKE ? OR title LIKE ? ORDER BY created_at DESC LIMIT ?").all(`%${query}%`, `%${query}%`, limit);
   return rows.map(sessionFromRow);
 }
 function countSessions() {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT COUNT(*) as count FROM sessions").get();
+  const db3 = getDatabase();
+  const row = db3.query("SELECT COUNT(*) as count FROM sessions").get();
   return row.count;
 }
 function sessionFromRow(row) {
@@ -19185,6 +19931,7 @@ export {
   writeScenarioMeta,
   writeRunMeta,
   uuid,
+  updateTestingWorkflow,
   updateSchedule,
   updateScenario,
   updateRun,
@@ -19202,6 +19949,7 @@ export {
   screenshotFromRow,
   scheduleFromRow,
   scenarioFromRow,
+  runTestingWorkflow,
   runSmoke,
   runSingleScenario,
   runRepoTests,
@@ -19233,6 +19981,7 @@ export {
   loginWithAuthConfig,
   loadConfig,
   listWebhooks,
+  listTestingWorkflows,
   listTemplateNames,
   listSessions,
   listScreenshots,
@@ -19255,6 +20004,7 @@ export {
   imageToBase64,
   getWebhook,
   getTransitiveDependencies,
+  getTestingWorkflow,
   getTemplate,
   getStarterScenarios,
   getSession,
@@ -19311,13 +20061,16 @@ export {
   diffRuns,
   detectFramework,
   deleteWebhook,
+  deleteTestingWorkflow,
   deleteSession,
   deleteSchedule,
   deleteScenario,
   deleteRun,
   deleteFlow,
   deleteAuthPreset,
+  createWorkflowDatabaseBundle,
   createWebhook,
+  createTestingWorkflow,
   createSession,
   createScreenshot,
   createSchedule,
@@ -19336,6 +20089,7 @@ export {
   closeBrowser,
   clearDiscoveryCache,
   checkBudget,
+  buildWorkflowRunPlan,
   agentFromRow,
   addDependency,
   VersionConflictError,