@hasna/testers 0.0.34 → 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
@@ -19778,7 +20313,6 @@ var require_range = __commonJS((exports, module) => {
       return this.range;
     }
     parseRange(range) {
-      range = range.replace(BUILDSTRIPRE, "");
       const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
       const memoKey = memoOpts + ":" + range;
       const cached = cache.get(memoKey);
@@ -19860,14 +20394,12 @@ var require_range = __commonJS((exports, module) => {
   var SemVer = require_semver();
   var {
     safeRe: re,
-    src,
     t,
     comparatorTrimReplace,
     tildeTrimReplace,
     caretTrimReplace
   } = require_re();
   var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
-  var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
   var isNullSet = (c) => c.value === "<0.0.0-0";
   var isAny = (c) => c.value === "";
   var isSatisfiable = (comparators, options) => {
@@ -25417,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();
@@ -26023,54 +26544,52 @@ import { promises as fsPromises } from "fs";
 import { createHash as createHash2, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
 import { homedir as homedir22 } from "os";
-import { dirname as dirname32, join as join62 } from "path";
+import { dirname as dirname32, join as join52 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 import { webcrypto as crypto2 } from "crypto";
-import { existsSync as existsSync5, writeFileSync as writeFileSync42, readFileSync as readFileSync32, mkdirSync as mkdirSync32 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync42, writeFileSync as writeFileSync32, readFileSync as readFileSync22, mkdirSync as mkdirSync32 } from "fs";
+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 { execFileSync } from "child_process";
-import { writeFileSync as writeFileSync22, existsSync as existsSync32, readFileSync as readFileSync8 } from "fs";
-import { join as join32 } from "path";
-import { hostname } from "os";
-import { existsSync as existsSync42, readFileSync as readFileSync22, writeFileSync as writeFileSync32, mkdirSync as mkdirSync22 } from "fs";
+import { execSync as execSync3, execFileSync } from "child_process";
+import { existsSync as existsSync32, readFileSync as readFileSync7, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join42, dirname as dirname22 } from "path";
+import { join as join32, dirname as dirname22 } from "path";
+import { hostname } from "os";
 import { Buffer as Buffer2 } from "buffer";
 import * as zlib from "zlib";
 import { Readable } from "stream";
 import { Writable } from "stream";
 import { createHash as createHash22 } from "crypto";
-import { mkdirSync as mkdirSync4, statSync as statSync2, writeFileSync as writeFileSync52 } from "fs";
-import { dirname as dirname42, join as join72, relative as relative3 } from "path";
+import { mkdirSync as mkdirSync4, statSync as statSync2, writeFileSync as writeFileSync42 } from "fs";
+import { dirname as dirname42, join as join62, relative as relative3 } from "path";
 import { readdir, readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync72, readdirSync as readdirSync5, readFileSync as readFileSync52, statSync as statSync22 } from "fs";
-import { basename as basename2, join as join82, resolve as resolve22 } from "path";
+import { existsSync as existsSync62, readdirSync as readdirSync5, readFileSync as readFileSync42, statSync as statSync22 } from "fs";
+import { basename as basename2, join as join72, resolve as resolve22 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync82, readFileSync as readFileSync62, writeFileSync as writeFileSync62, mkdirSync as mkdirSync52 } from "fs";
-import { dirname as dirname5, join as join92 } from "path";
+import { existsSync as existsSync72, readFileSync as readFileSync52, writeFileSync as writeFileSync52, mkdirSync as mkdirSync52 } from "fs";
+import { dirname as dirname5, join as join82 } from "path";
 import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync112 } from "fs";
-import { join as join122 } from "path";
-import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync92 } from "fs";
-import { homedir as homedir32, hostname as hostname2, platform as platform2, type } from "os";
-import { join as join102 } from "path";
 import { existsSync as existsSync102 } from "fs";
-import { execSync as execSync3 } from "child_process";
 import { join as join112 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync82 } from "fs";
+import { homedir as homedir32, hostname as hostname2, platform as platform2, type } from "os";
+import { join as join92 } from "path";
+import { existsSync as existsSync92 } from "fs";
 import { execSync as execSync22 } from "child_process";
-import { readFileSync as readFileSync72 } from "fs";
+import { join as join102 } from "path";
+import { execSync as execSync32 } from "child_process";
+import { readFileSync as readFileSync62 } from "fs";
 import { mkdirSync as mkdirSync62 } from "fs";
-import { dirname as dirname6, join as join132 } from "path";
+import { dirname as dirname6, join as join122 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync122 } from "fs";
+import { existsSync as existsSync112 } from "fs";
 function __accessProp3(key) {
   return this[key];
 }
@@ -26209,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 });
   }
@@ -26247,25 +26766,14 @@ function uuid2() {
 function isGitRepo(path) {
   return existsSync22(join22(path, ".git"));
 }
-function getCurrentBranch(path) {
-  return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    cwd: path,
-    stdio: "pipe",
-    encoding: "utf-8",
-    env: process.env
-  }).trim();
-}
-function bootstrapPathsToStage(path) {
-  return BOOTSTRAP_PATHS.filter((entry) => existsSync22(join22(path, entry)));
-}
 function gitInit(project) {
   const { path, name, id, slug } = project;
   if (isGitRepo(path))
     return;
-  execFileSync("git", ["init", "-b", "main"], { cwd: path, stdio: "pipe", env: process.env });
+  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,
@@ -26274,18 +26782,26 @@ 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");
-  const staged = bootstrapPathsToStage(path);
-  if (staged.length === 0)
-    return;
-  execFileSync("git", ["add", ...staged], { cwd: path, stdio: "pipe", env: process.env });
-  execFileSync("git", ["commit", "-m", `chore: init project ${name}`], {
+  execSync3("git add .gitignore .project.json", { cwd: path, stdio: "pipe" });
+  execSync3(`git commit -m "chore: init project ${name}"`, {
     cwd: path,
     stdio: "pipe",
     env: { ...process.env, GIT_AUTHOR_NAME: "open-projects", GIT_COMMITTER_NAME: "open-projects" }
   });
 }
+function getConfig() {
+  if (existsSync32(CONFIG_PATH3)) {
+    try {
+      const user = JSON.parse(readFileSync7(CONFIG_PATH3, "utf-8"));
+      return { ...DEFAULTS, ...user };
+    } catch {
+      return { ...DEFAULTS };
+    }
+  }
+  return { ...DEFAULTS };
+}
 function rowToWorkdir(row) {
   return {
     ...row,
@@ -26329,176 +26845,6 @@ function removeWorkdir(projectId, path, db2) {
   const d = db2 || getDatabase2();
   d.run("DELETE FROM project_workdirs WHERE project_id = ? AND path = ?", [projectId, path]);
 }
-function markWorkdirGenerated(projectId, path, db2) {
-  const d = db2 || getDatabase2();
-  d.run("UPDATE project_workdirs SET claude_md_generated = 1, agents_md_generated = 1 WHERE project_id = ? AND path = ?", [projectId, path]);
-}
-function buildWorkdirList(workdirs, currentPath) {
-  return workdirs.map((w) => {
-    const isCurrent = w.path === currentPath;
-    const primary = w.is_primary ? " (primary)" : "";
-    const current = isCurrent ? " \u2190 you are here" : "";
-    return `- \`${w.path}\` [${w.label}]${primary}${current}  *(machine: ${w.machine_id})*`;
-  }).join(`
-`);
-}
-function claudeMdContent(project, workdir, allWorkdirs) {
-  const otherDirs = allWorkdirs.filter((w) => w.path !== workdir.path);
-  const otherSection = otherDirs.length ? `
-## Other Working Directories
-${buildWorkdirList(otherDirs, workdir.path)}
-` : "";
-  const integrations = Object.keys(project.integrations).length ? `
-## Integrations
-${Object.entries(project.integrations).filter(([, v]) => v).map(([k, v]) => `- **${k}:** \`${v}\``).join(`
-`)}
-` : "";
-  const tags = project.tags.length ? `
-**Tags:** ${project.tags.join(", ")}` : "";
-  return `# Project: ${project.name}
-
-> ${project.description ?? `Working directory for project **${project.name}**`}
-${tags}
-
-## Working Directory
-
-You are working in the **${workdir.label}** directory for this project:
-
-\`\`\`
-${workdir.path}
-\`\`\`
-
-**Write all code to this directory.** Do not write to other project directories unless explicitly instructed.
-
-## Project Metadata
-
-| Field | Value |
-|-------|-------|
-| ID | \`${project.id}\` |
-| Slug | \`${project.slug}\` |
-| Label | \`${workdir.label}\` |
-| Machine | \`${workdir.machine_id}\` |
-| Status | ${project.status} |
-${project.git_remote ? `| Git Remote | ${project.git_remote} |` : ""}
-${project.s3_bucket ? `| S3 Bucket | \`${project.s3_bucket}\` |` : ""}
-${integrations}${otherSection}
-## All Working Directories
-
-${buildWorkdirList(allWorkdirs, workdir.path)}
-
-## Instructions for AI Agents
-
-1. **Write code in \`${workdir.path}\`** \u2014 this is your working directory for this session.
-2. Use \`projects sync ${project.slug}\` to push changes to S3.
-3. Use \`projects git ${project.slug} <args>\` to run git commands.
-4. If you need to switch to a different workdir, call \`projects_open\` with the project ID.
-
----
-*Generated by open-projects. Regenerate: \`projects workdir generate ${project.slug}\`*
-`.trimStart();
-}
-function agentsMdContent(project, workdir, allWorkdirs) {
-  const otherDirs = allWorkdirs.filter((w) => w.path !== workdir.path);
-  return `---
-project_id: ${project.id}
-project_slug: ${project.slug}
-project_name: ${project.name}
-working_directory: ${workdir.path}
-label: ${workdir.label}
-machine_id: ${workdir.machine_id}
-is_primary: ${workdir.is_primary}
----
-
-# ${project.name} \u2014 Agent Instructions
-
-## Scope
-
-This agent session is scoped to the **${workdir.label}** working directory:
-
-\`\`\`
-${workdir.path}
-\`\`\`
-
-**Only write files inside this directory** unless the user explicitly asks you to work elsewhere.
-${otherDirs.length ? `
-## Other workdirs for this project
-
-${otherDirs.map((w) => `- \`${w.path}\` [${w.label}] on ${w.machine_id}`).join(`
-`)}
-` : ""}
-## Quick Reference
-
-\`\`\`bash
-# Open this project
-cd ${workdir.path}
-
-# Sync to S3
-projects sync ${project.slug}
-
-# Git operations
-projects git ${project.slug} status
-projects git ${project.slug} log --oneline -10
-\`\`\`
-${Object.keys(project.integrations).length ? `
-## Service IDs
-
-${Object.entries(project.integrations).filter(([, v]) => v).map(([k, v]) => `- **${k}:** \`${v}\``).join(`
-`)}
-` : ""}
----
-*Generated by open-projects ${new Date().toISOString().slice(0, 10)}*
-`.trimStart();
-}
-function generateForWorkdir(project, workdir, allWorkdirs, options = {}) {
-  const claudeMd = claudeMdContent(project, workdir, allWorkdirs);
-  const agentsMd = agentsMdContent(project, workdir, allWorkdirs);
-  const claudePath = join32(workdir.path, "CLAUDE.md");
-  const agentsPath = join32(workdir.path, "AGENTS.md");
-  let written = false;
-  if (!options.dryRun && existsSync32(workdir.path)) {
-    if (existsSync32(claudePath) && !options.force) {
-      const existing = readFileSync8(claudePath, "utf-8");
-      if (existing.includes("Generated by open-projects")) {
-        writeFileSync22(claudePath, claudeMd, "utf-8");
-      } else {
-        const separator = `
-
----
-
-<!-- open-projects -->
-`;
-        const marker = "<!-- open-projects -->";
-        if (existing.includes(marker)) {
-          const before = existing.slice(0, existing.indexOf(marker) - separator.length + 1);
-          writeFileSync22(claudePath, before + separator + claudeMd, "utf-8");
-        } else {
-          writeFileSync22(claudePath, existing.trimEnd() + separator + claudeMd, "utf-8");
-        }
-      }
-    } else {
-      writeFileSync22(claudePath, claudeMd, "utf-8");
-    }
-    writeFileSync22(agentsPath, agentsMd, "utf-8");
-    markWorkdirGenerated(project.id, workdir.path, options.db);
-    written = true;
-  }
-  return { path: workdir.path, claude_md: claudeMd, agents_md: agentsMd, written };
-}
-function generateAllWorkdirs(project, options = {}) {
-  const workdirs = listWorkdirs(project.id, options.db);
-  return workdirs.map((w) => generateForWorkdir(project, w, workdirs, options));
-}
-function getConfig() {
-  if (existsSync42(CONFIG_PATH3)) {
-    try {
-      const user = JSON.parse(readFileSync22(CONFIG_PATH3, "utf-8"));
-      return { ...DEFAULTS, ...user };
-    } catch {
-      return { ...DEFAULTS };
-    }
-  }
-  return { ...DEFAULTS };
-}
 function generateProjectId() {
   return `prj_${nanoid()}`;
 }
@@ -26506,10 +26852,12 @@ function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function scaffoldProject(path) {
+  if (existsSync42(path))
+    return;
   mkdirSync32(path, { recursive: true });
   const config = getConfig();
   for (const dir of config.scaffold_dirs || ["data", "scripts", "assets", "docs"]) {
-    mkdirSync32(join52(path, dir), { recursive: true });
+    mkdirSync32(join42(path, dir), { recursive: true });
   }
 }
 function ensureUniqueSlug(base, db2, excludeId) {
@@ -26560,9 +26908,6 @@ function createProject2(input, db2) {
   try {
     addWorkdir({ project_id: id, path: input.path, label: "main", is_primary: true }, d);
   } catch {}
-  try {
-    generateAllWorkdirs(project, { db: d });
-  } catch {}
   const shouldGitInit = input.git_init !== false;
   if (shouldGitInit) {
     try {
@@ -26668,10 +27013,10 @@ function setIntegrations(id, integrations, db2) {
     id
   ]);
   try {
-    const jsonPath = join52(project.path, ".project.json");
-    if (existsSync5(jsonPath)) {
-      const existing = JSON.parse(readFileSync32(jsonPath, "utf-8"));
-      writeFileSync42(jsonPath, JSON.stringify({ ...existing, integrations: merged }, null, 2) + `
+    const jsonPath = join42(project.path, ".project.json");
+    if (existsSync42(jsonPath)) {
+      const existing = JSON.parse(readFileSync22(jsonPath, "utf-8"));
+      writeFileSync32(jsonPath, JSON.stringify({ ...existing, integrations: merged }, null, 2) + `
 `, "utf-8");
     }
   } catch {}
@@ -27745,7 +28090,7 @@ async function collectLocalFiles(rootPath) {
   async function walk(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join72(dir, entry.name);
+      const fullPath = join62(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else if (entry.isFile()) {
@@ -27817,7 +28162,7 @@ async function syncProject(project, options = {}) {
           continue;
         }
         try {
-          const data = await readFile2(join72(project.path, relPath));
+          const data = await readFile2(join62(project.path, relPath));
           await client.send(new PutObjectCommand({
             Bucket: bucket,
             Key: s3Key,
@@ -27855,9 +28200,9 @@ async function syncProject(project, options = {}) {
             chunks.push(chunk);
           }
           const data = Buffer.concat(chunks);
-          const localPath = join72(project.path, relPath);
+          const localPath = join62(project.path, relPath);
           mkdirSync4(dirname42(localPath), { recursive: true });
-          writeFileSync52(localPath, data);
+          writeFileSync42(localPath, data);
           log(`pull: ${relPath} (${data.length}B)`);
           result.pulled++;
           result.bytes += data.length;
@@ -27878,18 +28223,18 @@ async function syncProject(project, options = {}) {
   return result;
 }
 function inferProjectName(projectPath) {
-  const pkgPath = join82(projectPath, "package.json");
-  if (existsSync72(pkgPath)) {
+  const pkgPath = join72(projectPath, "package.json");
+  if (existsSync62(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync52(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync42(pkgPath, "utf-8"));
       if (pkg.name)
         return pkg.name.replace(/^@[^/]+\//, "");
     } catch {}
   }
-  const projPath = join82(projectPath, ".project.json");
-  if (existsSync72(projPath)) {
+  const projPath = join72(projectPath, ".project.json");
+  if (existsSync62(projPath)) {
     try {
-      const p2 = JSON.parse(readFileSync52(projPath, "utf-8"));
+      const p2 = JSON.parse(readFileSync42(projPath, "utf-8"));
       if (p2.name)
         return p2.name;
     } catch {}
@@ -27897,11 +28242,11 @@ function inferProjectName(projectPath) {
   return basename2(projectPath);
 }
 function inferGitRemote(projectPath) {
-  const gitConfigPath = join82(projectPath, ".git", "config");
-  if (!existsSync72(gitConfigPath))
+  const gitConfigPath = join72(projectPath, ".git", "config");
+  if (!existsSync62(gitConfigPath))
     return;
   try {
-    const config = readFileSync52(gitConfigPath, "utf-8");
+    const config = readFileSync42(gitConfigPath, "utf-8");
     const match = config.match(/\[remote "origin"\][\s\S]*?url\s*=\s*(.+)/);
     return match?.[1]?.trim();
   } catch {
@@ -27911,7 +28256,7 @@ function inferGitRemote(projectPath) {
 async function importProject(projectPath, options = {}) {
   const absPath = resolve22(projectPath);
   const log = options.onProgress ?? (() => {});
-  if (!existsSync72(absPath)) {
+  if (!existsSync62(absPath)) {
     return { error: `Path does not exist: ${absPath}` };
   }
   const stat = statSync22(absPath);
@@ -27946,7 +28291,7 @@ async function importBulk(dirPath, options = {}) {
   const absDir = resolve22(dirPath);
   const result = { imported: [], skipped: [], errors: [] };
   const log = options.onProgress ?? (() => {});
-  if (!existsSync72(absDir)) {
+  if (!existsSync62(absDir)) {
     result.errors.push({ path: absDir, error: "Directory does not exist" });
     return result;
   }
@@ -27954,7 +28299,7 @@ async function importBulk(dirPath, options = {}) {
   const dirs = entries.filter((e2) => e2.isDirectory() && !e2.name.startsWith("."));
   log(`Found ${dirs.length} subdirectories in ${absDir}`);
   for (const entry of dirs) {
-    const subPath = join82(absDir, entry.name);
+    const subPath = join72(absDir, entry.name);
     const res = await importProject(subPath, options);
     if (res.project) {
       result.imported.push(res.project);
@@ -27989,8 +28334,7 @@ function publishProject(name, path, options = {}) {
       } else {
         execFileSync2("git", ["remote", "add", "origin", remote], { cwd: path, stdio: "pipe", env: process.env });
       }
-      const branch = getCurrentBranch(path);
-      execFileSync2("git", ["push", "-u", "origin", branch, "--quiet"], { cwd: path, stdio: "pipe", env: process.env });
+      execFileSync2("git", ["push", "-u", "origin", "main", "--quiet"], { cwd: path, stdio: "pipe", env: process.env });
       pushed = true;
     } catch {}
   }
@@ -28016,14 +28360,14 @@ function getGitHubUrl(path) {
   }
 }
 function getScheduleConfig() {
-  if (!existsSync82(CONFIG_PATH22)) {
+  if (!existsSync72(CONFIG_PATH22)) {
     return { enabled: false, interval: "daily", direction: "both" };
   }
-  return JSON.parse(readFileSync62(CONFIG_PATH22, "utf-8"));
+  return JSON.parse(readFileSync52(CONFIG_PATH22, "utf-8"));
 }
 function saveScheduleConfig(config) {
   mkdirSync52(dirname5(CONFIG_PATH22), { recursive: true });
-  writeFileSync62(CONFIG_PATH22, JSON.stringify(config, null, 2) + `
+  writeFileSync52(CONFIG_PATH22, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 async function syncAll(direction = "both", onProgress) {
@@ -28053,7 +28397,7 @@ async function syncAll(direction = "both", onProgress) {
 function getMachineProfile() {
   const host = (process.env["HOSTNAME"] || hostname2()).split(".")[0] || hostname2();
   const currentPlatform = platform2();
-  const workspaceRoot = currentPlatform === "darwin" ? join102(homedir32(), "Workspace") : join102(homedir32(), "workspace");
+  const workspaceRoot = currentPlatform === "darwin" ? join92(homedir32(), "Workspace") : join92(homedir32(), "workspace");
   return {
     hostname: host,
     platform: currentPlatform,
@@ -28080,7 +28424,7 @@ function commandAvailability(command, versionArgs = ["--version"]) {
   return { command, available: true, path: commandPath, version };
 }
 function pathExists(path) {
-  return existsSync92(path);
+  return existsSync82(path);
 }
 function classifyMachine(host, currentPlatform) {
   if (host === "apple01")
@@ -28094,10 +28438,10 @@ function classifyMachine(host, currentPlatform) {
   return "unknown";
 }
 function gitStatus(path) {
-  if (!existsSync102(join112(path, ".git")))
+  if (!existsSync92(join102(path, ".git")))
     return "not a repo";
   try {
-    const out = execSync3("git status --porcelain", { cwd: path, stdio: "pipe", encoding: "utf-8" }).trim();
+    const out = execSync22("git status --porcelain", { cwd: path, stdio: "pipe", encoding: "utf-8" }).trim();
     if (!out)
       return "clean";
     const n2 = out.split(`
@@ -28108,17 +28452,17 @@ function gitStatus(path) {
   }
 }
 function dirSize(path) {
-  if (!existsSync102(path))
+  if (!existsSync92(path))
     return 0;
   try {
-    const out = execSync3(`du -sb -- "${path}" 2>/dev/null || du -sk -- "${path}" 2>/dev/null`, { stdio: "pipe", encoding: "utf-8" }).trim();
+    const out = execSync22(`du -sb -- "${path}" 2>/dev/null || du -sk -- "${path}" 2>/dev/null`, { stdio: "pipe", encoding: "utf-8" }).trim();
     return parseInt(out.split("\t")[0] ?? "0", 10);
   } catch {
     return 0;
   }
 }
 function getProjectStatus(project) {
-  const pathExists2 = existsSync102(project.path);
+  const pathExists2 = existsSync92(project.path);
   const workdirs = listWorkdirs(project.id);
   const lastSync = getDatabase2().query("SELECT completed_at FROM sync_log WHERE project_id = ? AND status = 'completed' ORDER BY completed_at DESC LIMIT 1").get(project.id)?.completed_at ?? null;
   return {
@@ -28131,21 +28475,18 @@ function getProjectStatus(project) {
   };
 }
 function run(cmd) {
-  return execSync22(cmd, { encoding: "utf-8", stdio: "pipe" }).trim();
+  return execSync32(cmd, { encoding: "utf-8", stdio: "pipe" }).trim();
 }
 function getTmuxSessionName(project) {
-  return project.slug || project.name;
+  const raw = project.slug || project.name;
+  if (project.path?.includes("opensourcedev")) {
+    const normalized = raw.replace(/^proj-/, "");
+    return normalized.startsWith("open-") ? normalized : `open-${normalized}`;
+  }
+  return raw;
 }
 function listSessions2() {
-  let output = "";
-  try {
-    output = run("tmux list-sessions -F '#{session_name}:#{session_group}:#{session_windows}:#{session_attached}'");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("no server running"))
-      return [];
-    throw err;
-  }
+  const output = run("tmux list-sessions -F '#{session_name}:#{session_group}:#{session_windows}:#{session_attached}'");
   return output.split(`
 `).filter(Boolean).map((line) => {
     const [name, group, windows, attached] = line.split(":");
@@ -28253,7 +28594,7 @@ function getProjectLocations(project) {
   const currentMachine = getMachineId();
   return listWorkdirs(project.id).map((workdir) => ({
     ...workdir,
-    exists: existsSync112(workdir.path),
+    exists: existsSync102(workdir.path),
     currentMachine: workdir.machine_id === currentMachine,
     recommended: workdir.is_primary || workdir.path === project.path
   }));
@@ -28290,7 +28631,7 @@ function buildProjectContext(project) {
   };
 }
 function getGitContext(path) {
-  if (!existsSync112(join122(path, ".git"))) {
+  if (!existsSync102(join112(path, ".git"))) {
     return { isRepo: false, branch: null, dirtyCount: null, remote: null };
   }
   return {
@@ -28333,7 +28674,7 @@ function setupMachineReport(options = {}) {
   const dryRun = options.dryRun !== false;
   const checks = [];
   const dbDir = dirname6(getDbPath2());
-  const cloudConfig = join132(process.env["HOME"] || "~", ".hasna", "cloud", "config.json");
+  const cloudConfig = join122(process.env["HOME"] || "~", ".hasna", "cloud", "config.json");
   checks.push(pathCheck("PROJECTS_DATA_DIR", "projects data dir", dbDir, options));
   checks.push(pathCheck("WORKSPACE_ROOT", "workspace root", machine.workspaceRoot, options));
   checks.push(commandCheck("bun", ["--version"], "Bun runtime"));
@@ -28394,8 +28735,8 @@ function commandCheck(command, versionArgs, label, missingStatus = "error") {
 }
 function packageVersion() {
   try {
-    const pkgPath = join132(dirname6(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync72(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join122(dirname6(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync62(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -28409,7 +28750,7 @@ function findStaleIssues(project) {
   const issues = [];
   const currentMachine = getMachineId();
   for (const p2 of projects) {
-    if (p2.status === "active" && !existsSync122(p2.path)) {
+    if (p2.status === "active" && !existsSync112(p2.path)) {
       issues.push({
         code: "PROJECT_PATH_MISSING",
         severity: "error",
@@ -28420,7 +28761,7 @@ function findStaleIssues(project) {
       });
     }
     for (const workdir of listWorkdirs(p2.id)) {
-      if (workdir.machine_id === currentMachine && !existsSync122(workdir.path)) {
+      if (workdir.machine_id === currentMachine && !existsSync112(workdir.path)) {
         issues.push({
           code: "WORKDIR_PATH_MISSING",
           severity: "warn",
@@ -29362,7 +29703,7 @@ Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.ht
   }
   const credentials = await fromWebToken({
     ...init,
-    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync42(webIdentityTokenFile, { encoding: "ascii" }),
+    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync32(webIdentityTokenFile, { encoding: "ascii" }),
     roleArn,
     roleSessionName
   })(awsIdentityProperties);
@@ -29449,7 +29790,7 @@ coverage/
 # Cache
 .cache/
 .turbo/
-`, BOOTSTRAP_PATHS, CONFIG_PATH3, DEFAULTS, nanoid, import_protocol_http, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin = (options) => ({
+`, CONFIG_PATH3, DEFAULTS, nanoid, import_protocol_http, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin = (options) => ({
   applyToStack: (clientStack) => {
     clientStack.add(addExpectContinueMiddleware(options), addExpectContinueMiddlewareOptions);
   }
@@ -42528,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) {
@@ -47260,7 +47601,7 @@ More information can be found at: https://a.co/c895JFp`);
     };
   });
   require_dist_cjs41 = __commonJS3((exports) => {
-    var __dirname2 = "/Users/hasna/Workspace/hasna/opensource/open-projects/node_modules/@aws-sdk/util-user-agent-node/dist-cjs";
+    var __dirname2 = "/home/hasna/workspace/hasna/opensource/open-projects/node_modules/@aws-sdk/util-user-agent-node/dist-cjs";
     var node_os = __require3("os");
     var node_process = __require3("process");
     var utilConfigProvider = require_dist_cjs28();
@@ -50930,10 +51271,10 @@ More information can be found at: https://a.co/c895JFp`);
         await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
       }
       getTokenFilePath() {
-        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join62(homedir22(), ".aws", "login", "cache");
+        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join52(homedir22(), ".aws", "login", "cache");
         const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
         const loginSessionSha256 = createHash2("sha256").update(loginSessionBytes).digest("hex");
-        return join62(directory, `${loginSessionSha256}.json`);
+        return join52(directory, `${loginSessionSha256}.json`);
       }
       derToRawSignature(derSignature) {
         let offset = 2;
@@ -51234,18 +51575,7 @@ More information can be found at: https://a.co/c895JFp`);
   INSERT OR IGNORE INTO _migrations (id) VALUES (4);
   `
   ];
-  BOOTSTRAP_PATHS = [
-    ".gitignore",
-    ".project.json",
-    "CLAUDE.md",
-    "AGENTS.md",
-    "README.md",
-    "docs",
-    "data",
-    "scripts",
-    "assets"
-  ];
-  CONFIG_PATH3 = join42(homedir11(), ".hasna", "projects", "config.json");
+  CONFIG_PATH3 = join32(homedir11(), ".hasna", "projects", "config.json");
   DEFAULTS = {
     default_path: process.cwd(),
     default_github_org: "hasnaxyz",
@@ -57031,7 +57361,7 @@ More information can be found at: https://a.co/c895JFp`);
   }).s("AmazonS3", "PutObject", {}).n("S3Client", "PutObjectCommand").sc(PutObject$).build() {
   };
   MAX_FILE_SIZE = 100 * 1024 * 1024;
-  CONFIG_PATH22 = join92(process.env["HOME"] || "~", ".hasna", "projects", "scheduler.json");
+  CONFIG_PATH22 = join82(process.env["HOME"] || "~", ".hasna", "projects", "scheduler.json");
   SPARK_MACHINES = new Set(["spark01", "spark02"]);
 });
 
@@ -57289,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);
@@ -57318,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;
@@ -57381,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");
@@ -57721,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 {
@@ -74582,34 +74912,27 @@ var init_v3 = __esm(() => {
 
 // node_modules/@ai-sdk/provider-utils/node_modules/eventsource-parser/dist/index.js
 function noop(_arg) {}
-function createParser(config2) {
-  if (typeof config2 == "function")
-    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
-  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [];
-  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError("`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?");
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+  let isFirstChunk = true, id, data = "", dataLines = 0, eventType;
   function feed(chunk) {
-    if (terminated)
-      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
     if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
       const trailing2 = processLines(chunk);
-      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      trailing2 !== "" && pendingFragments.push(trailing2);
       return;
     }
     if (chunk.indexOf(`
 `) === -1 && chunk.indexOf("\r") === -1) {
-      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      pendingFragments.push(chunk);
       return;
     }
     pendingFragments.push(chunk);
     const input = pendingFragments.join("");
-    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    pendingFragments.length = 0;
     const trailing = processLines(input);
-    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
-  }
-  function checkBufferSize() {
-    maxBufferSize !== undefined && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = undefined, data = "", dataLines = 0, eventType = undefined, onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
-      type: "max-buffer-size-exceeded"
-    }))));
+    trailing !== "" && pendingFragments.push(trailing);
   }
   function processLines(chunk) {
     let searchIndex = 0;
@@ -74721,7 +75044,7 @@ ${value}`, dataLines++;
       const incompleteLine = pendingFragments.join("");
       parseLine(incompleteLine, 0, incompleteLine.length);
     }
-    isFirstChunk = true, id = undefined, data = "", dataLines = 0, eventType = undefined, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+    isFirstChunk = true, id = undefined, data = "", dataLines = 0, eventType = undefined, pendingFragments.length = 0;
   }
   return { feed, reset };
 }
@@ -74745,7 +75068,7 @@ var EventSourceParserStream;
 var init_stream = __esm(() => {
   init_dist4();
   EventSourceParserStream = class EventSourceParserStream extends TransformStream {
-    constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+    constructor({ onError, onRetry, onComment } = {}) {
       let parser;
       super({
         start(controller) {
@@ -74754,11 +75077,10 @@ var init_stream = __esm(() => {
               controller.enqueue(event);
             },
             onError(error40) {
-              typeof onError == "function" && onError(error40), (onError === "terminate" || error40.type === "max-buffer-size-exceeded") && controller.error(error40);
+              onError === "terminate" ? controller.error(error40) : typeof onError == "function" && onError(error40);
             },
             onRetry,
-            onComment,
-            maxBufferSize
+            onComment
           });
         },
         transform(chunk) {
@@ -76100,7 +76422,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve4(value) {
+async function resolve3(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -76197,7 +76519,7 @@ var DelayedPromise = class {
     });
   }
   return () => `${prefix}${separator}${generator()}`;
-}, generateId, FETCH_FAILED_ERROR_MESSAGES, BUN_ERROR_CODES, VERSION = "4.0.27", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
+}, generateId, FETCH_FAILED_ERROR_MESSAGES, BUN_ERROR_CODES, VERSION = "4.0.26", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
   url: url2,
   headers = {},
   successfulResponseHandler,
@@ -76863,19 +77185,19 @@ var require_token_io = __commonJS((exports, module) => {
     getUserDataDir: () => getUserDataDir
   });
   module.exports = __toCommonJS2(token_io_exports);
-  var import_path27 = __toESM4(__require("path"));
-  var import_fs31 = __toESM4(__require("fs"));
+  var import_path26 = __toESM4(__require("path"));
+  var import_fs30 = __toESM4(__require("fs"));
   var import_os13 = __toESM4(__require("os"));
   var import_token_error = require_token_error();
   function findRootDir() {
     try {
       let dir = process.cwd();
-      while (dir !== import_path27.default.dirname(dir)) {
-        const pkgPath = import_path27.default.join(dir, ".vercel");
-        if (import_fs31.default.existsSync(pkgPath)) {
+      while (dir !== import_path26.default.dirname(dir)) {
+        const pkgPath = import_path26.default.join(dir, ".vercel");
+        if (import_fs30.default.existsSync(pkgPath)) {
           return dir;
         }
-        dir = import_path27.default.dirname(dir);
+        dir = import_path26.default.dirname(dir);
       }
     } catch (e2) {
       throw new import_token_error.VercelOidcTokenError("Token refresh only supported in node server environments");
@@ -76888,9 +77210,9 @@ var require_token_io = __commonJS((exports, module) => {
     }
     switch (import_os13.default.platform()) {
       case "darwin":
-        return import_path27.default.join(import_os13.default.homedir(), "Library/Application Support");
+        return import_path26.default.join(import_os13.default.homedir(), "Library/Application Support");
       case "linux":
-        return import_path27.default.join(import_os13.default.homedir(), ".local/share");
+        return import_path26.default.join(import_os13.default.homedir(), ".local/share");
       case "win32":
         if (process.env.LOCALAPPDATA) {
           return process.env.LOCALAPPDATA;
@@ -77787,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(),
@@ -77805,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(),
@@ -77851,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(),
@@ -77873,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(),
@@ -77906,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,
@@ -77914,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({
@@ -77937,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({
@@ -78026,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,
@@ -78034,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 } : {}
@@ -78090,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,
@@ -78098,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,
@@ -78173,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,
@@ -78300,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,
@@ -78308,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,
@@ -78342,7 +78664,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       "ai-model-id": this.modelId
     };
   }
-}, gatewayRerankingResponseSchema, parallelSearchInputSchema, parallelSearchOutputSchema, parallelSearchToolFactory, parallelSearch = (config2 = {}) => parallelSearchToolFactory(config2), perplexitySearchInputSchema, perplexitySearchOutputSchema, perplexitySearchToolFactory, perplexitySearch = (config2 = {}) => perplexitySearchToolFactory(config2), gatewayTools, VERSION2 = "3.0.120", AI_GATEWAY_PROTOCOL_VERSION = "0.0.1", gateway;
+}, gatewayRerankingResponseSchema, parallelSearchInputSchema, parallelSearchOutputSchema, parallelSearchToolFactory, parallelSearch = (config2 = {}) => parallelSearchToolFactory(config2), perplexitySearchInputSchema, perplexitySearchOutputSchema, perplexitySearchToolFactory, perplexitySearch = (config2 = {}) => perplexitySearchToolFactory(config2), gatewayTools, VERSION2 = "3.0.110", AI_GATEWAY_PROTOCOL_VERSION = "0.0.1", gateway;
 var init_dist6 = __esm(() => {
   init_dist5();
   init_dist3();
@@ -78381,15 +78703,13 @@ var init_dist6 = __esm(() => {
       message,
       statusCode = 500,
       cause,
-      generationId,
-      isRetryable = statusCode != null && (statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500)
+      generationId
     }) {
       super(generationId ? `${message} [${generationId}]` : message);
       this[_a17] = true;
       this.statusCode = statusCode;
       this.cause = cause;
       this.generationId = generationId;
-      this.isRetryable = isRetryable;
     }
     static isInstance(error40) {
       return _GatewayError.hasMarker(error40);
@@ -78912,11 +79232,62 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
   gateway = createGatewayProvider();
 });
 
+// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
+var require_globalThis = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports._globalThis = undefined;
+  exports._globalThis = typeof globalThis === "object" ? globalThis : global;
+});
+
+// node_modules/@opentelemetry/api/build/src/platform/node/index.js
+var require_node = __commonJS((exports) => {
+  var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    Object.defineProperty(o2, k22, { enumerable: true, get: function() {
+      return m2[k2];
+    } });
+  } : function(o2, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    o2[k22] = m2[k2];
+  });
+  var __exportStar2 = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p2 in m2)
+      if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p2))
+        __createBinding2(exports2, m2, p2);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar2(require_globalThis(), exports);
+});
+
+// node_modules/@opentelemetry/api/build/src/platform/index.js
+var require_platform = __commonJS((exports) => {
+  var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    Object.defineProperty(o2, k22, { enumerable: true, get: function() {
+      return m2[k2];
+    } });
+  } : function(o2, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    o2[k22] = m2[k2];
+  });
+  var __exportStar2 = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p2 in m2)
+      if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p2))
+        __createBinding2(exports2, m2, p2);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar2(require_node(), exports);
+});
+
 // node_modules/@opentelemetry/api/build/src/version.js
 var require_version = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.VERSION = undefined;
-  exports.VERSION = "1.9.1";
+  exports.VERSION = "1.9.0";
 });
 
 // node_modules/@opentelemetry/api/build/src/internal/semver.js
@@ -78994,11 +79365,12 @@ var require_semver2 = __commonJS((exports) => {
 var require_global_utils = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = undefined;
+  var platform_1 = require_platform();
   var version_1 = require_version();
   var semver_1 = require_semver2();
   var major = version_1.VERSION.split(".")[0];
   var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
-  var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+  var _global = platform_1._globalThis;
   function registerGlobal(type2, instance, diag, allowOverride = false) {
     var _a16;
     const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a16 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a16 !== undefined ? _a16 : {
@@ -79070,7 +79442,8 @@ var require_ComponentLogger = __commonJS((exports) => {
     if (!logger) {
       return;
     }
-    return logger[funcName](namespace, ...args);
+    args.unshift(namespace);
+    return logger[funcName](...args);
   }
 });
 
@@ -79131,12 +79504,6 @@ var require_diag = __commonJS((exports) => {
   var API_NAME = "diag";
 
   class DiagAPI {
-    static instance() {
-      if (!this._instance) {
-        this._instance = new DiagAPI;
-      }
-      return this._instance;
-    }
     constructor() {
       function _logProxy(funcName) {
         return function(...args) {
@@ -79181,6 +79548,12 @@ var require_diag = __commonJS((exports) => {
       self2.warn = _logProxy("warn");
       self2.error = _logProxy("error");
     }
+    static instance() {
+      if (!this._instance) {
+        this._instance = new DiagAPI;
+      }
+      return this._instance;
+    }
   }
   exports.DiagAPI = DiagAPI;
 });
@@ -79202,7 +79575,7 @@ var require_baggage_impl = __commonJS((exports) => {
       return Object.assign({}, entry);
     }
     getAllEntries() {
-      return Array.from(this._entries.entries());
+      return Array.from(this._entries.entries()).map(([k2, v2]) => [k2, v2]);
     }
     setEntry(key, entry) {
       const newBaggage = new BaggageImpl(this._entries);
@@ -79294,7 +79667,7 @@ var require_context = __commonJS((exports) => {
 // node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
 var require_consoleLogger = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  exports.DiagConsoleLogger = exports._originalConsoleMethods = undefined;
+  exports.DiagConsoleLogger = undefined;
   var consoleMap = [
     { n: "error", c: "error" },
     { n: "warn", c: "warn" },
@@ -79302,39 +79675,19 @@ var require_consoleLogger = __commonJS((exports) => {
     { n: "debug", c: "debug" },
     { n: "verbose", c: "trace" }
   ];
-  exports._originalConsoleMethods = {};
-  if (typeof console !== "undefined") {
-    const keys = [
-      "error",
-      "warn",
-      "info",
-      "debug",
-      "trace",
-      "log"
-    ];
-    for (const key of keys) {
-      if (typeof console[key] === "function") {
-        exports._originalConsoleMethods[key] = console[key];
-      }
-    }
-  }
 
   class DiagConsoleLogger {
     constructor() {
       function _consoleFunc(funcName) {
         return function(...args) {
-          let theFunc = exports._originalConsoleMethods[funcName];
-          if (typeof theFunc !== "function") {
-            theFunc = exports._originalConsoleMethods["log"];
-          }
-          if (typeof theFunc !== "function" && console) {
-            theFunc = console[funcName];
+          if (console) {
+            let theFunc = console[funcName];
             if (typeof theFunc !== "function") {
               theFunc = console.log;
             }
-          }
-          if (typeof theFunc === "function") {
-            return theFunc.apply(console, args);
+            if (typeof theFunc === "function") {
+              return theFunc.apply(console, args);
+            }
           }
         };
       }
@@ -79572,8 +79925,8 @@ var require_NonRecordingSpan = __commonJS((exports) => {
   var invalid_span_constants_1 = require_invalid_span_constants();
 
   class NonRecordingSpan {
-    constructor(spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
-      this._spanContext = spanContext;
+    constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+      this._spanContext = _spanContext;
     }
     spanContext() {
       return this._spanContext;
@@ -79649,126 +80002,14 @@ var require_spancontext_utils = __commonJS((exports) => {
   exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = undefined;
   var invalid_span_constants_1 = require_invalid_span_constants();
   var NonRecordingSpan_1 = require_NonRecordingSpan();
-  var isHex = new Uint8Array([
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  function isValidHex(id, length) {
-    if (typeof id !== "string" || id.length !== length)
-      return false;
-    let r2 = 0;
-    for (let i2 = 0;i2 < id.length; i2 += 4) {
-      r2 += (isHex[id.charCodeAt(i2)] | 0) + (isHex[id.charCodeAt(i2 + 1)] | 0) + (isHex[id.charCodeAt(i2 + 2)] | 0) + (isHex[id.charCodeAt(i2 + 3)] | 0);
-    }
-    return r2 === length;
-  }
+  var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+  var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
   function isValidTraceId(traceId) {
-    return isValidHex(traceId, 32) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+    return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
   }
   exports.isValidTraceId = isValidTraceId;
   function isValidSpanId(spanId) {
-    return isValidHex(spanId, 16) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+    return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
   }
   exports.isValidSpanId = isValidSpanId;
   function isSpanContextValid(spanContext) {
@@ -79828,7 +80069,7 @@ var require_NoopTracer = __commonJS((exports) => {
   }
   exports.NoopTracer = NoopTracer;
   function isSpanContext(spanContext) {
-    return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+    return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
   }
 });
 
@@ -79840,8 +80081,8 @@ var require_ProxyTracer = __commonJS((exports) => {
   var NOOP_TRACER = new NoopTracer_1.NoopTracer;
 
   class ProxyTracer {
-    constructor(provider, name15, version2, options) {
-      this._provider = provider;
+    constructor(_provider, name15, version2, options) {
+      this._provider = _provider;
       this.name = name15;
       this.version = version2;
       this.options = options;
@@ -80001,7 +80242,7 @@ var require_tracestate_impl = __commonJS((exports) => {
       return this._internalState.get(key);
     }
     serialize() {
-      return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
+      return this._keys().reduce((agg, key) => {
         agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
         return agg;
       }, []).join(LIST_MEMBERS_SEPARATOR);
@@ -80009,7 +80250,7 @@ var require_tracestate_impl = __commonJS((exports) => {
     _parse(rawTraceState) {
       if (rawTraceState.length > MAX_TRACE_STATE_LEN)
         return;
-      this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
+      this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
         const listMember = part.trim();
         const i2 = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
         if (i2 !== -1) {
@@ -81109,10 +81350,7 @@ function convertToLanguageModelMessage({
                 type: "tool-result",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                output: mapToolResultOutput({
-                  output: part.output,
-                  downloadedAssets
-                }),
+                output: mapToolResultOutput(part.output),
                 providerOptions
               };
             }
@@ -81131,10 +81369,7 @@ function convertToLanguageModelMessage({
                 type: "tool-result",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                output: mapToolResultOutput({
-                  output: part.output,
-                  downloadedAssets
-                }),
+                output: mapToolResultOutput(part.output),
                 providerOptions: part.providerOptions
               };
             }
@@ -81158,44 +81393,15 @@ function convertToLanguageModelMessage({
   }
 }
 async function downloadAssets(messages, download2, supportedUrls) {
-  var _a21;
-  const downloadableFiles = [];
-  for (const message of messages) {
-    if (message.role === "user" && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (part.type === "image" || part.type === "file") {
-          downloadableFiles.push({
-            data: part.type === "image" ? part.image : part.data,
-            mediaType: (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : undefined
-          });
-        }
-      }
-    }
-    if (message.role === "tool" || message.role === "assistant") {
-      if (!Array.isArray(message.content)) {
-        continue;
-      }
-      for (const part of message.content) {
-        if (part.type !== "tool-result") {
-          continue;
-        }
-        if (part.output.type !== "content") {
-          continue;
-        }
-        for (const contentPart of part.output.value) {
-          if (contentPart.type === "image-url" || contentPart.type === "file-url") {
-            downloadableFiles.push({
-              data: new URL(contentPart.url),
-              mediaType: contentPart.type === "image-url" ? "image/*" : undefined
-            });
-          }
-        }
-      }
+  const plannedDownloads = messages.filter((message) => message.role === "user").map((message) => message.content).filter((content) => Array.isArray(content)).flat().filter((part) => part.type === "image" || part.type === "file").map((part) => {
+    var _a21;
+    const mediaType = (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : undefined;
+    let data = part.type === "image" ? part.image : part.data;
+    if (typeof data === "string") {
+      try {
+        data = new URL(data);
+      } catch (ignored) {}
     }
-  }
-  const plannedDownloads = downloadableFiles.map((part) => {
-    const mediaType = part.mediaType;
-    const { data } = convertToLanguageModelV3DataContent(part.data);
     return { mediaType, data };
   }).filter((part) => part.data instanceof URL).map((part) => ({
     url: part.data,
@@ -81269,41 +81475,13 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
     }
   }
 }
-function mapToolResultOutput({
-  output,
-  downloadedAssets
-}) {
+function mapToolResultOutput(output) {
   if (output.type !== "content") {
     return output;
   }
   return {
     type: "content",
     value: output.value.map((item) => {
-      var _a21, _b16;
-      if (item.type === "image-url") {
-        const downloadedFile = downloadedAssets[new URL(item.url).toString()];
-        if (downloadedFile) {
-          return {
-            type: "image-data",
-            data: convertDataContentToBase64String(downloadedFile.data),
-            mediaType: (_a21 = downloadedFile.mediaType) != null ? _a21 : "image/*",
-            providerOptions: item.providerOptions
-          };
-        }
-        return item;
-      }
-      if (item.type === "file-url") {
-        const downloadedFile = downloadedAssets[new URL(item.url).toString()];
-        if (downloadedFile) {
-          return {
-            type: "file-data",
-            data: convertDataContentToBase64String(downloadedFile.data),
-            mediaType: (_b16 = downloadedFile.mediaType) != null ? _b16 : "application/octet-stream",
-            providerOptions: item.providerOptions
-          };
-        }
-        return item;
-      }
       if (item.type !== "media") {
         return item;
       }
@@ -81856,7 +82034,7 @@ function getRetryDelayInMs({
   error: error40,
   exponentialBackoffDelay
 }) {
-  const headers = APICallError.isInstance(error40) ? error40.responseHeaders : APICallError.isInstance(error40.cause) ? error40.cause.responseHeaders : undefined;
+  const headers = error40.responseHeaders;
   if (!headers)
     return exponentialBackoffDelay;
   let ms;
@@ -81906,7 +82084,7 @@ async function _retryWithExponentialBackoff(f2, {
         errors: newErrors
       });
     }
-    if (error40 instanceof Error && (APICallError.isInstance(error40) && error40.isRetryable === true || GatewayError.isInstance(error40) && error40.isRetryable === true) && tryNumber <= maxRetries) {
+    if (error40 instanceof Error && APICallError.isInstance(error40) && error40.isRetryable === true && tryNumber <= maxRetries) {
       await delay(getRetryDelayInMs({
         error: error40,
         exponentialBackoffDelay: delayInMs
@@ -82124,8 +82302,7 @@ async function executeToolCall({
           input,
           error: error40,
           dynamic: tool2.type === "dynamic",
-          ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {},
-          ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+          ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
         };
       }
       const durationMs = now3() - startTime;
@@ -82155,8 +82332,7 @@ async function executeToolCall({
         input,
         output,
         dynamic: tool2.type === "dynamic",
-        ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {},
-        ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+        ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
       };
     }
   });
@@ -82521,6 +82697,15 @@ async function parsePartialJson(jsonText) {
   }
   return { value: undefined, state: "failed-parse" };
 }
+function mergeToolProviderMetadata(toolMetadata, callMetadata) {
+  if (toolMetadata == null) {
+    return callMetadata;
+  }
+  if (callMetadata == null) {
+    return toolMetadata;
+  }
+  return { ...toolMetadata, ...callMetadata };
+}
 async function parseToolCall({
   toolCall,
   tools,
@@ -82528,6 +82713,7 @@ async function parseToolCall({
   system,
   messages
 }) {
+  var _a21, _b16;
   try {
     if (tools == null) {
       if (toolCall.providerExecuted && toolCall.dynamic) {
@@ -82568,7 +82754,6 @@ async function parseToolCall({
   } catch (error40) {
     const parsedInput = await safeParseJSON({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
-    const tool2 = tools == null ? undefined : tools[toolCall.toolName];
     return {
       type: "tool-call",
       toolCallId: toolCall.toolCallId,
@@ -82577,10 +82762,9 @@ async function parseToolCall({
       dynamic: true,
       invalid: true,
       error: error40,
-      title: tool2 == null ? undefined : tool2.title,
+      title: (_a21 = tools == null ? undefined : tools[toolCall.toolName]) == null ? undefined : _a21.title,
       providerExecuted: toolCall.providerExecuted,
-      providerMetadata: toolCall.providerMetadata,
-      ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+      providerMetadata: mergeToolProviderMetadata((_b16 = tools == null ? undefined : tools[toolCall.toolName]) == null ? undefined : _b16.providerMetadata, toolCall.providerMetadata)
     };
   }
 }
@@ -82627,14 +82811,14 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
+  const mergedProviderMetadata = mergeToolProviderMetadata(tool2.providerMetadata, toolCall.providerMetadata);
   return tool2.type === "dynamic" ? {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+    providerMetadata: mergedProviderMetadata,
     dynamic: true,
     title: tool2.title
   } : {
@@ -82643,8 +82827,7 @@ async function doParseToolCall({
     toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+    providerMetadata: mergedProviderMetadata,
     title: tool2.title
   };
 }
@@ -83476,8 +83659,7 @@ function asContent({
               error: part.result,
               providerExecuted: true,
               dynamic: part.dynamic,
-              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
             });
           } else {
             contentParts.push({
@@ -83488,8 +83670,7 @@ function asContent({
               output: part.result,
               providerExecuted: true,
               dynamic: part.dynamic,
-              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
             });
           }
           break;
@@ -83503,8 +83684,7 @@ function asContent({
             error: part.result,
             providerExecuted: true,
             dynamic: toolCall.dynamic,
-            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-            ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
           });
         } else {
           contentParts.push({
@@ -83515,8 +83695,7 @@ function asContent({
             output: part.result,
             providerExecuted: true,
             dynamic: toolCall.dynamic,
-            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-            ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
           });
         }
         break;
@@ -83730,9 +83909,6 @@ function processUIMessageStream({
             if (options.title !== undefined) {
               anyPart.title = options.title;
             }
-            if (options.toolMetadata !== undefined) {
-              anyPart.toolMetadata = options.toolMetadata;
-            }
             anyPart.providerExecuted = (_a222 = anyOptions.providerExecuted) != null ? _a222 : part.providerExecuted;
             const providerMetadata = anyOptions.providerMetadata;
             if (providerMetadata != null) {
@@ -83749,7 +83925,6 @@ function processUIMessageStream({
               toolCallId: options.toolCallId,
               state: options.state,
               title: options.title,
-              ...options.toolMetadata !== undefined ? { toolMetadata: options.toolMetadata } : {},
               input: anyOptions.input,
               output: anyOptions.output,
               rawInput: anyOptions.rawInput,
@@ -83777,9 +83952,6 @@ function processUIMessageStream({
             if (options.title !== undefined) {
               anyPart.title = options.title;
             }
-            if (options.toolMetadata !== undefined) {
-              anyPart.toolMetadata = options.toolMetadata;
-            }
             anyPart.providerExecuted = (_b23 = anyOptions.providerExecuted) != null ? _b23 : part.providerExecuted;
             const providerMetadata = anyOptions.providerMetadata;
             if (providerMetadata != null) {
@@ -83802,7 +83974,6 @@ function processUIMessageStream({
               preliminary: anyOptions.preliminary,
               providerExecuted: anyOptions.providerExecuted,
               title: options.title,
-              ...options.toolMetadata !== undefined ? { toolMetadata: options.toolMetadata } : {},
               ...anyOptions.providerMetadata != null && (options.state === "output-available" || options.state === "output-error") ? { resultProviderMetadata: anyOptions.providerMetadata } : {},
               ...anyOptions.providerMetadata != null && !(options.state === "output-available" || options.state === "output-error") ? { callProviderMetadata: anyOptions.providerMetadata } : {}
             });
@@ -83947,8 +84118,7 @@ function processUIMessageStream({
               toolName: chunk.toolName,
               index: toolInvocations.length,
               dynamic: chunk.dynamic,
-              title: chunk.title,
-              toolMetadata: chunk.toolMetadata
+              title: chunk.title
             };
             if (chunk.dynamic) {
               updateDynamicToolPart({
@@ -83958,7 +84128,6 @@ function processUIMessageStream({
                 input: undefined,
                 providerExecuted: chunk.providerExecuted,
                 title: chunk.title,
-                toolMetadata: chunk.toolMetadata,
                 providerMetadata: chunk.providerMetadata
               });
             } else {
@@ -83969,7 +84138,6 @@ function processUIMessageStream({
                 input: undefined,
                 providerExecuted: chunk.providerExecuted,
                 title: chunk.title,
-                toolMetadata: chunk.toolMetadata,
                 providerMetadata: chunk.providerMetadata
               });
             }
@@ -83993,8 +84161,7 @@ function processUIMessageStream({
                 toolName: partialToolCall.toolName,
                 state: "input-streaming",
                 input: partialArgs,
-                title: partialToolCall.title,
-                toolMetadata: partialToolCall.toolMetadata
+                title: partialToolCall.title
               });
             } else {
               updateToolPart({
@@ -84002,8 +84169,7 @@ function processUIMessageStream({
                 toolName: partialToolCall.toolName,
                 state: "input-streaming",
                 input: partialArgs,
-                title: partialToolCall.title,
-                toolMetadata: partialToolCall.toolMetadata
+                title: partialToolCall.title
               });
             }
             write();
@@ -84018,8 +84184,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: chunk.title,
-                toolMetadata: chunk.toolMetadata
+                title: chunk.title
               });
             } else {
               updateToolPart({
@@ -84029,8 +84194,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: chunk.title,
-                toolMetadata: chunk.toolMetadata
+                title: chunk.title
               });
             }
             write();
@@ -84052,8 +84216,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata,
-                toolMetadata: chunk.toolMetadata
+                providerMetadata: chunk.providerMetadata
               });
             } else {
               updateToolPart({
@@ -84064,8 +84227,7 @@ function processUIMessageStream({
                 rawInput: chunk.input,
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata,
-                toolMetadata: chunk.toolMetadata
+                providerMetadata: chunk.providerMetadata
               });
             }
             write();
@@ -84096,8 +84258,7 @@ function processUIMessageStream({
                 preliminary: chunk.preliminary,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             } else {
               updateToolPart({
@@ -84109,8 +84270,7 @@ function processUIMessageStream({
                 providerExecuted: chunk.providerExecuted,
                 preliminary: chunk.preliminary,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             }
             write();
@@ -84127,8 +84287,7 @@ function processUIMessageStream({
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             } else {
               updateToolPart({
@@ -84140,8 +84299,7 @@ function processUIMessageStream({
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             }
             write();
@@ -84599,8 +84757,7 @@ function runToolsTransformation({
                 input: toolCall.input,
                 error: getErrorMessage2(toolCall.error),
                 dynamic: true,
-                title: toolCall.title,
-                ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+                title: toolCall.title
               });
               break;
             }
@@ -84668,7 +84825,6 @@ function runToolsTransformation({
         }
         case "tool-result": {
           const toolName = chunk.toolName;
-          const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
           if (chunk.isError) {
             toolResultsStreamController.enqueue({
               type: "tool-error",
@@ -84678,8 +84834,7 @@ function runToolsTransformation({
               providerExecuted: true,
               error: chunk.result,
               dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {},
-              ...(toolCall == null ? undefined : toolCall.toolMetadata) != null ? { toolMetadata: toolCall.toolMetadata } : {}
+              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
             });
           } else {
             controller.enqueue({
@@ -84690,8 +84845,7 @@ function runToolsTransformation({
               output: chunk.result,
               providerExecuted: true,
               dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {},
-              ...(toolCall == null ? undefined : toolCall.toolMetadata) != null ? { toolMetadata: toolCall.toolMetadata } : {}
+              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
             });
           }
           break;
@@ -85474,7 +85628,7 @@ async function embed({
         }),
         tracer,
         fn: async (doEmbedSpan) => {
-          var _a21, _b16;
+          var _a21;
           const modelResponse = await model.doEmbed({
             values: [value],
             abortSignal,
@@ -85495,7 +85649,7 @@ async function embed({
           return {
             embedding: embedding2,
             usage: usage2,
-            warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+            warnings: modelResponse.warnings,
             providerMetadata: modelResponse.providerMetadata,
             response: modelResponse.response
           };
@@ -85591,7 +85745,7 @@ async function embedMany({
             }),
             tracer,
             fn: async (doEmbedSpan) => {
-              var _a222, _b16;
+              var _a222;
               const modelResponse = await model.doEmbed({
                 values,
                 abortSignal,
@@ -85612,7 +85766,7 @@ async function embedMany({
               return {
                 embeddings: embeddings3,
                 usage: usage2,
-                warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+                warnings: modelResponse.warnings,
                 providerMetadata: modelResponse.providerMetadata,
                 response: modelResponse.response
               };
@@ -85669,7 +85823,7 @@ async function embedMany({
               }),
               tracer,
               fn: async (doEmbedSpan) => {
-                var _a222, _b16;
+                var _a222;
                 const modelResponse = await model.doEmbed({
                   values: chunk,
                   abortSignal,
@@ -85690,7 +85844,7 @@ async function embedMany({
                 return {
                   embeddings: embeddings2,
                   usage,
-                  warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+                  warnings: modelResponse.warnings,
                   providerMetadata: modelResponse.providerMetadata,
                   response: modelResponse.response
                 };
@@ -87804,7 +87958,7 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
   const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
-}, VERSION3 = "6.0.191", download = async ({
+}, VERSION3 = "6.0.175", download = async ({
   url: url2,
   maxBytes,
   abortSignal
@@ -87894,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 },
@@ -87955,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",
@@ -88312,7 +88466,7 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
     }
     return this._output;
   }
-}, JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, toolMetadataSchema, uiMessageChunkSchema, isToolOrDynamicToolUIPart, getToolOrDynamicToolName, originalGenerateId2, DefaultStreamTextResult = class {
+}, JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, uiMessageChunkSchema, isToolOrDynamicToolUIPart, getToolOrDynamicToolName, originalGenerateId2, DefaultStreamTextResult = class {
   constructor({
     model,
     telemetry,
@@ -89560,7 +89714,6 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
               toolName: part.toolName,
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...dynamic != null ? { dynamic } : {},
               ...part.title != null ? { title: part.title } : {}
             });
@@ -89584,7 +89737,6 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
                 input: part.input,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                 ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
                 ...dynamic != null ? { dynamic } : {},
                 errorText: onError(part.error),
                 ...part.title != null ? { title: part.title } : {}
@@ -89597,7 +89749,6 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
                 input: part.input,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                 ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
                 ...dynamic != null ? { dynamic } : {},
                 ...part.title != null ? { title: part.title } : {}
               });
@@ -89620,7 +89771,6 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
               output: part.output,
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...part.preliminary != null ? { preliminary: part.preliminary } : {},
               ...dynamic != null ? { dynamic } : {}
             });
@@ -89634,7 +89784,6 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
               errorText: part.providerExecuted ? typeof part.error === "string" ? part.error : JSON.stringify(part.error) : onError(part.error),
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...dynamic != null ? { dynamic } : {}
             });
             break;
@@ -89808,21 +89957,10 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
       ...options
     };
     const preparedCallArgs = (_d2 = await ((_c2 = (_b16 = this.settings).prepareCall) == null ? undefined : _c2.call(_b16, baseCallArgs))) != null ? _d2 : baseCallArgs;
-    const {
-      instructions,
-      allowSystemInMessages,
-      messages,
-      prompt,
-      ...callArgs
-    } = preparedCallArgs;
+    const { instructions, messages, prompt, ...callArgs } = preparedCallArgs;
     return {
       ...callArgs,
-      ...{
-        system: instructions,
-        allowSystemInMessages,
-        messages,
-        prompt
-      }
+      ...{ system: instructions, messages, prompt }
     };
   }
   mergeOnStepFinishCallbacks(methodCallback) {
@@ -89863,7 +90001,7 @@ var import_api2, import_api3, __defProp4, __export4 = (target, all) => {
       onStepFinish: this.mergeOnStepFinishCallbacks(onStepFinish)
     });
   }
-}, toolMetadataSchema2, uiMessagesSchema, DefaultEmbedResult = class {
+}, uiMessagesSchema, DefaultEmbedResult = class {
   constructor(options) {
     this.value = options.value;
     this.embedding = options.embedding;
@@ -90868,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)
@@ -90918,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)
@@ -91371,7 +91509,6 @@ var init_dist7 = __esm(() => {
   init_dist6();
   init_dist3();
   init_dist3();
-  init_dist6();
   init_dist5();
   init_dist5();
   init_dist5();
@@ -92231,7 +92368,6 @@ var init_dist7 = __esm(() => {
     "x-vercel-ai-ui-message-stream": "v1",
     "x-accel-buffering": "no"
   };
-  toolMetadataSchema = exports_external2.record(exports_external2.string(), jsonValueSchema.optional());
   uiMessageChunkSchema = lazySchema(() => zodSchema(exports_external2.union([
     exports_external2.strictObject({
       type: exports_external2.literal("text-start"),
@@ -92259,7 +92395,6 @@ var init_dist7 = __esm(() => {
       toolName: exports_external2.string(),
       providerExecuted: exports_external2.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external2.boolean().optional(),
       title: exports_external2.string().optional()
     }),
@@ -92275,7 +92410,6 @@ var init_dist7 = __esm(() => {
       input: exports_external2.unknown(),
       providerExecuted: exports_external2.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external2.boolean().optional(),
       title: exports_external2.string().optional()
     }),
@@ -92286,7 +92420,6 @@ var init_dist7 = __esm(() => {
       input: exports_external2.unknown(),
       providerExecuted: exports_external2.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external2.boolean().optional(),
       errorText: exports_external2.string(),
       title: exports_external2.string().optional()
@@ -92302,7 +92435,6 @@ var init_dist7 = __esm(() => {
       output: exports_external2.unknown(),
       providerExecuted: exports_external2.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external2.boolean().optional(),
       preliminary: exports_external2.boolean().optional()
     }),
@@ -92312,7 +92444,6 @@ var init_dist7 = __esm(() => {
       errorText: exports_external2.string(),
       providerExecuted: exports_external2.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external2.boolean().optional()
     }),
     exports_external2.strictObject({
@@ -92400,7 +92531,6 @@ var init_dist7 = __esm(() => {
     prefix: "aitxt",
     size: 24
   });
-  toolMetadataSchema2 = exports_external2.record(exports_external2.string(), jsonValueSchema.optional());
   uiMessagesSchema = lazySchema(() => zodSchema(exports_external2.array(exports_external2.object({
     id: exports_external2.string(),
     role: exports_external2.enum(["system", "user", "assistant"]),
@@ -92452,7 +92582,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("input-streaming"),
         input: exports_external2.unknown().optional(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92465,7 +92594,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("input-available"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92478,7 +92606,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("approval-requested"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92495,7 +92622,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("approval-responded"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92512,7 +92638,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-available"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92531,9 +92656,8 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-error"),
-        input: exports_external2.unknown().optional(),
+        input: exports_external2.unknown(),
         rawInput: exports_external2.unknown().optional(),
         providerExecuted: exports_external2.boolean().optional(),
         output: exports_external2.never().optional(),
@@ -92550,7 +92674,6 @@ var init_dist7 = __esm(() => {
         type: exports_external2.literal("dynamic-tool"),
         toolName: exports_external2.string(),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-denied"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92566,7 +92689,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("input-streaming"),
         providerExecuted: exports_external2.boolean().optional(),
         callProviderMetadata: providerMetadataSchema.optional(),
@@ -92578,7 +92700,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("input-available"),
         providerExecuted: exports_external2.boolean().optional(),
         input: exports_external2.unknown(),
@@ -92590,7 +92711,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("approval-requested"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92606,7 +92726,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("approval-responded"),
         input: exports_external2.unknown(),
         providerExecuted: exports_external2.boolean().optional(),
@@ -92622,7 +92741,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-available"),
         providerExecuted: exports_external2.boolean().optional(),
         input: exports_external2.unknown(),
@@ -92640,10 +92758,9 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-error"),
         providerExecuted: exports_external2.boolean().optional(),
-        input: exports_external2.unknown().optional(),
+        input: exports_external2.unknown(),
         rawInput: exports_external2.unknown().optional(),
         output: exports_external2.never().optional(),
         errorText: exports_external2.string(),
@@ -92658,7 +92775,6 @@ var init_dist7 = __esm(() => {
       exports_external2.object({
         type: exports_external2.string().startsWith("tool-"),
         toolCallId: exports_external2.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external2.literal("output-denied"),
         providerExecuted: exports_external2.boolean().optional(),
         input: exports_external2.unknown(),
@@ -93163,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 = [];
@@ -93349,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);
@@ -93383,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";
@@ -93827,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",
@@ -93851,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",
@@ -93868,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",
@@ -93924,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();
@@ -95655,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,
@@ -95674,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}`);
@@ -95687,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)) {
@@ -95701,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
@@ -95813,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 });
   }
@@ -95927,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 {
@@ -95943,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;
@@ -95970,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)
@@ -95991,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 };
   }
@@ -96018,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;
@@ -96027,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");
@@ -96038,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, ""));
@@ -96047,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`);
@@ -96074,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 {
@@ -96108,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;
@@ -96126,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 {
@@ -96146,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;
@@ -96166,7 +96272,7 @@ function getInstallCommand(pm) {
       return "bun install";
   }
 }
-function getPlaywrightInstallCommand(pm) {
+function getPlaywrightInstallCommand(_pm) {
   return "npx playwright install";
 }
 function discoverRepo(opts) {
@@ -96181,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;
     }
@@ -96190,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;
@@ -96259,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));
       }
     }
   }
@@ -96283,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"];
   }
@@ -96305,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(" ")}`, {
@@ -96333,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);
@@ -96438,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();
@@ -96480,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 ===
@@ -96590,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({
@@ -96863,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);
@@ -97066,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();
@@ -97076,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") {
@@ -97105,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();
@@ -97115,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") {
@@ -97161,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"]);
@@ -97231,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;
@@ -97280,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,
@@ -97314,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)
@@ -97322,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);
         });
@@ -97415,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) {
@@ -97438,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...`));
@@ -97502,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,
@@ -97524,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) {
@@ -97714,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."));
@@ -97722,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$/, "");
@@ -97777,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 ?? ".";
@@ -97810,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);
@@ -97835,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("");
@@ -97989,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;
@@ -98007,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,
@@ -98073,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) {
@@ -98151,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,
@@ -98217,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."));
@@ -98227,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."));
@@ -98241,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."));
@@ -98330,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));
@@ -98571,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", () => {
@@ -98600,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;
   }
@@ -98636,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`));
@@ -98650,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") {
@@ -98835,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);
@@ -98849,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";
@@ -99659,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 });
@@ -99711,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");
@@ -100127,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,
@@ -100146,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
       }
     });
@@ -100180,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("");
@@ -100392,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();
@@ -100402,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") {
@@ -100563,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}`));
@@ -100653,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): ");
@@ -100816,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) {