@canaryai/cli 0.1.1-alpha.0

package/dist/runner/preload.js

@@ -0,0 +1,1491 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/runner/instrumentation.ts
+import Module from "module";
+import { createRequire } from "module";
+
+// src/runner/config.ts
+import path2 from "path";
+
+// src/runner/env.ts
+import fs from "fs";
+import path from "path";
+var loaded = false;
+function loadCanaryEnv() {
+  if (loaded) return;
+  loaded = true;
+  const explicitPath = process.env.CANARY_ENV_FILE;
+  const defaultPath = path.join(process.cwd(), ".env");
+  const envPath = explicitPath || defaultPath;
+  if (fs.existsSync(envPath)) {
+    loadFile(envPath);
+  }
+}
+function loadFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const idx = trimmed.indexOf("=");
+      if (idx === -1) continue;
+      const key = trimmed.slice(0, idx).trim();
+      const value = trimmed.slice(idx + 1).trim();
+      if (!key) continue;
+      if (process.env[key] === void 0) {
+        process.env[key] = stripQuotes(value);
+      }
+    }
+  } catch {
+  }
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+// src/runner/config.ts
+function loadCanaryConfig() {
+  loadCanaryEnv();
+  const eventLogPath = (() => {
+    const userPath = process.env.CANARY_EVENT_LOG;
+    if (userPath) return userPath;
+    const worker = process.env.TEST_WORKER_INDEX ?? "runner";
+    return path2.join(process.cwd(), "test-results", "ai-healer", `events-worker-${worker}.jsonl`);
+  })();
+  const baseConfig = {
+    enabled: true,
+    allowedPlaywrightVersion: process.env.CANARY_PLAYWRIGHT_VERSION,
+    aiProvider: process.env.AI_PROVIDER,
+    aiModel: process.env.AI_MODEL,
+    apiKey: process.env.AI_API_KEY,
+    healTimeoutMs: Number(process.env.AI_TIMEOUT_MS ?? 12e4),
+    // 2 minutes for agentic healing
+    maxActions: Number(process.env.CANARY_MAX_ACTIONS ?? 50),
+    // Generous step limit for agentic healing
+    dryRun: process.env.CANARY_DRY_RUN === "1",
+    warnOnly: process.env.CANARY_WARN_ONLY === "1",
+    visionEnabled: process.env.CANARY_VISION === "1" || process.env.AI_VISION === "1",
+    debug: process.env.CANARY_DEBUG === "1",
+    readOnly: process.env.CANARY_READ_ONLY === "1",
+    allowRunCode: process.env.CANARY_ALLOW_RUN_CODE === "1",
+    allowEvaluate: process.env.CANARY_ALLOW_EVALUATE !== "0",
+    maxPayloadBytes: Number(process.env.CANARY_MAX_PAYLOAD_BYTES ?? 6e4),
+    // cap snapshots/screenshots/text
+    eventLogPath,
+    eventLoggingEnabled: process.env.CANARY_EVENT_LOG !== "0"
+  };
+  const disabled = process.env.CANARY_ENABLED === "0" || process.env.CANARY_DISABLED === "1" || process.env.AI_HEALING === "0";
+  return {
+    ...baseConfig,
+    enabled: !disabled && baseConfig.enabled
+  };
+}
+
+// src/runner/healer.ts
+import { stepCountIs, streamText, tool } from "ai";
+import { z } from "zod";
+
+// src/runner/ai-client.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createAzure } from "@ai-sdk/azure";
+function resolveHealerModel(config = loadCanaryConfig()) {
+  if (!config.enabled) {
+    return { model: null, reason: "healing_disabled" };
+  }
+  if (!config.apiKey) {
+    return { model: null, reason: "missing_api_key" };
+  }
+  const provider = (config.aiProvider ?? "openai").toLowerCase();
+  const modelId = config.aiModel || (provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini");
+  try {
+    switch (provider) {
+      case "openai": {
+        const client = createOpenAI({ apiKey: config.apiKey, baseURL: process.env.AI_BASE_URL });
+        return { model: client(modelId), modelId };
+      }
+      case "anthropic": {
+        const client = createAnthropic({ apiKey: config.apiKey, baseURL: process.env.AI_BASE_URL });
+        return { model: client(modelId), modelId };
+      }
+      case "azure": {
+        const resourceName = process.env.AZURE_OPENAI_RESOURCE_NAME;
+        const apiVersion = process.env.AZURE_OPENAI_API_VERSION;
+        if (!resourceName) {
+          return { model: null, reason: "missing_azure_resource" };
+        }
+        const client = createAzure({
+          apiKey: config.apiKey,
+          resourceName,
+          apiVersion
+        });
+        return { model: client(modelId), modelId };
+      }
+      default:
+        return { model: null, reason: "unsupported_provider" };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { model: null, reason: `model_error:${message}` };
+  }
+}
+
+// src/runner/healer.ts
+var REDACTION_PATTERNS = [
+  { regex: /bearer\s+[a-z0-9._-]+/gi, replacement: "[REDACTED_BEARER]" },
+  { regex: /api[_-]?key[:\s"']+[a-z0-9._-]+/gi, replacement: "[REDACTED_API_KEY]" },
+  { regex: /secret[:\s"']+[a-z0-9._-]+/gi, replacement: "[REDACTED_SECRET]" },
+  { regex: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, replacement: "[REDACTED_EMAIL]" },
+  { regex: /[0-9]{12,}/g, replacement: "[REDACTED_NUMBER]" }
+];
+var CODE_DENY_PATTERNS = [/process\.env/i, /child_process/i, /\brequire\s*\(/i, /\bimport\s*\(/i];
+function classifyFailure(context) {
+  const message = (context.errorMessage ?? "").toLowerCase();
+  if (message.includes("closed") || message.includes("target page, context or browser has been closed")) {
+    return { healable: false, reason: "context_closed" };
+  }
+  if (message.includes("navigation failed") && message.includes("net::")) {
+    return { healable: false, reason: "navigation_failed" };
+  }
+  return { healable: true, reason: "agent_healing" };
+}
+async function executeHealActions(decision, failure, execCtx) {
+  const config = loadCanaryConfig();
+  const started = Date.now();
+  const mode = resolveMode(config);
+  const actionsRun = [];
+  const errors = [];
+  const logTools = config.debug || process.env.CANARY_TOOL_LOG === "1";
+  const initialContext = await buildInitialPageContext(execCtx.page, config);
+  if (!decision.healable) {
+    return baseOutcome({
+      mode,
+      started,
+      healed: false,
+      shouldRetryOriginal: false,
+      reason: decision.reason,
+      actionsRun,
+      errors
+    });
+  }
+  const { model, modelId, reason: modelReason } = resolveHealerModel(config);
+  if (!model) {
+    return baseOutcome({
+      mode,
+      started,
+      healed: false,
+      shouldRetryOriginal: false,
+      reason: modelReason ?? "no_model",
+      actionsRun,
+      errors
+    });
+  }
+  const testContext = {
+    testFile: execCtx.testContext?.testFile,
+    testTitle: execCtx.testContext?.testTitle,
+    testSource: execCtx.testContext?.testSource ? sanitizeString(execCtx.testContext.testSource) : void 0,
+    currentStep: `${failure.action ?? "unknown"}(${failure.target ?? "unknown"})`,
+    expectedAfter: execCtx.testContext?.expectedAfter,
+    action: failure.action ?? "unknown",
+    target: failure.target,
+    errorMessage: failure.errorMessage
+  };
+  const toolset = createAgenticTools({
+    page: execCtx.page,
+    config,
+    actionsRun,
+    debug: config.debug
+  });
+  let completionReason;
+  try {
+    const abort = AbortSignal.timeout(config.healTimeoutMs);
+    const result = await streamText({
+      model,
+      system: buildSystemPrompt(testContext, config),
+      messages: buildInitialMessages(testContext, failure, initialContext),
+      tools: toolset.tools,
+      stopWhen: stepCountIs(Math.max(1, config.maxActions)),
+      abortSignal: abort,
+      maxRetries: 0,
+      onStepFinish: (step) => {
+        if (config.debug) {
+          console.log(
+            `[canary][debug] step finish: finishReason=${step.finishReason}; toolCalls=${step.toolCalls?.length ?? 0}; toolResults=${step.toolResults?.length ?? 0}`
+          );
+        }
+        if (logTools) {
+          logToolStep(step);
+        }
+      }
+    });
+    for await (const _ of result.fullStream) {
+      if (toolset.isComplete()) {
+        completionReason = toolset.getCompletionReason();
+        if (config.debug) {
+          console.log(`[canary][debug] agent marked complete: ${completionReason}`);
+        }
+        break;
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    errors.push(message);
+    if (config.debug) {
+      console.log(`[canary][debug] agent error: ${message}`);
+    }
+  }
+  const healed = toolset.isComplete();
+  return {
+    healed,
+    shouldRetryOriginal: false,
+    // Agent-controlled completion, no retry needed
+    actionsRun,
+    timedOut: Date.now() - started > config.healTimeoutMs,
+    durationMs: Date.now() - started,
+    errors,
+    mode,
+    reason: completionReason ?? (healed ? "agent_healed" : "agent_incomplete"),
+    modelId,
+    summary: toolset.getSummary()
+  };
+}
+function createAgenticTools(params) {
+  const { page, config, actionsRun, debug } = params;
+  let complete = false;
+  let completionReason;
+  let completionSummary;
+  const maxPayloadBytes = Math.max(1e3, config.maxPayloadBytes || 6e4);
+  const log = (msg) => {
+    if (debug) {
+      console.log(`[canary][debug] ${msg}`);
+    }
+  };
+  const track = (action) => {
+    actionsRun.push(action);
+  };
+  const tools = {
+    // === Core Action Tools ===
+    click: tool({
+      description: "Click an element by its visible text",
+      inputSchema: z.object({ text: z.string().describe("The visible text to click") }),
+      execute: async ({ text }) => {
+        track(`click:${text}`);
+        log(`click called with text="${text}"`);
+        if (config.readOnly) return { clicked: "", error: "read_only_mode" };
+        if (config.dryRun) return { clicked: text, mode: "dry-run" };
+        if (!page?.getByText) return { clicked: "", error: "Page unavailable" };
+        try {
+          const el = page.getByText(text);
+          if (el?.scrollIntoViewIfNeeded) {
+            await el.scrollIntoViewIfNeeded({ timeout: 2e3 });
+          }
+          const clickable = el;
+          if (clickable?.click) {
+            await clickable.click({ timeout: 5e3 });
+          }
+          log(`click succeeded for "${text}"`);
+          return { clicked: text };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`click error: ${msg}`);
+          return { clicked: "", error: msg };
+        }
+      }
+    }),
+    click_selector: tool({
+      description: "Click an element by CSS or Playwright selector",
+      inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      execute: async ({ selector }) => {
+        track(`click_selector:${selector}`);
+        log(`click_selector called with selector="${selector}"`);
+        if (config.readOnly) return { clicked: "", error: "read_only_mode" };
+        if (config.dryRun) return { clicked: selector, mode: "dry-run" };
+        if (!page?.locator) return { clicked: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.scrollIntoViewIfNeeded) {
+            await el.scrollIntoViewIfNeeded({ timeout: 2e3 });
+          }
+          if (el?.click) {
+            await el.click({ timeout: 5e3 });
+          }
+          log(`click_selector succeeded for "${selector}"`);
+          return { clicked: selector };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`click_selector error: ${msg}`);
+          return { clicked: "", error: msg };
+        }
+      }
+    }),
+    fill: tool({
+      description: "Fill an input field with a value using CSS selector (clears existing content)",
+      inputSchema: z.object({
+        selector: z.string().describe('CSS selector for the input (e.g. input[placeholder="..."])'),
+        value: z.string().describe("Value to fill")
+      }),
+      execute: async ({ selector, value }) => {
+        track(`fill:${selector}`);
+        log(`fill called with selector="${selector}" value="${value}"`);
+        if (config.readOnly) return { filled: "", error: "read_only_mode" };
+        if (config.dryRun) return { filled: selector, mode: "dry-run" };
+        if (!page?.locator) return { filled: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.fill) {
+            await el.fill(value, { timeout: 5e3 });
+          }
+          log(`fill succeeded`);
+          return { filled: selector, value };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`fill error: ${msg}`);
+          return { filled: "", error: msg };
+        }
+      }
+    }),
+    fill_by_name: tool({
+      description: 'Fill a textbox by its accessible name (shown in snapshot as textbox "NAME"). This is the PREFERRED way to fill inputs - use the name from the snapshot directly.',
+      inputSchema: z.object({
+        name: z.string().describe('The accessible name of the textbox (from snapshot, e.g. "Enter 6-digit code")'),
+        value: z.string().describe("Value to fill")
+      }),
+      execute: async ({ name, value }) => {
+        track(`fill_by_name:${name}`);
+        log(`fill_by_name called with name="${name}" value="${value}"`);
+        if (config.readOnly) return { filled: "", error: "read_only_mode" };
+        if (config.dryRun) return { filled: name, mode: "dry-run" };
+        if (!page?.locator) return { filled: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(`role=textbox[name="${name}"]`);
+          if (el?.fill) {
+            await el.fill(value, { timeout: 5e3 });
+          }
+          log(`fill_by_name succeeded`);
+          return { filled: name, value };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`fill_by_name error: ${msg}`);
+          return { filled: "", error: msg };
+        }
+      }
+    }),
+    type: tool({
+      description: "Type text character by character (triggers key events)",
+      inputSchema: z.object({
+        selector: z.string().describe("CSS or Playwright selector"),
+        text: z.string().describe("Text to type")
+      }),
+      execute: async ({ selector, text }) => {
+        track(`type:${selector}`);
+        log(`type called with selector="${selector}" text="${text}"`);
+        if (config.readOnly) return { typed: "", error: "read_only_mode" };
+        if (config.dryRun) return { typed: text, mode: "dry-run" };
+        if (!page?.locator) return { typed: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.pressSequentially) {
+            await el.pressSequentially(text);
+          }
+          log(`type succeeded`);
+          return { typed: text, into: selector };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`type error: ${msg}`);
+          return { typed: "", error: msg };
+        }
+      }
+    }),
+    press_key: tool({
+      description: "Press a keyboard key (Enter, Tab, Escape, ArrowDown, etc.)",
+      inputSchema: z.object({ key: z.string().describe("Key to press") }),
+      execute: async ({ key }) => {
+        track(`press_key:${key}`);
+        log(`press_key called with key="${key}"`);
+        if (config.readOnly) return { pressed: "", error: "read_only_mode" };
+        if (config.dryRun) return { pressed: key, mode: "dry-run" };
+        if (!page?.keyboard?.press) return { pressed: "", error: "Page unavailable" };
+        try {
+          await page.keyboard.press(key);
+          log(`press_key succeeded`);
+          return { pressed: key };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`press_key error: ${msg}`);
+          return { pressed: "", error: msg };
+        }
+      }
+    }),
+    hover: tool({
+      description: "Hover over an element",
+      inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      execute: async ({ selector }) => {
+        track(`hover:${selector}`);
+        log(`hover called with selector="${selector}"`);
+        if (config.readOnly) return { hovered: "", error: "read_only_mode" };
+        if (config.dryRun) return { hovered: selector, mode: "dry-run" };
+        if (!page?.locator) return { hovered: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.hover) {
+            await el.hover();
+          }
+          log(`hover succeeded`);
+          return { hovered: selector };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`hover error: ${msg}`);
+          return { hovered: "", error: msg };
+        }
+      }
+    }),
+    select_option: tool({
+      description: "Select an option from a dropdown",
+      inputSchema: z.object({
+        selector: z.string().describe("CSS or Playwright selector for the select element"),
+        value: z.string().describe("Value or label to select")
+      }),
+      execute: async ({ selector, value }) => {
+        track(`select_option:${selector}`);
+        log(`select_option called with selector="${selector}" value="${value}"`);
+        if (config.readOnly) return { selected: "", error: "read_only_mode" };
+        if (config.dryRun) return { selected: value, mode: "dry-run" };
+        if (!page?.locator) return { selected: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.selectOption) {
+            await el.selectOption(value);
+          }
+          log(`select_option succeeded`);
+          return { selected: value, from: selector };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`select_option error: ${msg}`);
+          return { selected: "", error: msg };
+        }
+      }
+    }),
+    // === Navigation & Waiting ===
+    wait: tool({
+      description: "Wait for a duration in milliseconds",
+      inputSchema: z.object({ ms: z.number().min(100).max(3e4).describe("Milliseconds to wait") }),
+      execute: async ({ ms }) => {
+        track(`wait:${ms}`);
+        log(`wait called with ms=${ms}`);
+        if (config.dryRun) return { waited: ms, mode: "dry-run" };
+        if (page?.waitForTimeout) {
+          await page.waitForTimeout(ms);
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, ms));
+        }
+        log(`wait completed`);
+        return { waited: ms };
+      }
+    }),
+    wait_for_selector: tool({
+      description: "Wait for an element to reach a state (visible, hidden, attached, detached)",
+      inputSchema: z.object({
+        selector: z.string().describe("CSS or Playwright selector"),
+        state: z.enum(["visible", "hidden", "attached", "detached"]).optional().describe("State to wait for")
+      }),
+      execute: async ({ selector, state }) => {
+        track(`wait_for_selector:${selector}`);
+        log(`wait_for_selector called with selector="${selector}" state="${state ?? "visible"}"`);
+        if (config.dryRun) return { found: selector, mode: "dry-run" };
+        if (!page?.locator) return { found: "", error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          if (el?.waitFor) {
+            await el.waitFor({ state: state ?? "visible" });
+          }
+          log(`wait_for_selector succeeded`);
+          return { found: selector, state: state ?? "visible" };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`wait_for_selector error: ${msg}`);
+          return { found: "", error: msg };
+        }
+      }
+    }),
+    navigate: tool({
+      description: "Navigate to a URL",
+      inputSchema: z.object({ url: z.string().describe("URL to navigate to") }),
+      execute: async ({ url }) => {
+        track(`navigate:${url}`);
+        log(`navigate called with url="${url}"`);
+        if (config.readOnly) return { navigated: "", error: "read_only_mode" };
+        if (config.dryRun) return { navigated: url, mode: "dry-run" };
+        if (!page?.goto) return { navigated: "", error: "Page unavailable" };
+        try {
+          await page.goto(url);
+          log(`navigate succeeded`);
+          return { navigated: url };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`navigate error: ${msg}`);
+          return { navigated: "", error: msg };
+        }
+      }
+    }),
+    go_back: tool({
+      description: "Go back in browser history",
+      inputSchema: z.object({}),
+      execute: async () => {
+        track("go_back");
+        log(`go_back called`);
+        if (config.readOnly) return { action: "", error: "read_only_mode" };
+        if (config.dryRun) return { action: "back", mode: "dry-run" };
+        if (!page?.goBack) return { action: "", error: "Page unavailable" };
+        try {
+          await page.goBack();
+          log(`go_back succeeded`);
+          return { action: "back" };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`go_back error: ${msg}`);
+          return { action: "", error: msg };
+        }
+      }
+    }),
+    reload: tool({
+      description: "Reload the current page",
+      inputSchema: z.object({}),
+      execute: async () => {
+        track("reload");
+        log(`reload called`);
+        if (config.readOnly) return { action: "", error: "read_only_mode" };
+        if (config.dryRun) return { action: "reload", mode: "dry-run" };
+        if (!page?.reload) return { action: "", error: "Page unavailable" };
+        try {
+          await page.reload();
+          log(`reload succeeded`);
+          return { action: "reload" };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`reload error: ${msg}`);
+          return { action: "", error: msg };
+        }
+      }
+    }),
+    // === Inspection Tools ===
+    snapshot: tool({
+      description: "Get the accessibility tree of the current page to understand its structure. ALWAYS call this first!",
+      inputSchema: z.object({}),
+      execute: async () => {
+        track("snapshot");
+        log(`snapshot called`);
+        if (config.dryRun) return { tree: null, mode: "dry-run" };
+        if (!page) return { error: "Page unavailable" };
+        let tree;
+        let html;
+        try {
+          if (page.accessibility && typeof page.accessibility.snapshot === "function") {
+            tree = await page.accessibility.snapshot();
+          }
+        } catch (err) {
+          log(`accessibility snapshot error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!tree && page.evaluate) {
+          try {
+            html = await page.evaluate("document.body.innerHTML");
+            if (html) {
+              log(`snapshot using HTML fallback`);
+            }
+          } catch (err) {
+            log(`HTML fallback error: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        if (!tree && !html) {
+          return { error: "Could not get page content" };
+        }
+        log(`snapshot succeeded`);
+        const sanitizedTree = sanitizeUnknown(tree, maxPayloadBytes);
+        const sanitizedHtml = html ? truncate(sanitizeString(html), maxPayloadBytes) : void 0;
+        return { tree: sanitizedTree, html: sanitizedHtml };
+      }
+    }),
+    screenshot: tool({
+      description: "Capture a screenshot of the current page",
+      inputSchema: z.object({
+        fullPage: z.boolean().optional().describe("Whether to capture the full page")
+      }),
+      execute: async ({ fullPage }) => {
+        track("screenshot");
+        log(`screenshot called fullPage=${fullPage}`);
+        if (config.dryRun) return { screenshot: void 0, mode: "dry-run" };
+        if (!page?.screenshot) return { error: "Page unavailable" };
+        try {
+          const buffer = await page.screenshot({ fullPage: fullPage ?? false });
+          const b = typeof buffer === "string" ? Buffer.from(buffer) : Buffer.from(buffer);
+          const base64 = b.toString("base64");
+          if (b.byteLength > maxPayloadBytes || base64.length > maxPayloadBytes) {
+            return { error: "screenshot_too_large" };
+          }
+          const dataUrl = `data:image/png;base64,${truncate(base64, maxPayloadBytes)}`;
+          log(`screenshot succeeded`);
+          return { screenshot: dataUrl };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`screenshot error: ${msg}`);
+          return { error: msg };
+        }
+      }
+    }),
+    get_text: tool({
+      description: "Get the text content of an element",
+      inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      execute: async ({ selector }) => {
+        track(`get_text:${selector}`);
+        log(`get_text called with selector="${selector}"`);
+        if (config.dryRun) return { text: null, mode: "dry-run" };
+        if (!page?.locator) return { error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          const text = el?.textContent ? await el.textContent() : null;
+          const sanitized = text ? truncate(sanitizeString(text), maxPayloadBytes) : text;
+          log(`get_text succeeded: "${sanitized}"`);
+          return { text: sanitized };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`get_text error: ${msg}`);
+          return { error: msg };
+        }
+      }
+    }),
+    is_visible: tool({
+      description: "Check if an element is visible",
+      inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      execute: async ({ selector }) => {
+        track(`is_visible:${selector}`);
+        log(`is_visible called with selector="${selector}"`);
+        if (config.dryRun) return { visible: false, mode: "dry-run" };
+        if (!page?.locator) return { error: "Page unavailable" };
+        try {
+          const el = page.locator(selector);
+          const visible = el?.isVisible ? await el.isVisible() : false;
+          log(`is_visible succeeded: ${visible}`);
+          return { visible };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`is_visible error: ${msg}`);
+          return { error: msg };
+        }
+      }
+    }),
+    evaluate: tool({
+      description: "Run JavaScript in the page context",
+      inputSchema: z.object({ script: z.string().describe("JavaScript code to execute") }),
+      execute: async ({ script }) => {
+        track("evaluate");
+        log(`evaluate called`);
+        if (!config.allowEvaluate) return { error: "evaluate_disabled" };
+        if (violatesCodeDenylist(script)) return { error: "evaluate_blocked" };
+        if (config.dryRun) return { result: null, mode: "dry-run" };
+        if (!page?.evaluate) return { error: "Page unavailable" };
+        try {
+          const scriptSafe = truncate(script, maxPayloadBytes);
+          const result = await page.evaluate(scriptSafe);
+          log(`evaluate succeeded`);
+          return { result: sanitizeUnknown(result, maxPayloadBytes) };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`evaluate error: ${msg}`);
+          return { error: msg };
+        }
+      }
+    }),
+    // === Power Tool: Arbitrary Playwright Code ===
+    run_playwright_code: tool({
+      description: 'Execute arbitrary Playwright code. Has access to `page` object. Use for complex operations not covered by other tools. Example: `await page.getByRole("button", { name: "Submit" }).click();`',
+      inputSchema: z.object({
+        code: z.string().describe("Playwright code to execute (has access to `page` object)")
+      }),
+      execute: async ({ code }) => {
+        track("run_playwright_code");
+        log(`run_playwright_code called with code:
+${code}`);
+        if (!config.allowRunCode) return { executed: false, error: "run_code_disabled" };
+        if (violatesCodeDenylist(code)) return { executed: false, error: "run_code_blocked" };
+        if (config.dryRun) return { executed: false, mode: "dry-run" };
+        if (!page) return { executed: false, error: "Page unavailable" };
+        try {
+          const boundedCode = truncate(code, maxPayloadBytes);
+          const fn = new Function("page", `return (async () => { ${boundedCode} })();`);
+          const result = await fn(page);
+          log(`run_playwright_code succeeded`);
+          return { executed: true, result: sanitizeUnknown(result, maxPayloadBytes) };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`run_playwright_code error: ${msg}`);
+          return { executed: false, error: msg };
+        }
+      }
+    }),
+    // === Completion Tool ===
+    mark_complete: tool({
+      description: "Call this when the browser is ready for the test to continue. You MUST call this when done healing!",
+      inputSchema: z.object({
+        reason: z.string().describe("Brief technical description of what was done"),
+        summary: z.string().describe(`One-line human-readable summary for the test report, e.g. "Clicked 'Send OTP' instead of 'Submit'" or "Filled email field by accessible name"`)
+      }),
+      execute: async ({ reason, summary }) => {
+        track("mark_complete");
+        log(`mark_complete called with reason="${reason}" summary="${summary}"`);
+        if (!config.dryRun) {
+          complete = true;
+          completionReason = reason;
+          completionSummary = summary;
+        }
+        return { complete: !config.dryRun, reason, summary, mode: config.dryRun ? "dry-run" : void 0 };
+      }
+    })
+  };
+  return {
+    tools,
+    isComplete: () => complete,
+    getCompletionReason: () => completionReason,
+    getSummary: () => completionSummary
+  };
+}
+function buildSystemPrompt(testContext, config) {
+  const testInfo = testContext.testFile ? `
+## Test Context
+File: ${testContext.testFile}
+Test: "${testContext.testTitle ?? "unknown"}"
+` : "";
+  const testSource = testContext.testSource ? `
+### Full Test Code:
+\`\`\`typescript
+${testContext.testSource}
+\`\`\`
+` : "";
+  const expectedAfter = testContext.expectedAfter ? `
+### What the Test Expects After This Step:
+${testContext.expectedAfter}
+` : "";
+  return `You are an AI test healer. A Playwright test step failed. Your job is to make the browser ready for the next step in the test **without violating the intent of the test**. Heal only the failing step; do not advance beyond it.
+
+## Your Goal
+Get the browser into the state the test expects, then call mark_complete.
+${testInfo}${testSource}
+### Current Step That Failed:
+${testContext.currentStep}
+${expectedAfter}
+## The Failure
+Action attempted: ${testContext.action}
+Target: ${testContext.target ?? "unknown"}
+Error: ${testContext.errorMessage ?? "unknown"}
+
+## Test Intent and Discipline
+- Adhere to the spirit of the test. If advancing would bypass a required validation or skip a missing field, you must not proceed\u2014report failure instead.
+- Heal only this step. Avoid extra navigation or state changes unrelated to the intended action. If you take a detour, undo it before completion.
+- If you cannot confidently achieve the expected postcondition for this step, do not mark complete; let the test fail.
+
+## Tools Available
+
+### Inspection (use first!)
+- snapshot() - Get accessibility tree to see page structure
+- screenshot() - Capture visual screenshot
+- get_text(selector) - Get text content of an element
+- is_visible(selector) - Check if element is visible
+
+### Actions
+- click(text) - Click element by visible text
+- click_selector(selector) - Click by CSS/Playwright selector
+- fill_by_name(name, value) - PREFERRED: Fill textbox by accessible name from snapshot (e.g. textbox "Enter 6-digit code")
+- fill(selector, value) - Fill input by CSS selector (use placeholder attribute, NOT aria-label)
+- type(selector, text) - Type text character by character
+- press_key(key) - Press keyboard key (Enter, Tab, etc.)
+- hover(selector) - Hover over element
+- select_option(selector, value) - Select from dropdown
+
+### Navigation & Waiting
+- wait(ms) - Wait for a duration
+- wait_for_selector(selector, state?) - Wait for element state
+- navigate(url) - Navigate to URL
+- go_back() - Go back in history
+- reload() - Reload page
+
+### Power Tool
+- run_playwright_code(code) - Execute any Playwright code with \`page\` object
+  Example: \`await page.getByRole('button', { name: 'Submit' }).click();\`
+
+### Completion (REQUIRED)
+- mark_complete(reason, summary) - Call when browser is ready for test to continue
+  - reason: technical description of what was done
+  - summary: one-line human-readable summary for test report (e.g. "Clicked 'Send OTP' instead of 'Submit'")
+
+## CRITICAL RULES - READ CAREFULLY
+
+### Rule 1: YOU MUST PERFORM THE ACTION YOURSELF
+The test tried to ${testContext.action}("${testContext.target ?? ""}") but it failed.
+YOU must perform the equivalent action on the correct element.
+DO NOT leave it for "the next step" - there is no next step until YOU complete the action.
+
+### Rule 2: The workflow is ALWAYS:
+1. snapshot() - understand the page
+2. click() / fill() / type() - PERFORM THE ACTION on the correct element
+3. mark_complete() - report what you did
+
+### Rule 3: NEVER call mark_complete without performing an action
+If mark_complete is called without a click/fill/type, the test WILL FAIL.
+
+## Example 1: Test tried click("Submit") but button says "Send OTP"
+CORRECT:
+1. snapshot() \u2192 see "Send OTP" button exists
+2. click("Send OTP") \u2192 CLICK THE BUTTON
+3. mark_complete({reason: "clicked Send OTP button", summary: "Clicked 'Send OTP' instead of 'Submit'"})
+
+WRONG (this will cause test failure):
+1. snapshot() \u2192 see "Send OTP" button exists
+2. mark_complete(...) \u2190 WRONG! No click performed!
+
+## Example 2: Test tried fill with wrong placeholder
+If snapshot shows: textbox "Enter 6-digit code" [ref=e37]
+CORRECT:
+1. snapshot() \u2192 see textbox "Enter 6-digit code"
+2. fill_by_name("Enter 6-digit code", "111222") \u2192 USE THE NAME FROM SNAPSHOT
+3. mark_complete({reason: "filled by accessible name", summary: "Filled 'Enter 6-digit code' field"})
+
+## If healing would break test intent
+- If the page is missing required UI (e.g., a field not present) or advancing would skip validation, do NOT hack around it. Report failure by not calling mark_complete.
+- If you temporarily navigate or change state, undo it before completion so the test can continue from the intended point.
+
+## Start now
+1. Call snapshot()
+2. Identify the correct element for the intended action
+3. PERFORM THE ACTION (click, fill, type, etc.)
+4. Call mark_complete with what you did
+
+Mode: ${resolveMode(config)}.`;
+}
+function resolveMode(config) {
+  if (config.dryRun) return "dry-run";
+  if (config.warnOnly) return "warn";
+  return "full";
+}
+function baseOutcome({
+  started,
+  healed,
+  shouldRetryOriginal,
+  mode,
+  reason,
+  actionsRun = [],
+  errors = []
+}) {
+  return {
+    healed,
+    shouldRetryOriginal,
+    actionsRun,
+    timedOut: false,
+    durationMs: Date.now() - started,
+    errors,
+    mode,
+    reason
+  };
+}
+function logToolStep(step) {
+  const color = {
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    green: "\x1B[32m",
+    reset: "\x1B[0m"
+  };
+  const calls = step.toolCalls ?? [];
+  const results = step.toolResults ?? [];
+  if (calls.length === 0 && results.length === 0) {
+    console.log(
+      `${color.magenta}[canary][tool] step${color.reset} (no tool calls/results; finish=${step.finishReason ?? "unknown"})`
+    );
+  }
+  for (const call of calls) {
+    const name = call.toolName ?? "unknown_tool";
+    const args = call.args ? truncate(safeJson(call.args), 300) : "";
+    console.log(
+      `${color.magenta}[canary][tool] call${color.reset} ${color.cyan}${name}${color.reset}${args ? ` args=${args}` : ""}`
+    );
+  }
+  for (const result of results) {
+    const name = result.toolName ?? "unknown_tool";
+    const res = result.result ? truncate(safeJson(result.result), 300) : void 0;
+    const err = result.error ? truncate(safeJson(result.error), 300) : void 0;
+    const statusColor = err ? color.yellow : color.green;
+    console.log(
+      `${color.magenta}[canary][tool] result${color.reset} ${color.cyan}${name}${color.reset}` + (res ? ` ${statusColor}->${color.reset} ${res}` : "") + (err ? ` ${color.yellow}error=${err}${color.reset}` : "")
+    );
+  }
+}
+function buildInitialMessages(testContext, failure, initial) {
+  const parts = [];
+  parts.push(
+    `Please heal this test step. Start by reviewing the snapshot below. Failing step: ${failure.action ?? "unknown"}(${failure.target ?? "unknown"}). Error: ${failure.errorMessage ?? "unknown"}.`
+  );
+  if (testContext.testSource) {
+    parts.push(
+      `Full test source (truncated/redacted):
+\`\`\`typescript
+${truncate(testContext.testSource, 15e3)}
+\`\`\``
+    );
+  }
+  parts.push(`Test file: ${testContext.testFile ?? "unknown"}`);
+  parts.push(`Test title: ${testContext.testTitle ?? "unknown"}`);
+  if (initial.snapshot) {
+    parts.push(`Initial accessibility snapshot (sanitized):
+\`\`\`json
+${truncate(safeJson(initial.snapshot), 8e3)}
+\`\`\``);
+  }
+  if (initial.html) {
+    parts.push(`HTML fallback (sanitized):
+\`\`\`html
+${truncate(initial.html, 4e3)}
+\`\`\``);
+  }
+  if (initial.screenshot) {
+    parts.push(`Screenshot (base64 data URL, truncated): ${truncate(initial.screenshot, 12e3)}`);
+  }
+  parts.push(`Remember: perform only the intended step and mark_complete only when the postcondition for this step is truly met.`);
+  return [{ role: "user", content: parts.join("\n\n") }];
+}
+async function buildInitialPageContext(page, config) {
+  const maxPayloadBytes = Math.max(1e3, config.maxPayloadBytes || 6e4);
+  const result = {};
+  if (!page) return result;
+  try {
+    if (page.accessibility?.snapshot) {
+      const tree = await page.accessibility.snapshot();
+      if (tree) {
+        result.snapshot = sanitizeUnknown(tree, maxPayloadBytes);
+      }
+    }
+  } catch {
+  }
+  if (!result.snapshot && page.evaluate) {
+    try {
+      const html = await page.evaluate("document.body.innerHTML");
+      if (html) {
+        result.html = truncate(sanitizeString(html), maxPayloadBytes);
+      }
+    } catch {
+    }
+  }
+  if (config.visionEnabled && page.screenshot) {
+    try {
+      const buffer = await page.screenshot({ fullPage: false });
+      const b = typeof buffer === "string" ? Buffer.from(buffer) : Buffer.from(buffer);
+      const base64 = b.toString("base64");
+      if (b.byteLength <= maxPayloadBytes && base64.length <= maxPayloadBytes) {
+        result.screenshot = `data:image/png;base64,${truncate(base64, maxPayloadBytes)}`;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max) + "...";
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function sanitizeString(value) {
+  let result = value;
+  for (const { regex, replacement } of REDACTION_PATTERNS) {
+    result = result.replace(regex, replacement);
+  }
+  return result;
+}
+function sanitizeUnknown(value, maxPayloadBytes, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    return truncate(sanitizeString(value), maxPayloadBytes);
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "object") {
+    if (seen.has(value)) return "[REDACTED_CYCLE]";
+    seen.add(value);
+    if (Array.isArray(value)) {
+      return value.slice(0, 50).map((v) => sanitizeUnknown(v, maxPayloadBytes, seen));
+    }
+    const out = {};
+    const entries = Object.entries(value).slice(0, 50);
+    for (const [k, v] of entries) {
+      out[k] = sanitizeUnknown(v, maxPayloadBytes, seen);
+    }
+    return out;
+  }
+  return "[REDACTED_UNKNOWN]";
+}
+function violatesCodeDenylist(code) {
+  return CODE_DENY_PATTERNS.some((p) => p.test(code));
+}
+
+// src/runner/state.ts
+import fs2 from "fs";
+import path3 from "path";
+function getEventLog() {
+  if (!globalThis.__CANARY_EVENTS) {
+    globalThis.__CANARY_EVENTS = [];
+  }
+  return globalThis.__CANARY_EVENTS;
+}
+function setEventLogPath(path4) {
+  globalThis.__CANARY_EVENT_LOG_PATH = path4;
+}
+function getEventLogPath() {
+  return globalThis.__CANARY_EVENT_LOG_PATH;
+}
+function recordHealingEvent(event) {
+  loadCanaryEnv();
+  const log = getEventLog();
+  const entry = {
+    ...event,
+    workerId: process.env.TEST_WORKER_INDEX,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  log.push(entry);
+  appendEvent(entry);
+}
+function markPatched() {
+  globalThis.__CANARY_PATCHED = true;
+}
+function alreadyPatched() {
+  return globalThis.__CANARY_PATCHED === true;
+}
+function appendEvent(event) {
+  const logPath = getEventLogPath();
+  if (!logPath) return;
+  const config = loadCanaryConfig();
+  if (!config.eventLoggingEnabled) return;
+  try {
+    fs2.mkdirSync(path3.dirname(logPath), { recursive: true });
+    fs2.appendFileSync(logPath, JSON.stringify(event) + "\n");
+  } catch {
+  }
+}
+
+// src/runner/instrumentation.ts
+var DEBUG = false;
+var requireFn = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
+var LOCATOR_ACTIONS = /* @__PURE__ */ new Set([
+  "click",
+  "dblclick",
+  "fill",
+  "check",
+  "uncheck",
+  "hover",
+  "press",
+  "type",
+  "selectOption",
+  "tap"
+]);
+var PAGE_ACTIONS = /* @__PURE__ */ new Set([
+  "goto",
+  "click",
+  "dblclick",
+  "fill",
+  "check",
+  "uncheck",
+  "hover",
+  "press",
+  "type",
+  "selectOption",
+  "tap",
+  "waitForSelector"
+]);
+var LOCATOR_FACTORIES = /* @__PURE__ */ new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId",
+  "frameLocator"
+]);
+var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([
+  "locator",
+  "first",
+  "last",
+  "nth",
+  "filter",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId"
+]);
+function installInstrumentation() {
+  if (alreadyPatched()) return;
+  const config = loadCanaryConfig();
+  DEBUG = !!config.debug;
+  if (!config.enabled) {
+    markPatched();
+    return;
+  }
+  setEventLogPath(config.eventLogPath);
+  if (!ensurePlaywrightVersion(config.allowedPlaywrightVersion)) {
+    recordHealingEvent({
+      kind: "unknown",
+      action: "playwright_version_mismatch",
+      errorMessage: "Playwright version does not match CANARY_PLAYWRIGHT_VERSION",
+      healed: false
+    });
+    markPatched();
+    return;
+  }
+  hookPlaywrightModuleLoad();
+  if (DEBUG) {
+    console.log(`[canary][debug] instrumentation installed (eventLog=${config.eventLogPath})`);
+  }
+  recordHealingEvent({
+    kind: "unknown",
+    action: "instrumentation_ready",
+    healed: false
+  });
+  markPatched();
+}
+function hookPlaywrightModuleLoad() {
+  const mod = Module;
+  const originalLoad = mod._canaryOriginalLoad ?? mod._load;
+  if (!mod._canaryOriginalLoad) {
+    mod._canaryOriginalLoad = originalLoad;
+  }
+  mod._load = function patchedLoad(request, parent, isMain) {
+    if (request === "@playwright/test" || request === "playwright/test") {
+      if (DEBUG) {
+        console.log(`[canary][debug] patching playwright module (request=${request})`);
+      }
+      const real = originalLoad.call(this, request, parent, isMain);
+      return createPatchedPlaywright(real);
+    }
+    return originalLoad.call(this, request, parent, isMain);
+  };
+}
+function createPatchedPlaywright(real) {
+  if (real.__canaryPatched) return real;
+  const extended = real.test.extend({
+    page: async ({ page }, use) => {
+      recordHealingEvent({
+        kind: "page",
+        action: "fixture_initialized",
+        healed: false
+      });
+      const wrappedPage = wrapPage(page);
+      await use(wrappedPage);
+    }
+  });
+  const patched = {
+    ...real,
+    test: extended,
+    expect: wrapExpect(real.expect)
+  };
+  patched.__canaryPatched = true;
+  if (DEBUG) {
+    console.log(`[canary][debug] playwright patched`);
+  }
+  return patched;
+}
+function ensurePlaywrightVersion(expected) {
+  if (!expected) return true;
+  try {
+    const pkg = requireFn("playwright/package.json");
+    if (pkg.version && pkg.version.startsWith(expected)) {
+      return true;
+    }
+    console.warn(`[canary] Playwright version mismatch. Expected ${expected}, found ${pkg.version ?? "unknown"}`);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function wrapExpect(expectImpl) {
+  const wrapMatchers = (expectation, mode) => {
+    return new Proxy(expectation ?? {}, {
+      get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof prop === "string" && typeof value === "function") {
+          return (...args) => runMatcherWithHealing({ matcher: value, matcherName: prop, args, expectTarget: target, mode });
+        }
+        return value;
+      }
+    });
+  };
+  const proxy = new Proxy(expectImpl, {
+    apply(target, thisArg, argArray) {
+      const expectation = target.apply(thisArg, argArray);
+      return wrapMatchers(expectation, "hard");
+    },
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "soft" && typeof value === "function") {
+        return (...args) => wrapMatchers(value.apply(target, args), "soft");
+      }
+      return value;
+    }
+  });
+  return proxy;
+}
+function wrapPage(page) {
+  return new Proxy(page, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string") {
+        if (LOCATOR_FACTORIES.has(prop) && typeof value === "function") {
+          return (...args) => {
+            const locator = value.apply(target, args);
+            return wrapLocator(locator);
+          };
+        }
+        if (PAGE_ACTIONS.has(prop) && typeof value === "function") {
+          return async (...args) => {
+            return attemptWithHealing({
+              kind: "page",
+              action: prop,
+              target: safeTargetString(target),
+              locator: void 0,
+              page: target,
+              invoke: () => value.apply(target, args)
+            });
+          };
+        }
+      }
+      return value;
+    }
+  });
+}
+function wrapLocator(locator) {
+  if (!locator || typeof locator !== "object") return locator;
+  return new Proxy(locator, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && LOCATOR_ACTIONS.has(prop) && typeof value === "function") {
+        return async (...args) => {
+          return attemptWithHealing({
+            kind: "locator",
+            action: prop,
+            target: safeTargetString(target),
+            locator: target,
+            page: void 0,
+            invoke: () => value.apply(target, args)
+          });
+        };
+      }
+      if (typeof prop === "string" && LOCATOR_CHAIN_METHODS.has(prop) && typeof value === "function") {
+        return (...args) => wrapLocator(value.apply(target, args));
+      }
+      return value;
+    }
+  });
+}
+async function attemptWithHealing(ctx) {
+  try {
+    return await Promise.resolve(ctx.invoke());
+  } catch (error) {
+    const failure = buildFailureContext(ctx.kind, ctx.action, ctx.target, error);
+    recordHealingEvent({ ...failure, healed: false });
+    const decision = classifyFailure(failure);
+    if (DEBUG) {
+      console.log(`[canary][debug] failure intercepted: kind=${ctx.kind} action=${ctx.action} reason=${decision.healable ? decision.reason ?? "healable" : decision.reason}`);
+    }
+    if (!decision.healable) {
+      throw error;
+    }
+    const outcome = await executeHealActions(decision, failure, {
+      kind: ctx.kind,
+      action: ctx.action,
+      target: ctx.target,
+      locator: isLocatorLike(ctx.locator) ? ctx.locator : void 0,
+      page: isPageLike(ctx.page) ? ctx.page : void 0,
+      testContext: {
+        testFile: testContext?.testFile,
+        testTitle: testContext?.testTitle,
+        testSource: loadTestSource(testContext?.testFile)
+      }
+    });
+    const testContext = getTestContext();
+    const summaryBase = {
+      ...failure,
+      healed: outcome.healed,
+      strategy: "agentic",
+      reason: outcome.reason ?? decision.reason,
+      actions: actionsToEventItems(outcome.actionsRun),
+      durationMs: outcome.durationMs,
+      mode: outcome.mode,
+      decision: decision.reason,
+      modelId: outcome.modelId,
+      summary: outcome.summary,
+      testFile: testContext?.testFile,
+      testTitle: testContext?.testTitle
+    };
+    if (outcome.healed && !outcome.shouldRetryOriginal) {
+      recordHealingEvent({ ...summaryBase, healed: true });
+      return void 0;
+    }
+    if (outcome.shouldRetryOriginal) {
+      try {
+        const retried = await Promise.resolve(ctx.invoke());
+        if (DEBUG) {
+          console.log(`[canary][debug] retry_original succeeded for action=${ctx.action}`);
+        }
+        recordHealingEvent({ ...summaryBase, healed: true });
+        return retried;
+      } catch (retryError) {
+        const retryInfo = errorInfo(retryError);
+        recordHealingEvent({ ...summaryBase, healed: false, errorMessage: retryInfo.message });
+        if (DEBUG) {
+          console.log(`[canary][debug] retry_original failed for action=${ctx.action}: ${retryInfo.message ?? retryError}`);
+        }
+        throw retryError;
+      }
+    }
+    recordHealingEvent(summaryBase);
+    throw error;
+  }
+}
+async function runMatcherWithHealing(params) {
+  const { matcher, matcherName, args, expectTarget, mode } = params;
+  const invoke = () => matcher.apply(expectTarget, args);
+  if (mode === "soft") {
+    return Promise.resolve(invoke());
+  }
+  try {
+    return await Promise.resolve(invoke());
+  } catch (error) {
+    const target = stringifyTarget(args?.[0]);
+    const failure = buildFailureContext("expect", matcherName, target, error);
+    recordHealingEvent({ ...failure, healed: false });
+    const decision = classifyFailure(failure);
+    if (!decision.healable) {
+      throw error;
+    }
+    const outcome = await executeHealActions(decision, failure, {
+      kind: "expect",
+      action: matcherName,
+      target,
+      locator: isLocatorLike(args?.[0]) ? args[0] : void 0
+    });
+    const testContext = getTestContext();
+    const summaryBase = {
+      ...failure,
+      healed: false,
+      strategy: "agentic",
+      reason: outcome.reason ?? decision.reason,
+      actions: actionsToEventItems(outcome.actionsRun),
+      durationMs: outcome.durationMs,
+      mode: outcome.mode,
+      decision: decision.reason,
+      modelId: outcome.modelId,
+      summary: outcome.summary,
+      testFile: testContext?.testFile,
+      testTitle: testContext?.testTitle
+    };
+    if (outcome.shouldRetryOriginal) {
+      try {
+        const retried = await Promise.resolve(invoke());
+        recordHealingEvent({ ...summaryBase, healed: true });
+        return retried;
+      } catch (retryError) {
+        const retryInfo = errorInfo(retryError);
+        recordHealingEvent({ ...summaryBase, healed: false, errorMessage: retryInfo.message });
+        throw retryError;
+      }
+    }
+    recordHealingEvent(summaryBase);
+    throw error;
+  }
+}
+function buildFailureContext(kind, action, target, error) {
+  const info = errorInfo(error);
+  return {
+    kind,
+    action,
+    target,
+    errorMessage: info.message,
+    errorName: info.name,
+    stack: info.stack
+  };
+}
+function actionsToEventItems(actions) {
+  return actions.map((action) => ({ type: action }));
+}
+function errorInfo(error) {
+  if (error instanceof Error) {
+    return { message: error.message, name: error.name, stack: error.stack };
+  }
+  return { message: typeof error === "string" ? error : JSON.stringify(error) };
+}
+function isLocatorLike(candidate) {
+  return Boolean(candidate && typeof candidate === "object" && "scrollIntoViewIfNeeded" in candidate);
+}
+function isPageLike(candidate) {
+  return Boolean(candidate && typeof candidate === "object" && "waitForTimeout" in candidate);
+}
+function safeTargetString(target) {
+  try {
+    if (typeof target === "object" && target !== null && "toString" in target) {
+      const s = String(target.toString());
+      if (s && s !== "[object Object]") return s;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function loadTestSource(filePath) {
+  if (!filePath) return void 0;
+  try {
+    return requireFn("fs").readFileSync(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function stringifyTarget(candidate) {
+  if (!candidate) return void 0;
+  if (typeof candidate === "string") return candidate;
+  if (typeof candidate === "object") {
+    if ("selector" in candidate && typeof candidate.selector === "string") {
+      return String(candidate.selector);
+    }
+  }
+  return safeTargetString(candidate);
+}
+function getTestContext() {
+  try {
+    const playwright = requireFn("@playwright/test");
+    if (playwright?.test?.info) {
+      const info = playwright.test.info();
+      if (info) {
+        return {
+          testFile: info.file,
+          testTitle: info.title
+        };
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/runner/preload.ts
+getEventLog();
+installInstrumentation();
+//# sourceMappingURL=preload.js.map