intellitester 0.5.2 → 0.5.4

package/dist/{chunk-VWXGXFIM.js → chunk-KRXZC5J5.js}

@@ -1,4 +1,4 @@
-import { loadTestDefinition } from './chunk-PDU3AEXH.js';
+import { loadTestDefinition } from './chunk-VP7KGC7O.js';
 import { track } from './chunk-VZ5S7MN6.js';
 import { loadCleanupHandlers, executeCleanup, saveFailedCleanup } from './chunk-R6R55OTZ.js';
 import { init_esm_shims, __require } from './chunk-RXXJEYXO.js';
@@ -14,10 +14,11 @@ import { chromium, webkit, firefox } from 'playwright';
 import prompts from 'prompts';
 import { Client, Users, TablesDB, Storage, Teams } from 'node-appwrite';
 import os from 'os';
-import { CompletionModel, Workflow, ChatMessage, runAgent } from 'blazen';
+import { CompletionModel, Workflow, runAgent, ChatMessage } from 'blazen';
 import { z } from 'zod';
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, rmSync } from 'fs';
+import { pathToFileURL } from 'url';
 import { createWorker } from 'tesseract.js';
 
 // src/core/randomUsername.ts
@@ -2187,17 +2188,17 @@ var AIEvaluationResponseSchema = z.object({
 });
 var SUBMIT_EVALUATION_TOOL = {
   name: "submit_evaluation",
-  description: "Submit the structured pass/fail evaluation of the screenshot. Always call this exactly once.",
+  description: "Submit the structured pass/fail evaluation of the page. Call this exactly once when you are confident in your verdict \u2014 it is terminal.",
   parameters: {
     type: "object",
     properties: {
       passed: {
         type: "boolean",
-        description: "Whether the screenshot meets the expected criteria."
+        description: "Whether the page meets the expected criteria."
       },
       reason: {
         type: "string",
-        description: "Concise explanation of the decision."
+        description: "Concise explanation of the decision, citing the evidence you observed."
       }
     },
     required: ["passed", "reason"]
@@ -2237,8 +2238,382 @@ Does the screenshot contain all of the expected content or meet the specified co
   const result = await wf.run({});
   return result.data;
 }
+var TAKE_SCREENSHOT_TOOL = {
+  name: "take_screenshot",
+  description: "Capture a fresh screenshot (saved as a test artifact). NOTE: pixels from this call are NOT shown back to you on the next turn \u2014 only the initial screenshot in the user message is visible. For verifying content after scrolling/waiting, use accessibility_snapshot or query_dom (those return real readable data).",
+  parameters: {
+    type: "object",
+    properties: {
+      fullPage: {
+        type: "boolean",
+        description: "Capture full scrollable page (true) or just the current viewport (false). Default: false."
+      },
+      selector: {
+        type: "string",
+        description: "Optional CSS selector. If provided, screenshots just that element."
+      }
+    }
+  }
+};
+var SCROLL_TOOL = {
+  name: "scroll",
+  description: "Scroll the page or a specific element. Use to bring off-screen content into the viewport before re-screenshotting.",
+  parameters: {
+    type: "object",
+    properties: {
+      direction: {
+        type: "string",
+        enum: ["up", "down"],
+        description: "Direction to scroll the page."
+      },
+      pixels: {
+        type: "number",
+        description: "Pixels to scroll (default 800). Used with `direction`."
+      },
+      toBottom: {
+        type: "boolean",
+        description: "Scroll all the way to the bottom of the page."
+      },
+      toTop: {
+        type: "boolean",
+        description: "Scroll all the way to the top of the page."
+      },
+      selector: {
+        type: "string",
+        description: "CSS selector. If provided, scrolls that element into view instead of moving the page."
+      }
+    }
+  }
+};
+var WAIT_TOOL = {
+  name: "wait",
+  description: "Pause briefly to let animations or lazy-loaded UI settle before re-checking. Capped at 3000ms.",
+  parameters: {
+    type: "object",
+    properties: {
+      ms: {
+        type: "number",
+        description: "Milliseconds to wait (1-3000)."
+      }
+    },
+    required: ["ms"]
+  }
+};
+var QUERY_DOM_TOOL = {
+  name: "query_dom",
+  description: "Look up an element by CSS selector and report whether it exists, is visible, its text content, and its attributes. Useful when pixels are ambiguous (e.g., for <video>, <canvas>, or off-screen content).",
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "CSS selector to query."
+      }
+    },
+    required: ["selector"]
+  }
+};
+var ACCESSIBILITY_SNAPSHOT_TOOL = {
+  name: "accessibility_snapshot",
+  description: "Get the ARIA snapshot (YAML accessibility tree) of the page or a sub-tree. The truth-source when pixels are ambiguous \u2014 lists roles, names, and structure as screen readers see them.",
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "Optional CSS selector to scope the snapshot to a sub-tree. Default: full body."
+      }
+    }
+  }
+};
+var AGENT_BUILTIN_TOOLS = [
+  TAKE_SCREENSHOT_TOOL,
+  SCROLL_TOOL,
+  WAIT_TOOL,
+  QUERY_DOM_TOOL,
+  ACCESSIBILITY_SNAPSHOT_TOOL
+];
+var AGENT_BUILTIN_NAMES = new Set(AGENT_BUILTIN_TOOLS.map((t) => t.name));
+var RESERVED_TOOL_NAMES = /* @__PURE__ */ new Set([...AGENT_BUILTIN_NAMES, "submit_evaluation"]);
+function truncate(s, limit) {
+  return s.length <= limit ? s : `${s.slice(0, limit)}
+\u2026[truncated ${s.length - limit} chars]`;
+}
+async function execTakeScreenshot(args, page) {
+  const fullPage = args.fullPage === true;
+  const selector = typeof args.selector === "string" ? args.selector : void 0;
+  try {
+    if (selector) {
+      await page.locator(selector).first().screenshot();
+    } else {
+      await page.screenshot({ fullPage });
+    }
+    const url = page.url();
+    const scope = selector ? `selector="${selector}"` : fullPage ? "fullPage" : "viewport";
+    return {
+      kind: "text",
+      text: `Screenshot captured (${scope}) at ${url}. Note: re-screenshots are not surfaced visually in this loop \u2014 use accessibility_snapshot or query_dom to verify the contents you'd want to inspect.`
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { kind: "text", text: `take_screenshot error: ${msg}` };
+  }
+}
+async function execScroll(args, page) {
+  const selector = typeof args.selector === "string" ? args.selector : void 0;
+  const toBottom = args.toBottom === true;
+  const toTop = args.toTop === true;
+  const direction = args.direction === "up" ? "up" : args.direction === "down" ? "down" : null;
+  const pixels = typeof args.pixels === "number" ? args.pixels : 800;
+  if (selector) {
+    await page.locator(selector).first().scrollIntoViewIfNeeded();
+    return { kind: "text", text: `Scrolled "${selector}" into view.` };
+  }
+  if (toBottom) {
+    await page.evaluate(() => window.scrollTo(0, document.documentElement.scrollHeight));
+    return { kind: "text", text: "Scrolled to bottom of page." };
+  }
+  if (toTop) {
+    await page.evaluate(() => window.scrollTo(0, 0));
+    return { kind: "text", text: "Scrolled to top of page." };
+  }
+  const dy = direction === "up" ? -pixels : pixels;
+  await page.evaluate((y) => window.scrollBy(0, y), dy);
+  const pos = await page.evaluate(() => ({ y: window.scrollY, max: document.documentElement.scrollHeight - window.innerHeight }));
+  return { kind: "text", text: `Scrolled ${dy}px. Now at y=${Math.round(pos.y)} / ${Math.round(pos.max)} (max).` };
+}
+async function execWait(args, page) {
+  const requested = typeof args.ms === "number" && args.ms > 0 ? args.ms : 500;
+  const ms = Math.min(Math.floor(requested), 3e3);
+  await page.waitForTimeout(ms);
+  return { kind: "text", text: `Waited ${ms}ms${requested !== ms ? ` (capped from requested ${requested}ms)` : ""}.` };
+}
+async function execQueryDom(args, page) {
+  const selector = typeof args.selector === "string" ? args.selector : "";
+  if (!selector) return { kind: "text", text: "query_dom error: selector is required." };
+  try {
+    const locator = page.locator(selector);
+    const count = await locator.count();
+    if (count === 0) {
+      return { kind: "text", text: `query_dom: no elements match "${selector}".` };
+    }
+    const first = locator.first();
+    const visible = await first.isVisible().catch(() => false);
+    const text = await first.innerText({ timeout: 1e3 }).catch(() => "");
+    const attributes = await first.evaluate((el) => {
+      const out = {};
+      const target = el;
+      for (const name of target.getAttributeNames()) {
+        out[name] = target.getAttribute(name) ?? "";
+      }
+      return out;
+    }).catch(() => ({}));
+    const payload = {
+      selector,
+      count,
+      visible,
+      text: truncate(text, 2e3),
+      attributes
+    };
+    return { kind: "text", text: JSON.stringify(payload, null, 2) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { kind: "text", text: `query_dom error: ${msg}` };
+  }
+}
+async function execAccessibilitySnapshot(args, page) {
+  const selector = typeof args.selector === "string" && args.selector.trim() ? args.selector : "body";
+  try {
+    const locator = page.locator(selector).first();
+    const count = await locator.count();
+    if (count === 0) {
+      return { kind: "text", text: `accessibility_snapshot: selector "${selector}" did not match any element.` };
+    }
+    const snap = await locator.ariaSnapshot({ timeout: 5e3 });
+    return { kind: "text", text: truncate(snap, 8e3) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { kind: "text", text: `accessibility_snapshot error: ${msg}` };
+  }
+}
+async function dispatchBuiltinTool(name, args, page) {
+  switch (name) {
+    case "take_screenshot":
+      return execTakeScreenshot(args, page);
+    case "scroll":
+      return execScroll(args, page);
+    case "wait":
+      return execWait(args, page);
+    case "query_dom":
+      return execQueryDom(args, page);
+    case "accessibility_snapshot":
+      return execAccessibilitySnapshot(args, page);
+    default:
+      throw new Error(`Unknown built-in tool: ${name}`);
+  }
+}
+async function loadCustomTools(toolsPath, workflowDir) {
+  const resolved = path5__default.isAbsolute(toolsPath) ? toolsPath : path5__default.resolve(workflowDir, toolsPath);
+  const href = pathToFileURL(resolved).href;
+  const mod = await import(href);
+  const candidate = (mod && typeof mod === "object" && "default" in mod ? mod.default : mod) ?? mod;
+  if (!candidate || typeof candidate !== "object" || !Array.isArray(candidate.tools) || typeof candidate.handler !== "function") {
+    throw new Error(
+      `Custom tools module at ${resolved} must export { tools: JsToolDef[], handler: (name, args, ctx) => AgentToolResult }`
+    );
+  }
+  const out = candidate;
+  for (const tool of out.tools) {
+    if (!tool.name || typeof tool.name !== "string") {
+      throw new Error(`Custom tools module at ${resolved}: every tool must have a string \`name\`.`);
+    }
+    if (RESERVED_TOOL_NAMES.has(tool.name)) {
+      throw new Error(
+        `Custom tools module at ${resolved}: tool name "${tool.name}" collides with a reserved built-in tool. Rename it.`
+      );
+    }
+  }
+  return out;
+}
+var SubmitEvaluationSignal = class extends Error {
+  constructor(passed, reason) {
+    super("SubmitEvaluationSignal");
+    this.passed = passed;
+    this.reason = reason;
+    this.name = "SubmitEvaluationSignal";
+  }
+};
+async function runAgentEvaluation(initialScreenshot, expectedArray, customPrompt, aiConfig, page, opts) {
+  const model = buildModel(aiConfig);
+  const completionOptions = buildCompletionOptions(aiConfig);
+  let customTools = [];
+  let customHandler;
+  if (opts.customToolsPath) {
+    const mod = await loadCustomTools(opts.customToolsPath, opts.workflowDir);
+    customTools = mod.tools;
+    customHandler = mod.handler;
+  }
+  const allTools = [
+    ...AGENT_BUILTIN_TOOLS,
+    ...customTools,
+    SUBMIT_EVALUATION_TOOL
+  ];
+  const systemPrompt = `You are auditing a web page to decide whether the user's expected condition holds.
+
+The initial screenshot of the page is attached to the user message \u2014 that is the ONLY image you can see. Re-screenshots are not shown back to you (they are saved as artifacts only). After scrolling/waiting, verify content by reading the DOM, NOT by re-screenshotting.
+
+Tools:
+  - accessibility_snapshot: returns the ARIA tree (YAML) of a region \u2014 the truth source for what is rendered. Use this to confirm structure (lists, regions, roles, accessible names).
+  - query_dom: returns count/visibility/text/attributes for a CSS selector.
+  - scroll: move the page (by pixels, to-bottom/top, or scroll a selector into view).
+  - wait: pause up to 3000ms for animations/lazy loads.
+  - take_screenshot: captures an artifact (you do not see the result image \u2014 informational only).
+  - submit_evaluation: terminal \u2014 call exactly once with { passed, reason } when confident.
+
+Workflow: examine the initial screenshot. If the expected content isn't in view, scroll to where it should live, then use accessibility_snapshot or query_dom to confirm. Be efficient. Call submit_evaluation once you have enough evidence.`;
+  const defaultUserPrompt = `Expected content or conditions:
+${expectedArray.map((exp) => `- ${exp}`).join("\n")}
+
+Investigate the page using the available tools. When confident, call submit_evaluation with your verdict.`;
+  const userPromptText = customPrompt || defaultUserPrompt;
+  const imageBase64 = initialScreenshot.toString("base64");
+  const messages = [
+    ChatMessage.system(systemPrompt),
+    ChatMessage.userImageBase64(userPromptText, imageBase64, "image/png")
+  ];
+  let submission;
+  const toolHandler = async (name, rawArgs) => {
+    const args = rawArgs && typeof rawArgs === "object" ? rawArgs : {};
+    if (name === "submit_evaluation") {
+      const parsed = AIEvaluationResponseSchema.parse(args);
+      submission = parsed;
+      throw new SubmitEvaluationSignal(parsed.passed, parsed.reason);
+    }
+    let result;
+    if (AGENT_BUILTIN_NAMES.has(name)) {
+      result = await dispatchBuiltinTool(name, args, page);
+    } else if (customHandler) {
+      result = await customHandler(name, args, { page });
+    } else {
+      result = { kind: "text", text: `Unknown tool: ${name}` };
+    }
+    return result.text;
+  };
+  let iterations = 0;
+  try {
+    const agentResult = await runAgent(model, messages, allTools, toolHandler, {
+      maxIterations: opts.maxSteps,
+      temperature: completionOptions.temperature ?? void 0,
+      maxTokens: completionOptions.maxTokens ?? void 0,
+      noFinishTool: true
+    });
+    iterations = agentResult.iterations;
+  } catch (e) {
+    if (!submission) {
+      throw e;
+    }
+  }
+  if (!submission) {
+    throw new Error(
+      `Agent exhausted ${opts.maxSteps} iterations without calling submit_evaluation.`
+    );
+  }
+  return {
+    passed: submission.passed,
+    reason: submission.reason,
+    iterations: iterations || opts.maxSteps
+  };
+}
 async function evaluate(options) {
   const expectedArray = Array.isArray(options.expected) ? options.expected : [options.expected];
+  if (options.mode === "agent") {
+    if (!options.aiConfig) {
+      return {
+        passed: false,
+        mode: "agent",
+        reason: "Agent evaluation requested but no AI configuration provided",
+        screenshotPath: options.screenshotPath
+      };
+    }
+    if (!options.page) {
+      return {
+        passed: false,
+        mode: "agent",
+        reason: "Agent evaluation requires a live Page (internal wiring error)",
+        screenshotPath: options.screenshotPath
+      };
+    }
+    try {
+      const agentResult = await runAgentEvaluation(
+        options.screenshotBuffer,
+        expectedArray,
+        options.prompt,
+        options.aiConfig,
+        options.page,
+        {
+          maxSteps: options.maxSteps ?? 6,
+          customToolsPath: options.customToolsPath,
+          workflowDir: options.workflowDir ?? process.cwd()
+        }
+      );
+      return {
+        passed: agentResult.passed,
+        mode: "agent",
+        reason: agentResult.reason,
+        aiReason: agentResult.reason,
+        agentIterations: agentResult.iterations,
+        screenshotPath: options.screenshotPath
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return {
+        passed: false,
+        mode: "agent",
+        reason: `Agent evaluation failed: ${msg}`,
+        screenshotPath: options.screenshotPath
+      };
+    }
+  }
   let ocrFailReason;
   if (options.mode === "ocr" || options.mode === "auto") {
     try {
@@ -2600,7 +2975,7 @@ async function handleInteractiveError(page, action, error, screenshotDir, stepIn
   return response.action || "abort";
 }
 async function executeActionWithRetry(page, action, index, options) {
-  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName, healing, testFilePath } = options;
+  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName, healing, testFilePath, responseLog, stepStartTs } = options;
   const extras = {};
   const buildTrackPayload = (stepExtras) => {
     if (!("track" in action)) return null;
@@ -3053,15 +3428,7 @@ async function executeActionWithRetry(page, action, index, options) {
             if (debugMode) {
               console.log(`[DEBUG] Executing nested step ${nestedIdx + 1}: ${nestedAction.type}`);
             }
-            await executeActionWithRetry(page, nestedAction, index, {
-              baseUrl,
-              context,
-              screenshotDir,
-              debugMode,
-              interactive,
-              aiConfig,
-              browserName
-            });
+            await executeActionWithRetry(page, nestedAction, index, options);
           }
           break;
         }
@@ -3163,18 +3530,10 @@ async function executeActionWithRetry(page, action, index, options) {
               if (debugMode) {
                 console.log(`[DEBUG] Executing branch step ${nestedIdx + 1}: ${nestedAction.type}`);
               }
-              await executeActionWithRetry(page, nestedAction, index, {
-                baseUrl,
-                context,
-                screenshotDir,
-                debugMode,
-                interactive,
-                aiConfig,
-                browserName
-              });
+              await executeActionWithRetry(page, nestedAction, index, options);
             }
           } else {
-            const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-2CW6OEXJ.js');
+            const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-FDWG62M2.js');
             const workflowPath = path5__default.resolve(process.cwd(), branchToExecute.workflow);
             const workflowDir = path5__default.dirname(workflowPath);
             if (debugMode) {
@@ -3200,17 +3559,147 @@ async function executeActionWithRetry(page, action, index, options) {
                 }
               }
               for (const [testStepIdx, testAction] of test.steps.entries()) {
-                await executeActionWithRetry(page, testAction, testStepIdx, {
-                  baseUrl,
-                  context,
-                  screenshotDir,
-                  debugMode,
-                  interactive,
-                  aiConfig,
-                  browserName
-                });
+                await executeActionWithRetry(page, testAction, testStepIdx, options);
+              }
+            }
+          }
+          break;
+        }
+        case "saveStorageState": {
+          const saveAction = action;
+          if (saveAction.path) {
+            const resolvedPath = interpolateVariables(saveAction.path, context.variables);
+            const baseDir = testFilePath ? path5__default.dirname(testFilePath) : process.cwd();
+            const absPath = path5__default.isAbsolute(resolvedPath) ? resolvedPath : path5__default.resolve(baseDir, resolvedPath);
+            await page.context().storageState({ path: absPath });
+            if (debugMode) {
+              console.log(`[DEBUG] Saved storage state to ${absPath}`);
+            }
+          } else if (saveAction.handler) {
+            const resolvedHandler = interpolateVariables(saveAction.handler, context.variables);
+            const baseDir = testFilePath ? path5__default.dirname(testFilePath) : process.cwd();
+            const absPath = path5__default.isAbsolute(resolvedHandler) ? resolvedHandler : path5__default.resolve(baseDir, resolvedHandler);
+            let loadPath = absPath;
+            if (absPath.endsWith(".ts")) {
+              const jsPath = absPath.replace(/\.ts$/, ".js");
+              try {
+                await fs3__default.access(jsPath);
+                loadPath = jsPath;
+              } catch {
+              }
+            }
+            const mod = await import(`${loadPath}?t=${Date.now()}`);
+            const fn = mod.default ?? mod;
+            if (typeof fn !== "function") {
+              throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
+            }
+            await fn({
+              page,
+              context: page.context(),
+              variables: context.variables
+            });
+            if (debugMode) {
+              console.log(`[DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
+            }
+          } else {
+            throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
+          }
+          break;
+        }
+        case "assertCookies": {
+          const cookieAction = action;
+          const filterUrl = cookieAction.url ? interpolateVariables(cookieAction.url, context.variables) : void 0;
+          const jar = await page.context().cookies(filterUrl);
+          const names = new Set(jar.map((c) => c.name));
+          const problems = [];
+          if (cookieAction.has) {
+            for (const name of cookieAction.has) {
+              if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
+            }
+          }
+          if (cookieAction.not) {
+            for (const name of cookieAction.not) {
+              if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
+            }
+          }
+          if (cookieAction.match) {
+            for (const [name, pattern] of Object.entries(cookieAction.match)) {
+              const c = jar.find((entry) => entry.name === name);
+              if (!c) {
+                problems.push(`expected cookie "${name}" to be present (for value match)`);
+                continue;
+              }
+              const matcher = compileMatcher(interpolateVariables(pattern, context.variables), "substr");
+              if (!matcher(c.value)) {
+                problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
+              }
+            }
+          }
+          if (problems.length > 0) {
+            throw new Error(`assertCookies failed:
+  - ${problems.join("\n  - ")}
+  (cookies seen: ${[...names].join(", ") || "<none>"})`);
+          }
+          break;
+        }
+        case "expectResponse": {
+          if (!responseLog) {
+            throw new Error("expectResponse requires a responseLog to be attached (executor wiring issue)");
+          }
+          const respAction = action;
+          const urlPattern = interpolateVariables(respAction.url, context.variables);
+          const urlMatch = compileMatcher(urlPattern, "url");
+          const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
+            name: name.toLowerCase(),
+            test: compileMatcher(interpolateVariables(pattern, context.variables), "substr"),
+            pattern
+          })) : [];
+          const expectedStatus = respAction.status;
+          let sinceTs;
+          if (respAction.since === "testStart") {
+            sinceTs = 0;
+          } else if (typeof respAction.since === "number") {
+            sinceTs = respAction.since;
+          } else {
+            sinceTs = stepStartTs ?? 0;
+          }
+          const timeout = respAction.timeout ?? 5e3;
+          const deadline = Date.now() + timeout;
+          const findMatch = () => {
+            for (const entry of responseLog.snapshot()) {
+              if (entry.ts < sinceTs) continue;
+              if (!urlMatch(entry.url)) continue;
+              if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
+              let headersOk = true;
+              for (const h of headerMatchers) {
+                const value = entry.headers[h.name];
+                if (value === void 0 || !h.test(value)) {
+                  headersOk = false;
+                  break;
+                }
               }
+              if (headersOk) return entry;
             }
+            return null;
+          };
+          let match = findMatch();
+          while (!match && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            match = findMatch();
+          }
+          if (!match) {
+            const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
+            throw new Error(
+              `expectResponse timed out after ${timeout}ms.
+  url pattern: ${urlPattern}
+` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
+` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
+` : "") + `  recent responses:
+  ${recent || "<none>"}`
+            );
+          }
+          if (debugMode) {
+            console.log(`[DEBUG] expectResponse matched: ${match.status} ${match.url}`);
           }
           break;
         }
@@ -3670,6 +4159,7 @@ var runWebTest = async (test, options = {}) => {
             });
             const expectedRaw = evalAction.expected;
             const expectedArray = Array.isArray(expectedRaw) ? expectedRaw.map((e) => interpolateVariables(e, executionContext.variables)) : [interpolateVariables(expectedRaw, executionContext.variables)];
+            const workflowDir = options.testFilePath ? path5__default.dirname(options.testFilePath) : process.cwd();
             const evalResult = await evaluate({
               expected: expectedArray,
               mode: evalAction.mode ?? "auto",
@@ -3678,7 +4168,11 @@ var runWebTest = async (test, options = {}) => {
               confidence: evalAction.confidence ?? 60,
               screenshotBuffer,
               screenshotPath: evalScreenshotPath,
-              aiConfig: options.aiConfig
+              aiConfig: options.aiConfig,
+              page,
+              maxSteps: evalAction.maxSteps,
+              customToolsPath: evalAction.tools,
+              workflowDir
             });
             if (debugMode) {
               console.log(`[DEBUG] Evaluate result: ${evalResult.passed ? "PASSED" : "FAILED"} (${evalResult.mode})`);
@@ -3699,172 +4193,7 @@ var runWebTest = async (test, options = {}) => {
             safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
             continue;
           }
-          if (action.type === "saveStorageState") {
-            const saveAction = action;
-            try {
-              if (saveAction.path) {
-                const resolvedPath = interpolateVariables(saveAction.path, executionContext.variables);
-                const baseDir = options.testFilePath ? path5__default.dirname(options.testFilePath) : process.cwd();
-                const absPath = path5__default.isAbsolute(resolvedPath) ? resolvedPath : path5__default.resolve(baseDir, resolvedPath);
-                await page.context().storageState({ path: absPath });
-                if (debugMode) {
-                  console.log(`[DEBUG] Saved storage state to ${absPath}`);
-                }
-              } else if (saveAction.handler) {
-                const resolvedHandler = interpolateVariables(saveAction.handler, executionContext.variables);
-                const baseDir = options.testFilePath ? path5__default.dirname(options.testFilePath) : process.cwd();
-                const absPath = path5__default.isAbsolute(resolvedHandler) ? resolvedHandler : path5__default.resolve(baseDir, resolvedHandler);
-                let loadPath = absPath;
-                if (absPath.endsWith(".ts")) {
-                  const jsPath = absPath.replace(/\.ts$/, ".js");
-                  try {
-                    await fs3__default.access(jsPath);
-                    loadPath = jsPath;
-                  } catch {
-                  }
-                }
-                const mod = await import(`${loadPath}?t=${Date.now()}`);
-                const fn = mod.default ?? mod;
-                if (typeof fn !== "function") {
-                  throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
-                }
-                await fn({
-                  page,
-                  context: page.context(),
-                  variables: executionContext.variables
-                });
-                if (debugMode) {
-                  console.log(`[DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
-                }
-              } else {
-                throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              const trackedPayload = buildTrackPayload(action, index);
-              if (trackedPayload) {
-                await track(trackedPayload);
-              }
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
-          if (action.type === "assertCookies") {
-            const cookieAction = action;
-            try {
-              const filterUrl = cookieAction.url ? interpolateVariables(cookieAction.url, executionContext.variables) : void 0;
-              const jar = await page.context().cookies(filterUrl);
-              const names = new Set(jar.map((c) => c.name));
-              const problems = [];
-              if (cookieAction.has) {
-                for (const name of cookieAction.has) {
-                  if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
-                }
-              }
-              if (cookieAction.not) {
-                for (const name of cookieAction.not) {
-                  if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
-                }
-              }
-              if (cookieAction.match) {
-                for (const [name, pattern] of Object.entries(cookieAction.match)) {
-                  const c = jar.find((entry) => entry.name === name);
-                  if (!c) {
-                    problems.push(`expected cookie "${name}" to be present (for value match)`);
-                    continue;
-                  }
-                  const matcher = compileMatcher(interpolateVariables(pattern, executionContext.variables), "substr");
-                  if (!matcher(c.value)) {
-                    problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
-                  }
-                }
-              }
-              if (problems.length > 0) {
-                throw new Error(`assertCookies failed:
-  - ${problems.join("\n  - ")}
-  (cookies seen: ${[...names].join(", ") || "<none>"})`);
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
-          if (action.type === "expectResponse") {
-            const respAction = action;
-            try {
-              const urlPattern = interpolateVariables(respAction.url, executionContext.variables);
-              const urlMatch = compileMatcher(urlPattern, "url");
-              const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
-                name: name.toLowerCase(),
-                test: compileMatcher(interpolateVariables(pattern, executionContext.variables), "substr"),
-                pattern
-              })) : [];
-              const expectedStatus = respAction.status;
-              let sinceTs;
-              if (respAction.since === "testStart") {
-                sinceTs = 0;
-              } else if (typeof respAction.since === "number") {
-                sinceTs = respAction.since;
-              } else {
-                sinceTs = lastStepEndTs;
-              }
-              const timeout = respAction.timeout ?? 5e3;
-              const deadline = Date.now() + timeout;
-              const findMatch = () => {
-                for (const entry of responseLog.snapshot()) {
-                  if (entry.ts < sinceTs) continue;
-                  if (!urlMatch(entry.url)) continue;
-                  if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
-                  let headersOk = true;
-                  for (const h of headerMatchers) {
-                    const value = entry.headers[h.name];
-                    if (value === void 0 || !h.test(value)) {
-                      headersOk = false;
-                      break;
-                    }
-                  }
-                  if (headersOk) return entry;
-                }
-                return null;
-              };
-              let match = findMatch();
-              while (!match && Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                match = findMatch();
-              }
-              if (!match) {
-                const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
-                throw new Error(
-                  `expectResponse timed out after ${timeout}ms.
-  url pattern: ${urlPattern}
-` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
-` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
-` : "") + `  recent responses:
-  ${recent || "<none>"}`
-                );
-              }
-              if (debugMode) {
-                console.log(`[DEBUG] expectResponse matched: ${match.status} ${match.url}`);
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
+          const stepStartTs = lastStepEndTs;
           const actionExtras = await executeActionWithRetry(page, action, index, {
             baseUrl: options.baseUrl ?? test.config?.web?.baseUrl,
             context: executionContext,
@@ -3874,7 +4203,9 @@ var runWebTest = async (test, options = {}) => {
             aiConfig: options.aiConfig,
             browserName,
             healing: options.healing,
-            testFilePath: options.testFilePath
+            testFilePath: options.testFilePath,
+            responseLog,
+            stepStartTs
           });
           sizeResults.push({ action, status: "passed", logOutput: actionExtras.logOutput });
           safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
@@ -3952,23 +4283,6 @@ var runWebTest = async (test, options = {}) => {
 // src/executors/web/workflowExecutor.ts
 init_esm_shims();
 var defaultScreenshotDir2 = path5__default.join(process.cwd(), "artifacts", "screenshots");
-var interpolateTrackMetadata2 = (value, variables) => {
-  if (typeof value === "string") {
-    return interpolateVariables(value, variables);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => interpolateTrackMetadata2(entry, variables));
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        key,
-        interpolateTrackMetadata2(entry, variables)
-      ])
-    );
-  }
-  return value;
-};
 var getBrowser2 = (browser) => {
   switch (browser) {
     case "firefox":
@@ -3980,772 +4294,45 @@ var getBrowser2 = (browser) => {
   }
 };
 function interpolateWorkflowVariables(value, currentVariables, testResults) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (match, path6) => {
-    if (path6.includes(".") && !path6.includes(":")) {
-      const [testId, _varName] = path6.split(".", 2);
+  return value.replace(/\{\{([^}]+)\}\}/g, (match, path7) => {
+    if (path7.includes(".") && !path7.includes(":")) {
+      const [testId, _varName] = path7.split(".", 2);
       testResults.find((t) => t.id === testId);
-      console.warn(`Cross-test variable interpolation {{${path6}}} not yet fully implemented`);
+      console.warn(`Cross-test variable interpolation {{${path7}}} not yet fully implemented`);
       return match;
     }
-    const result = interpolateVariables(`{{${path6}}}`, currentVariables);
+    const result = interpolateVariables(`{{${path7}}}`, currentVariables);
     return result;
   });
 }
-async function runTestInWorkflow(test, page, context, options, workflowDir, testFilePath, workflowBaseUrl) {
+async function runTestInWorkflow(test, page, context, options, _workflowDir, testFilePath, workflowBaseUrl) {
   const results = [];
   const debugMode = options.debug ?? false;
   const screenshotDir = defaultScreenshotDir2;
-  const resolveUrl2 = (value, baseUrl) => {
-    if (!baseUrl) return value;
-    try {
-      const url = new URL(value, baseUrl);
-      return url.toString();
-    } catch {
-      return value;
-    }
-  };
-  const interpolate = (value) => {
-    return interpolateVariables(value, context.variables);
-  };
+  const browserName = options.browser ?? "chromium";
+  const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
   const responseLog = new ResponseLog();
   responseLog.attach(page);
-  let lastStepEndTs = Date.now();
-  const resolveLocator2 = (locator) => {
-    if (locator.testId) return page.getByTestId(locator.testId);
-    if (locator.text) return page.getByText(locator.text);
-    if (locator.css) return page.locator(locator.css);
-    if (locator.xpath) return page.locator(`xpath=${locator.xpath}`);
-    if (locator.role) {
-      const options2 = {};
-      if (locator.name) options2.name = locator.name;
-      return page.getByRole(locator.role, options2);
-    }
-    if (locator.description) return page.getByText(locator.description);
-    throw new Error("No usable selector found for locator");
-  };
-  const buildTrackPayload = (action, index, stepExtras) => {
-    if (!("track" in action)) return null;
-    const rawTrack = action.track;
-    if (!rawTrack || typeof rawTrack !== "object") return null;
-    const track2 = interpolateTrackMetadata2(rawTrack, context.variables);
-    if (typeof track2.type !== "string" || typeof track2.id !== "string") return null;
-    const { includeStepContext, ...rest } = track2;
-    const payload = {
-      type: track2.type,
-      id: track2.id,
-      ...rest
-    };
-    if (includeStepContext) {
-      payload.step = { index, ...action, ...stepExtras };
-    }
-    return payload;
-  };
   try {
     for (const [index, action] of test.steps.entries()) {
-      lastStepEndTs = Date.now();
+      const stepStartTs = Date.now();
       if (debugMode) {
         console.log(`  [DEBUG] Step ${index + 1}: ${action.type}`);
       }
       try {
-        switch (action.type) {
-          case "navigate": {
-            const interpolated = interpolate(action.value);
-            const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
-            const target = resolveUrl2(interpolated, baseUrl);
-            if (debugMode) {
-              console.log(`  [DEBUG] Navigate step:`);
-              console.log(`  [DEBUG]   - action.value: ${action.value}`);
-              console.log(`  [DEBUG]   - interpolated: ${interpolated}`);
-              console.log(`  [DEBUG]   - test.config?.web?.baseUrl: ${test.config?.web?.baseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - workflowBaseUrl: ${workflowBaseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - effective baseUrl: ${baseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - target: ${target}`);
-            }
-            await page.goto(target);
-            break;
-          }
-          case "tap": {
-            if (debugMode) console.log(`  [DEBUG] Tapping element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.click();
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 1e4 }).catch(() => {
-            });
-            break;
-          }
-          case "input": {
-            const interpolated = interpolate(action.value);
-            if (debugMode) console.log(`  [DEBUG] Input: ${interpolated}`);
-            const handle = resolveLocator2(action.target);
-            await handle.fill(interpolated);
-            break;
-          }
-          case "clear": {
-            if (debugMode) console.log(`  [DEBUG] Clearing element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.clear();
-            break;
-          }
-          case "hover": {
-            if (debugMode) console.log(`  [DEBUG] Hovering element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.hover();
-            break;
-          }
-          case "select": {
-            const interpolated = interpolate(action.value);
-            if (debugMode) console.log(`  [DEBUG] Selecting: ${interpolated}`);
-            const handle = resolveLocator2(action.target);
-            await handle.selectOption(interpolated);
-            break;
-          }
-          case "check": {
-            if (debugMode) console.log(`  [DEBUG] Checking:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.check();
-            break;
-          }
-          case "uncheck": {
-            if (debugMode) console.log(`  [DEBUG] Unchecking:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.uncheck();
-            break;
-          }
-          case "press": {
-            if (debugMode) console.log(`  [DEBUG] Pressing key: ${action.key}`);
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.press(action.key);
-            } else {
-              await page.keyboard.press(action.key);
-            }
-            break;
-          }
-          case "focus": {
-            if (debugMode) console.log(`  [DEBUG] Focusing:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.focus();
-            break;
-          }
-          case "assert": {
-            if (debugMode) console.log(`  [DEBUG] Assert:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.waitFor({ state: "visible" });
-            if (action.value) {
-              const interpolated = interpolate(action.value);
-              const text = (await handle.textContent())?.trim() ?? "";
-              if (!text.includes(interpolated)) {
-                throw new Error(
-                  `Assertion failed: expected "${interpolated}", got "${text}"`
-                );
-              }
-            }
-            break;
-          }
-          case "wait": {
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.waitFor({ state: "visible", timeout: action.timeout });
-            } else {
-              await page.waitForTimeout(action.timeout ?? 1e3);
-            }
-            break;
-          }
-          case "scroll": {
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.scrollIntoViewIfNeeded();
-            } else {
-              const amount = action.amount ?? 500;
-              const direction = action.direction ?? "down";
-              const deltaY = direction === "up" ? -amount : amount;
-              await page.evaluate((value) => window.scrollBy(0, value), deltaY);
-            }
-            break;
-          }
-          case "screenshot": {
-            const ssAction = action;
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-            });
-            const waitBefore = ssAction.waitBefore ?? 500;
-            if (waitBefore > 0) {
-              await page.waitForTimeout(waitBefore);
-            }
-            const filename = ssAction.name ?? `step-${index + 1}.png`;
-            const filePath = path5__default.join(screenshotDir, filename);
-            await page.screenshot({ path: filePath, fullPage: true });
-            results.push({ action, status: "passed", screenshotPath: filePath });
-            const trackedPayload2 = buildTrackPayload(action, index, { screenshotPath: filePath });
-            if (trackedPayload2) {
-              await track(trackedPayload2);
-            }
-            continue;
-          }
-          case "saveStorageState": {
-            const saveAction = action;
-            if (saveAction.path) {
-              const resolvedPath = interpolate(saveAction.path);
-              const baseDir = path5__default.dirname(testFilePath);
-              const absPath = path5__default.isAbsolute(resolvedPath) ? resolvedPath : path5__default.resolve(baseDir, resolvedPath);
-              await page.context().storageState({ path: absPath });
-              if (debugMode) {
-                console.log(`  [DEBUG] Saved storage state to ${absPath}`);
-              }
-            } else if (saveAction.handler) {
-              const resolvedHandler = interpolate(saveAction.handler);
-              const baseDir = path5__default.dirname(testFilePath);
-              const absPath = path5__default.isAbsolute(resolvedHandler) ? resolvedHandler : path5__default.resolve(baseDir, resolvedHandler);
-              let loadPath = absPath;
-              if (absPath.endsWith(".ts")) {
-                const jsPath = absPath.replace(/\.ts$/, ".js");
-                try {
-                  await fs3__default.access(jsPath);
-                  loadPath = jsPath;
-                } catch {
-                }
-              }
-              const mod = await import(`${loadPath}?t=${Date.now()}`);
-              const fn = mod.default ?? mod;
-              if (typeof fn !== "function") {
-                throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
-              }
-              await fn({
-                page,
-                context: page.context(),
-                variables: context.variables
-              });
-              if (debugMode) {
-                console.log(`  [DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
-              }
-            } else {
-              throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
-            }
-            results.push({ action, status: "passed" });
-            const trackedPayload2 = buildTrackPayload(action, index);
-            if (trackedPayload2) {
-              await track(trackedPayload2);
-            }
-            break;
-          }
-          case "assertCookies": {
-            const cookieAction = action;
-            const filterUrl = cookieAction.url ? interpolate(cookieAction.url) : void 0;
-            const jar = await page.context().cookies(filterUrl);
-            const names = new Set(jar.map((c) => c.name));
-            const problems = [];
-            if (cookieAction.has) {
-              for (const name of cookieAction.has) {
-                if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
-              }
-            }
-            if (cookieAction.not) {
-              for (const name of cookieAction.not) {
-                if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
-              }
-            }
-            if (cookieAction.match) {
-              for (const [name, pattern] of Object.entries(cookieAction.match)) {
-                const c = jar.find((entry) => entry.name === name);
-                if (!c) {
-                  problems.push(`expected cookie "${name}" to be present (for value match)`);
-                  continue;
-                }
-                const matcher = compileMatcher(interpolate(pattern), "substr");
-                if (!matcher(c.value)) {
-                  problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
-                }
-              }
-            }
-            if (problems.length > 0) {
-              throw new Error(`assertCookies failed:
-  - ${problems.join("\n  - ")}
-  (cookies seen: ${[...names].join(", ") || "<none>"})`);
-            }
-            results.push({ action, status: "passed" });
-            break;
-          }
-          case "expectResponse": {
-            const respAction = action;
-            const urlPattern = interpolate(respAction.url);
-            const urlMatch = compileMatcher(urlPattern, "url");
-            const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
-              name: name.toLowerCase(),
-              test: compileMatcher(interpolate(pattern), "substr"),
-              pattern
-            })) : [];
-            const expectedStatus = respAction.status;
-            let sinceTs;
-            if (respAction.since === "testStart") {
-              sinceTs = 0;
-            } else if (typeof respAction.since === "number") {
-              sinceTs = respAction.since;
-            } else {
-              sinceTs = lastStepEndTs;
-            }
-            const timeout = respAction.timeout ?? 5e3;
-            const deadline = Date.now() + timeout;
-            const findMatch = () => {
-              for (const entry of responseLog.snapshot()) {
-                if (entry.ts < sinceTs) continue;
-                if (!urlMatch(entry.url)) continue;
-                if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
-                let headersOk = true;
-                for (const h of headerMatchers) {
-                  const value = entry.headers[h.name];
-                  if (value === void 0 || !h.test(value)) {
-                    headersOk = false;
-                    break;
-                  }
-                }
-                if (headersOk) return entry;
-              }
-              return null;
-            };
-            let match = findMatch();
-            while (!match && Date.now() < deadline) {
-              await new Promise((resolve) => setTimeout(resolve, 50));
-              match = findMatch();
-            }
-            if (!match) {
-              const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
-              throw new Error(
-                `expectResponse timed out after ${timeout}ms.
-  url pattern: ${urlPattern}
-` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
-` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
-` : "") + `  recent responses:
-  ${recent || "<none>"}`
-              );
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] expectResponse matched: ${match.status} ${match.url}`);
-            }
-            results.push({ action, status: "passed" });
-            break;
-          }
-          case "setVar": {
-            let value;
-            if (action.value) {
-              value = interpolate(action.value);
-            } else if (action.from === "response") {
-              throw new Error("setVar from response not yet implemented");
-            } else if (action.from === "element") {
-              throw new Error("setVar from element not yet implemented");
-            } else if (action.from === "email") {
-              throw new Error("Use email.extractCode or email.extractLink instead");
-            } else {
-              throw new Error("setVar requires value or from");
-            }
-            context.variables.set(action.name, value);
-            if (debugMode) console.log(`  [DEBUG] Set variable ${action.name} = ${value}`);
-            break;
-          }
-          case "email.waitFor": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            const mailbox = interpolate(action.mailbox);
-            context.lastEmail = await context.emailClient.waitForEmail(mailbox, {
-              timeout: action.timeout,
-              subjectContains: action.subjectContains
-            });
-            break;
-          }
-          case "email.extractCode": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            if (!context.lastEmail) {
-              throw new Error("No email loaded - call email.waitFor first");
-            }
-            const code = context.emailClient.extractCode(
-              context.lastEmail,
-              action.pattern ? new RegExp(action.pattern) : void 0
-            );
-            if (!code) {
-              throw new Error("No code found in email");
-            }
-            context.variables.set(action.saveTo, code);
-            break;
-          }
-          case "email.extractLink": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            if (!context.lastEmail) {
-              throw new Error("No email loaded - call email.waitFor first");
-            }
-            const link = context.emailClient.extractLink(
-              context.lastEmail,
-              action.pattern ? new RegExp(action.pattern) : void 0
-            );
-            if (!link) {
-              throw new Error("No link found in email");
-            }
-            context.variables.set(action.saveTo, link);
-            break;
-          }
-          case "email.clear": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            const mailbox = interpolate(action.mailbox);
-            await context.emailClient.clearMailbox(mailbox);
-            break;
-          }
-          case "appwrite.verifyEmail": {
-            if (!context.appwriteContext.userId) {
-              throw new Error("No user tracked. appwrite.verifyEmail requires a user signup first.");
-            }
-            if (!context.appwriteConfig?.apiKey) {
-              throw new Error("appwrite.verifyEmail requires appwrite.apiKey in config");
-            }
-            const { Client: Client2, Users: Users2 } = await import('node-appwrite');
-            const client = new Client2().setEndpoint(context.appwriteConfig.endpoint).setProject(context.appwriteConfig.projectId).setKey(context.appwriteConfig.apiKey);
-            const users = new Users2(client);
-            await users.updateEmailVerification(context.appwriteContext.userId, true);
-            if (debugMode) console.log(`  [DEBUG] Verified email for user ${context.appwriteContext.userId}`);
-            break;
-          }
-          case "debug": {
-            console.log("  [DEBUG] Pausing execution - Playwright Inspector will open");
-            await page.pause();
-            break;
-          }
-          case "waitForSelector": {
-            const handle = resolveLocator2(action.target);
-            const timeout = action.timeout ?? 3e4;
-            if (debugMode) {
-              console.log(`  [DEBUG] Waiting for element to be ${action.state}:`, action.target);
-            }
-            const waitForCondition2 = async (checkFn, timeoutMs, errorMessage) => {
-              const start = Date.now();
-              while (Date.now() - start < timeoutMs) {
-                if (await checkFn()) return;
-                await new Promise((r) => setTimeout(r, 100));
-              }
-              throw new Error(errorMessage);
-            };
-            switch (action.state) {
-              case "visible":
-              case "hidden":
-              case "attached":
-              case "detached":
-                await handle.waitFor({ state: action.state, timeout });
-                break;
-              case "enabled":
-                await waitForCondition2(
-                  () => handle.isEnabled(),
-                  timeout,
-                  `Element did not become enabled within ${timeout}ms`
-                );
-                break;
-              case "disabled":
-                await waitForCondition2(
-                  () => handle.isDisabled(),
-                  timeout,
-                  `Element did not become disabled within ${timeout}ms`
-                );
-                break;
-            }
-            break;
-          }
-          case "conditional": {
-            const handle = resolveLocator2(action.condition.target);
-            let conditionMet = false;
-            if (debugMode) {
-              console.log(`  [DEBUG] Checking condition ${action.condition.type}:`, action.condition.target);
-            }
-            try {
-              switch (action.condition.type) {
-                case "exists":
-                  await handle.waitFor({ state: "attached", timeout: 500 });
-                  conditionMet = true;
-                  break;
-                case "notExists":
-                  try {
-                    await handle.waitFor({ state: "detached", timeout: 500 });
-                    conditionMet = true;
-                  } catch {
-                    conditionMet = false;
-                  }
-                  break;
-                case "visible":
-                  conditionMet = await handle.isVisible();
-                  break;
-                case "hidden":
-                  conditionMet = !await handle.isVisible();
-                  break;
-              }
-            } catch {
-              conditionMet = action.condition.type === "notExists";
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] Condition result: ${conditionMet}`);
-            }
-            const stepsToRun = conditionMet ? action.then : action.else ?? [];
-            for (const nestedAction of stepsToRun) {
-              switch (nestedAction.type) {
-                case "screenshot": {
-                  await page.waitForLoadState("domcontentloaded").catch(() => {
-                  });
-                  await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-                  });
-                  const filename = nestedAction.name ?? `conditional-step.png`;
-                  const filePath = path5__default.join(screenshotDir, filename);
-                  await page.screenshot({ path: filePath, fullPage: true });
-                  results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
-                  const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
-                  if (trackedPayload2) {
-                    await track(trackedPayload2);
-                  }
-                  break;
-                }
-                case "evaluate":
-                  throw new Error("Evaluate action in nested context (conditional/waitForBranch) is not yet supported");
-                case "fail": {
-                  throw new Error(nestedAction.message);
-                }
-                default:
-                  throw new Error(`Nested action type ${nestedAction.type} in conditional not yet supported`);
-              }
-            }
-            break;
-          }
-          case "evaluate": {
-            const evalAction = action;
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-            });
-            const waitBefore = evalAction.waitBefore ?? 500;
-            if (waitBefore > 0) {
-              await page.waitForTimeout(waitBefore);
-            }
-            const evalScreenshotPath = path5__default.join(screenshotDir, `evaluate-step-${index + 1}.png`);
-            const screenshotBuffer = await page.screenshot({
-              path: evalScreenshotPath,
-              fullPage: evalAction.fullPage ?? true
-            });
-            const expectedRaw = evalAction.expected;
-            const expectedArray = Array.isArray(expectedRaw) ? expectedRaw.map((e) => interpolate(e)) : [interpolate(expectedRaw)];
-            const evalResult = await evaluate({
-              expected: expectedArray,
-              mode: evalAction.mode ?? "auto",
-              regex: evalAction.regex ?? false,
-              prompt: evalAction.prompt,
-              confidence: evalAction.confidence ?? 60,
-              screenshotBuffer,
-              screenshotPath: evalScreenshotPath,
-              aiConfig: options.aiConfig
-            });
-            if (debugMode) {
-              console.log(`  [DEBUG] Evaluate result: ${evalResult.passed ? "PASSED" : "FAILED"} (${evalResult.mode})`);
-              console.log(`  [DEBUG] Reason: ${evalResult.reason}`);
-            }
-            if (!evalResult.passed) {
-              throw new Error(`Evaluate failed (${evalResult.mode} mode): ${evalResult.reason}`);
-            }
-            results.push({
-              action,
-              status: "passed",
-              screenshotPath: evalScreenshotPath,
-              logOutput: `Evaluate passed (${evalResult.mode}): ${evalResult.reason}`
-            });
-            continue;
-          }
-          case "fail": {
-            throw new Error(action.message);
-          }
-          case "waitForBranch": {
-            const wfbAction = action;
-            const handle = resolveLocator2(wfbAction.target);
-            const timeout = wfbAction.timeout ?? 3e4;
-            const state = wfbAction.state ?? "visible";
-            const pollInterval = wfbAction.pollInterval ?? 100;
-            if (debugMode) {
-              console.log(`  [DEBUG] waitForBranch: waiting for element to be ${state}:`, wfbAction.target);
-            }
-            const startTime = Date.now();
-            let elementAppeared = false;
-            while (Date.now() - startTime < timeout) {
-              try {
-                let conditionMet = false;
-                switch (state) {
-                  case "visible":
-                    conditionMet = await handle.isVisible();
-                    break;
-                  case "attached":
-                    conditionMet = await handle.count() > 0;
-                    break;
-                  case "enabled":
-                    conditionMet = await handle.isEnabled().catch(() => false);
-                    break;
-                }
-                if (conditionMet) {
-                  elementAppeared = true;
-                  break;
-                }
-              } catch {
-              }
-              await new Promise((r) => setTimeout(r, pollInterval));
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] waitForBranch: element ${elementAppeared ? "appeared" : "timed out"}`);
-            }
-            const branch = elementAppeared ? wfbAction.onAppear : wfbAction.onTimeout;
-            if (branch) {
-              if (Array.isArray(branch)) {
-                for (const nestedAction of branch) {
-                  if (debugMode) {
-                    console.log(`  [DEBUG] waitForBranch: executing nested action ${nestedAction.type}`);
-                  }
-                  switch (nestedAction.type) {
-                    case "navigate": {
-                      const interpolated = interpolate(nestedAction.value);
-                      const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
-                      const target = resolveUrl2(interpolated, baseUrl);
-                      await page.goto(target);
-                      break;
-                    }
-                    case "tap": {
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.click();
-                      await page.waitForLoadState("domcontentloaded").catch(() => {
-                      });
-                      await page.waitForLoadState("networkidle", { timeout: 1e4 }).catch(() => {
-                      });
-                      break;
-                    }
-                    case "input": {
-                      const interpolated = interpolate(nestedAction.value);
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.fill(interpolated);
-                      break;
-                    }
-                    case "screenshot": {
-                      await page.waitForLoadState("domcontentloaded").catch(() => {
-                      });
-                      await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-                      });
-                      const nestedSsAction = nestedAction;
-                      const nestedWaitBefore = nestedSsAction.waitBefore ?? 500;
-                      if (nestedWaitBefore > 0) {
-                        await page.waitForTimeout(nestedWaitBefore);
-                      }
-                      const filename = nestedSsAction.name ?? `waitForBranch-step.png`;
-                      const filePath = path5__default.join(screenshotDir, filename);
-                      await page.screenshot({ path: filePath, fullPage: true });
-                      results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
-                      const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
-                      if (trackedPayload2) {
-                        await track(trackedPayload2);
-                      }
-                      break;
-                    }
-                    case "wait": {
-                      if (nestedAction.target) {
-                        const nestedHandle = resolveLocator2(nestedAction.target);
-                        await nestedHandle.waitFor({ state: "visible", timeout: nestedAction.timeout });
-                      } else {
-                        await page.waitForTimeout(nestedAction.timeout ?? 1e3);
-                      }
-                      break;
-                    }
-                    case "evaluate":
-                      throw new Error("Evaluate action in nested context (conditional/waitForBranch) is not yet supported");
-                    case "fail": {
-                      throw new Error(nestedAction.message);
-                    }
-                    case "setVar": {
-                      let value;
-                      if (nestedAction.value) {
-                        value = interpolate(nestedAction.value);
-                      } else {
-                        throw new Error("setVar in waitForBranch requires value");
-                      }
-                      context.variables.set(nestedAction.name, value);
-                      if (debugMode) console.log(`  [DEBUG] Set variable ${nestedAction.name} = ${value}`);
-                      break;
-                    }
-                    case "assert": {
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.waitFor({ state: "visible" });
-                      if (nestedAction.value) {
-                        const interpolated = interpolate(nestedAction.value);
-                        const text = (await nestedHandle.textContent())?.trim() ?? "";
-                        if (!text.includes(interpolated)) {
-                          throw new Error(
-                            `Assertion failed: expected "${interpolated}", got "${text}"`
-                          );
-                        }
-                      }
-                      break;
-                    }
-                    default:
-                      throw new Error(`Nested action type ${nestedAction.type} in waitForBranch not yet supported`);
-                  }
-                  if (nestedAction.type !== "screenshot") {
-                    const trackedPayload2 = buildTrackPayload(nestedAction, index);
-                    if (trackedPayload2) {
-                      await track(trackedPayload2);
-                    }
-                  }
-                  results.push({ action: nestedAction, status: "passed" });
-                }
-              } else if (typeof branch === "object" && "workflow" in branch) {
-                const workflowPath = path5__default.resolve(workflowDir, branch.workflow);
-                if (debugMode) {
-                  console.log(`  [DEBUG] waitForBranch: loading workflow from ${workflowPath}`);
-                }
-                const { loadWorkflowDefinition } = await import('./loader-2CW6OEXJ.js');
-                const nestedWorkflow = await loadWorkflowDefinition(workflowPath);
-                if (branch.variables) {
-                  for (const [key, value] of Object.entries(branch.variables)) {
-                    const interpolated = interpolate(value);
-                    context.variables.set(key, interpolated);
-                  }
-                }
-                for (const testRef of nestedWorkflow.tests) {
-                  const testFilePath2 = path5__default.resolve(path5__default.dirname(workflowPath), testRef.file);
-                  const nestedTest = await loadTestDefinition(testFilePath2);
-                  if (nestedTest.variables) {
-                    for (const [key, value] of Object.entries(nestedTest.variables)) {
-                      const interpolated = interpolateVariables(value, context.variables);
-                      context.variables.set(key, interpolated);
-                    }
-                  }
-                  const nestedResult = await runTestInWorkflow(
-                    nestedTest,
-                    page,
-                    context,
-                    options,
-                    path5__default.dirname(workflowPath),
-                    testFilePath2,
-                    nestedWorkflow.config?.web?.baseUrl ?? workflowBaseUrl
-                  );
-                  results.push(...nestedResult.steps);
-                  if (nestedResult.status === "failed") {
-                    throw new Error(`Nested workflow test failed in waitForBranch`);
-                  }
-                }
-              }
-            } else if (!elementAppeared && debugMode) {
-              console.log(`  [DEBUG] waitForBranch: timeout occurred but no onTimeout branch defined, continuing silently`);
-            }
-            break;
-          }
-          default:
-            throw new Error(`Unsupported action type: ${action.type}`);
-        }
-        const trackedPayload = buildTrackPayload(action, index);
-        if (trackedPayload) {
-          await track(trackedPayload);
-        }
-        results.push({ action, status: "passed" });
+        const actionExtras = await executeActionWithRetry(page, action, index, {
+          baseUrl,
+          context,
+          screenshotDir,
+          debugMode,
+          interactive: false,
+          aiConfig: options.aiConfig,
+          browserName,
+          testFilePath,
+          responseLog,
+          stepStartTs
+        });
+        results.push({ action, status: "passed", logOutput: actionExtras.logOutput });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         results.push({ action, status: "failed", error: message });
@@ -4955,13 +4542,14 @@ async function runWorkflowWithContext(workflow, workflowFilePath, options) {
 Starting workflow: ${workflow.name}`);
   console.log(`Session ID: ${sessionId}
 `);
-  if (workflow.config?.appwrite) {
+  const effectiveAppwriteConfig = workflow.config?.appwrite ? {
+    endpoint: workflow.config.appwrite.endpoint,
+    projectId: workflow.config.appwrite.projectId,
+    apiKey: workflow.config.appwrite.apiKey
+  } : options.appwriteConfig;
+  if (effectiveAppwriteConfig) {
     if (!executionContext.appwriteConfig) {
-      executionContext.appwriteConfig = {
-        endpoint: workflow.config.appwrite.endpoint,
-        projectId: workflow.config.appwrite.projectId,
-        apiKey: workflow.config.appwrite.apiKey
-      };
+      executionContext.appwriteConfig = effectiveAppwriteConfig;
     }
     setupAppwriteTracking(page, executionContext);
   }
@@ -5163,15 +4751,20 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       process.env.INTELLITESTER_SESSION_ID = sessionId;
       process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
     }
+    const trackingAppwrite = workflow.config?.appwrite ? {
+      endpoint: workflow.config.appwrite.endpoint,
+      projectId: workflow.config.appwrite.projectId,
+      apiKey: workflow.config.appwrite.apiKey
+    } : options.appwriteConfig;
     fileTracking = await initFileTracking({
       sessionId,
       cleanupConfig,
       trackDir: options.trackDir,
-      providerConfig: workflow.config?.appwrite ? {
+      providerConfig: trackingAppwrite ? {
         provider: "appwrite",
-        endpoint: workflow.config.appwrite.endpoint,
-        projectId: workflow.config.appwrite.projectId,
-        apiKey: workflow.config.appwrite.apiKey
+        endpoint: trackingAppwrite.endpoint,
+        projectId: trackingAppwrite.projectId,
+        apiKey: trackingAppwrite.apiKey
       } : void 0
     });
     process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
@@ -5219,12 +4812,13 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   };
   process.on("SIGINT", signalCleanup);
   process.on("SIGTERM", signalCleanup);
-  const browserName = options.browser ?? workflow.config?.web?.browser ?? "chromium";
+  const browserName = workflow.config?.web?.browser ?? options.browser ?? "chromium";
   const headless = options.headed === true ? false : workflow.config?.web?.headless ?? true;
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
   const browser = await getBrowser2(browserName).launch(getBrowserLaunchOptions({ headless, browser: browserName }));
   console.log(`Browser launched successfully`);
-  const testSizes = options.testSizes && options.testSizes.length > 0 ? options.testSizes : ["1920x1080"];
+  const workflowTestSizes = workflow.config?.web?.testSizes;
+  const testSizes = workflowTestSizes && workflowTestSizes.length > 0 ? workflowTestSizes : options.testSizes && options.testSizes.length > 0 ? options.testSizes : ["1920x1080"];
   const viewportSizes = [];
   for (const size of testSizes) {
     const viewport = parseViewportSize(size);
@@ -5237,11 +4831,12 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   }
   const allTestResults = [];
   let anyFailed = false;
-  const cliStorageState = typeof options.storageState === "string" ? path5__default.isAbsolute(options.storageState) ? options.storageState : path5__default.resolve(process.cwd(), options.storageState) : options.storageState;
-  const storageState = cliStorageState ?? resolveStorageStatePath(
+  const optionsStorageState = typeof options.storageState === "string" ? path5__default.isAbsolute(options.storageState) ? options.storageState : path5__default.resolve(process.cwd(), options.storageState) : options.storageState;
+  const workflowStorageState = resolveStorageStatePath(
     workflow.config?.web?.storageState,
     workflowDir
   );
+  const storageState = workflowStorageState ?? optionsStorageState;
   let browserContext = await browser.newContext({
     viewport: viewportSizes[0].viewport,
     ...storageState ? { storageState } : {}
@@ -5257,7 +4852,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       endpoint: workflow.config.appwrite.endpoint,
       projectId: workflow.config.appwrite.projectId,
       apiKey: workflow.config.appwrite.apiKey
-    } : void 0
+    } : options.appwriteConfig
   };
   if (workflow.variables) {
     for (const [key, value] of Object.entries(workflow.variables)) {
@@ -5430,6 +5025,6 @@ Collected ${serverResources.length} server-tracked resources`);
 // src/executors/web/index.ts
 init_esm_shims();
 
-export { buildCompletionOptions, buildModel, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, initFileTracking, interpolateVariables, mergeFileTrackedResources, parseViewportSize, resolveStorageStatePath, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, webServerManager };
-//# sourceMappingURL=chunk-VWXGXFIM.js.map
-//# sourceMappingURL=chunk-VWXGXFIM.js.map
+export { buildCompletionOptions, buildModel, createTestContext, executeActionWithRetry, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, initFileTracking, interpolateVariables, mergeFileTrackedResources, parseViewportSize, resolveStorageStatePath, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, webServerManager };
+//# sourceMappingURL=chunk-KRXZC5J5.js.map
+//# sourceMappingURL=chunk-KRXZC5J5.js.map