@canaryai/cli 0.2.0 → 0.2.2

package/dist/{chunk-ROTCL5WO.js → chunk-TO66FC4R.js}

@@ -1,3 +1,7 @@
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
 // src/runner/config.ts
 import path2 from "path";
 
@@ -122,9 +126,12 @@ function appendEvent(event) {
   }
 }
 
+// src/runner/healing-helpers.ts
+import { createRequire } from "module";
+import fs3 from "fs";
+
 // src/runner/healer.ts
-import { stepCountIs, streamText, tool } from "ai";
-import { z } from "zod";
+import { stepCountIs, streamText } from "ai";
 
 // src/runner/ai-client.ts
 import { createOpenAI } from "@ai-sdk/openai";
@@ -171,441 +178,236 @@ function resolveHealerModel(config = loadCanaryConfig()) {
   }
 }
 
-// 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" };
+// src/runner/healer-tools.ts
+import { tool } from "ai";
+import { z } from "zod";
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max) + "...";
 }
-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
-    });
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
-  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
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function makePageTool(ctx, opts) {
+  const { page, config, actionsRun, debug } = ctx;
+  const mutates = opts.mutates ?? true;
+  const log = (msg) => {
+    if (debug) {
+      console.log(`[canary][debug] ${msg}`);
+    }
   };
-  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;
+  return tool({
+    description: opts.description,
+    inputSchema: opts.inputSchema,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    execute: async (input) => {
+      const trackSuffix = input?.text ?? input?.selector ?? input?.name ?? input?.key ?? input?.url ?? input?.ms ?? "";
+      actionsRun.push(trackSuffix ? `${opts.name}:${trackSuffix}` : opts.name);
+      log(`${opts.name} called`);
+      if (mutates && config.readOnly) return { error: "read_only_mode" };
+      if (config.dryRun) return opts.dryResult(input);
+      if (opts.pageCheck && !page?.[opts.pageCheck]) return { error: "Page unavailable" };
+      try {
+        const result = await opts.execute(input);
+        log(`${opts.name} succeeded`);
+        return result;
+      } catch (err) {
+        const msg = errMsg(err);
+        log(`${opts.name} error: ${msg}`);
+        return { error: msg };
       }
     }
-  } 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;
+  const ctx = params;
+  const { page, config } = ctx;
   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({
+    click: makePageTool(ctx, {
+      name: "click",
       description: "Click an element by its visible text",
       inputSchema: z.object({ text: z.string().describe("The visible text to click") }),
+      pageCheck: "getByText",
+      dryResult: ({ text }) => ({ clicked: text, mode: "dry-run" }),
       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 };
-        }
+        const el = page.getByText(text);
+        if (el?.scrollIntoViewIfNeeded) await el.scrollIntoViewIfNeeded({ timeout: 2e3 });
+        const clickable = el;
+        if (clickable?.click) await clickable.click({ timeout: 5e3 });
+        return { clicked: text };
       }
     }),
-    click_selector: tool({
+    click_selector: makePageTool(ctx, {
+      name: "click_selector",
       description: "Click an element by CSS or Playwright selector",
       inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      pageCheck: "locator",
+      dryResult: ({ selector }) => ({ clicked: selector, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.scrollIntoViewIfNeeded) await el.scrollIntoViewIfNeeded({ timeout: 2e3 });
+        if (el?.click) await el.click({ timeout: 5e3 });
+        return { clicked: selector };
       }
     }),
-    fill: tool({
+    fill: makePageTool(ctx, {
+      name: "fill",
       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")
       }),
+      pageCheck: "locator",
+      dryResult: ({ selector }) => ({ filled: selector, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.fill) await el.fill(value, { timeout: 5e3 });
+        return { filled: selector, value };
       }
     }),
-    fill_by_name: tool({
+    fill_by_name: makePageTool(ctx, {
+      name: "fill_by_name",
       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")
       }),
+      pageCheck: "locator",
+      dryResult: ({ name }) => ({ filled: name, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(`role=textbox[name="${name}"]`);
+        if (el?.fill) await el.fill(value, { timeout: 5e3 });
+        return { filled: name, value };
       }
     }),
-    type: tool({
+    type: makePageTool(ctx, {
+      name: "type",
       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")
       }),
+      pageCheck: "locator",
+      dryResult: ({ text }) => ({ typed: text, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.pressSequentially) await el.pressSequentially(text);
+        return { typed: text, into: selector };
       }
     }),
-    press_key: tool({
+    press_key: makePageTool(ctx, {
+      name: "press_key",
       description: "Press a keyboard key (Enter, Tab, Escape, ArrowDown, etc.)",
       inputSchema: z.object({ key: z.string().describe("Key to press") }),
+      pageCheck: "keyboard",
+      dryResult: ({ key }) => ({ pressed: key, mode: "dry-run" }),
       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 };
-        }
+        await page.keyboard.press(key);
+        return { pressed: key };
       }
     }),
-    hover: tool({
+    hover: makePageTool(ctx, {
+      name: "hover",
       description: "Hover over an element",
       inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      pageCheck: "locator",
+      dryResult: ({ selector }) => ({ hovered: selector, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.hover) await el.hover();
+        return { hovered: selector };
       }
     }),
-    select_option: tool({
+    select_option: makePageTool(ctx, {
+      name: "select_option",
       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")
       }),
+      pageCheck: "locator",
+      dryResult: ({ value }) => ({ selected: value, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.selectOption) await el.selectOption(value);
+        return { selected: value, from: selector };
       }
     }),
     // === Navigation & Waiting ===
-    wait: tool({
+    wait: makePageTool(ctx, {
+      name: "wait",
       description: "Wait for a duration in milliseconds",
       inputSchema: z.object({ ms: z.number().min(100).max(3e4).describe("Milliseconds to wait") }),
+      mutates: false,
+      dryResult: ({ ms }) => ({ waited: ms, mode: "dry-run" }),
       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({
+    wait_for_selector: makePageTool(ctx, {
+      name: "wait_for_selector",
       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")
       }),
+      mutates: false,
+      pageCheck: "locator",
+      dryResult: ({ selector }) => ({ found: selector, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        if (el?.waitFor) await el.waitFor({ state: state ?? "visible" });
+        return { found: selector, state: state ?? "visible" };
       }
     }),
-    navigate: tool({
+    navigate: makePageTool(ctx, {
+      name: "navigate",
       description: "Navigate to a URL",
       inputSchema: z.object({ url: z.string().describe("URL to navigate to") }),
+      pageCheck: "goto",
+      dryResult: ({ url }) => ({ navigated: url, mode: "dry-run" }),
       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 };
-        }
+        await page.goto(url);
+        return { navigated: url };
       }
     }),
-    go_back: tool({
+    go_back: makePageTool(ctx, {
+      name: "go_back",
       description: "Go back in browser history",
       inputSchema: z.object({}),
+      pageCheck: "goBack",
+      dryResult: () => ({ action: "back", mode: "dry-run" }),
       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 };
-        }
+        await page.goBack();
+        return { action: "back" };
       }
     }),
-    reload: tool({
+    reload: makePageTool(ctx, {
+      name: "reload",
       description: "Reload the current page",
       inputSchema: z.object({}),
+      pageCheck: "reload",
+      dryResult: () => ({ action: "reload", mode: "dry-run" }),
       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 };
-        }
+        await page.reload();
+        return { action: "reload" };
       }
     }),
     // === Inspection Tools ===
@@ -613,8 +415,7 @@ function createAgenticTools(params) {
       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`);
+        params.actionsRun.push("snapshot");
         if (config.dryRun) return { tree: null, mode: "dry-run" };
         if (!page) return { error: "Page unavailable" };
         let tree;
@@ -624,22 +425,20 @@ function createAgenticTools(params) {
             tree = await page.accessibility.snapshot();
           }
         } catch (err) {
-          log(`accessibility snapshot error: ${err instanceof Error ? err.message : String(err)}`);
+          if (params.debug) {
+            console.log(`[canary][debug] accessibility snapshot error: ${errMsg(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 (params.debug) {
+              console.log(`[canary][debug] HTML fallback error: ${errMsg(err)}`);
+            }
           }
         }
-        if (!tree && !html) {
-          return { error: "Could not get page content" };
-        }
-        log(`snapshot succeeded`);
+        if (!tree && !html) return { error: "Could not get page content" };
         const sanitizedTree = sanitizeUnknown(tree, maxPayloadBytes);
         const sanitizedHtml = html ? truncate(sanitizeString(html), maxPayloadBytes) : void 0;
         return { tree: sanitizedTree, html: sanitizedHtml };
@@ -651,8 +450,7 @@ function createAgenticTools(params) {
         fullPage: z.boolean().optional().describe("Whether to capture the full page")
       }),
       execute: async ({ fullPage }) => {
-        track("screenshot");
-        log(`screenshot called fullPage=${fullPage}`);
+        params.actionsRun.push("screenshot");
         if (config.dryRun) return { screenshot: void 0, mode: "dry-run" };
         if (!page?.screenshot) return { error: "Page unavailable" };
         try {
@@ -662,63 +460,44 @@ function createAgenticTools(params) {
           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 };
+          return { screenshot: `data:image/png;base64,${truncate(base64, maxPayloadBytes)}` };
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          log(`screenshot error: ${msg}`);
-          return { error: msg };
+          return { error: errMsg(err) };
         }
       }
     }),
-    get_text: tool({
+    get_text: makePageTool(ctx, {
+      name: "get_text",
       description: "Get the text content of an element",
       inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      mutates: false,
+      pageCheck: "locator",
+      dryResult: () => ({ text: null, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        const text = el?.textContent ? await el.textContent() : null;
+        const sanitized = text ? truncate(sanitizeString(text), maxPayloadBytes) : text;
+        return { text: sanitized };
       }
     }),
-    is_visible: tool({
+    is_visible: makePageTool(ctx, {
+      name: "is_visible",
       description: "Check if an element is visible",
       inputSchema: z.object({ selector: z.string().describe("CSS or Playwright selector") }),
+      mutates: false,
+      pageCheck: "locator",
+      dryResult: () => ({ visible: false, mode: "dry-run" }),
       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 };
-        }
+        const el = page.locator(selector);
+        const visible = el?.isVisible ? await el.isVisible() : false;
+        return { visible };
       }
     }),
     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`);
+        params.actionsRun.push("evaluate");
         if (!config.allowEvaluate) return { error: "evaluate_disabled" };
         if (violatesCodeDenylist(script)) return { error: "evaluate_blocked" };
         if (config.dryRun) return { result: null, mode: "dry-run" };
@@ -726,25 +505,19 @@ function createAgenticTools(params) {
         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 };
+          return { error: errMsg(err) };
         }
       }
     }),
-    // === 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}`);
+        params.actionsRun.push("run_playwright_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" };
@@ -753,12 +526,9 @@ ${code}`);
           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 };
+          return { executed: false, error: errMsg(err) };
         }
       }
     }),
@@ -770,8 +540,7 @@ ${code}`);
         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}"`);
+        params.actionsRun.push("mark_complete");
         if (!config.dryRun) {
           complete = true;
           completionReason = reason;
@@ -788,6 +557,56 @@ ${code}`);
     getSummary: () => completionSummary
   };
 }
+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}` : "")
+    );
+  }
+}
+
+// src/runner/healer-prompt.ts
+function resolveMode(config) {
+  if (config.dryRun) return "dry-run";
+  if (config.warnOnly) return "warn";
+  return "full";
+}
+function truncate2(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max) + "...";
+}
+function safeJson2(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 function buildSystemPrompt(testContext, config) {
   const testInfo = testContext.testFile ? `
 ## Test Context
@@ -900,63 +719,6 @@ CORRECT:
 
 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(
@@ -966,7 +728,7 @@ function buildInitialMessages(testContext, failure, initial) {
     parts.push(
       `Full test source (truncated/redacted):
 \`\`\`typescript
-${truncate(testContext.testSource, 15e3)}
+${truncate2(testContext.testSource, 15e3)}
 \`\`\``
     );
   }
@@ -975,17 +737,17 @@ ${truncate(testContext.testSource, 15e3)}
   if (initial.snapshot) {
     parts.push(`Initial accessibility snapshot (sanitized):
 \`\`\`json
-${truncate(safeJson(initial.snapshot), 8e3)}
+${truncate2(safeJson2(initial.snapshot), 8e3)}
 \`\`\``);
   }
   if (initial.html) {
     parts.push(`HTML fallback (sanitized):
 \`\`\`html
-${truncate(initial.html, 4e3)}
+${truncate2(initial.html, 4e3)}
 \`\`\``);
   }
   if (initial.screenshot) {
-    parts.push(`Screenshot (base64 data URL, truncated): ${truncate(initial.screenshot, 12e3)}`);
+    parts.push(`Screenshot (base64 data URL, truncated): ${truncate2(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") }];
@@ -1007,7 +769,7 @@ async function buildInitialPageContext(page, config) {
     try {
       const html = await page.evaluate("document.body.innerHTML");
       if (html) {
-        result.html = truncate(sanitizeString(html), maxPayloadBytes);
+        result.html = truncate2(sanitizeString(html), maxPayloadBytes);
       }
     } catch {
     }
@@ -1018,23 +780,133 @@ async function buildInitialPageContext(page, config) {
       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)}`;
+        result.screenshot = `data:image/png;base64,${truncate2(base64, maxPayloadBytes)}`;
       }
     } catch {
     }
   }
   return result;
 }
-function truncate(value, max) {
-  if (value.length <= max) return value;
-  return value.slice(0, max) + "...";
+
+// 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" };
 }
-function safeJson(value) {
+async function executeHealActions(decision, failure, execCtx) {
+  const config = loadCanaryConfig();
+  const started = Date.now();
+  const mode = resolveMode2(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 {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+    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,
+    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 resolveMode2(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 sanitizeString(value) {
   let result = value;
@@ -1046,7 +918,7 @@ function sanitizeString(value) {
 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);
+    return truncate3(sanitizeString(value), maxPayloadBytes);
   }
   if (typeof value === "number" || typeof value === "boolean") return value;
   if (typeof value === "object") {
@@ -1067,6 +939,343 @@ function sanitizeUnknown(value, maxPayloadBytes, seen = /* @__PURE__ */ new Weak
 function violatesCodeDenylist(code) {
   return CODE_DENY_PATTERNS.some((p) => p.test(code));
 }
+function truncate3(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max) + "...";
+}
+
+// src/runner/healing-helpers.ts
+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 wrapExpect(expectImpl, options) {
+  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,
+            debug: options.debug
+          });
+        }
+        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, options) {
+  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, options, target);
+          };
+        }
+        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),
+              debug: options.debug
+            });
+          };
+        }
+      }
+      return value;
+    }
+  });
+}
+function wrapLocator(locator, options, page) {
+  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,
+            invoke: () => value.apply(target, args),
+            debug: options.debug
+          });
+        };
+      }
+      if (typeof prop === "string" && LOCATOR_CHAIN_METHODS.has(prop) && typeof value === "function") {
+        return (...args) => wrapLocator(value.apply(target, args), options, page);
+      }
+      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 (ctx.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 testContext = getTestContext();
+    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 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.healed) {
+      if (ctx.debug) {
+        console.log(`[canary][debug] healed via AI tool for action=${ctx.action}`);
+      }
+      recordHealingEvent({ ...summaryBase, healed: true });
+      return void 0;
+    }
+    if (outcome.shouldRetryOriginal) {
+      try {
+        const retried = await Promise.resolve(ctx.invoke());
+        if (ctx.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 (ctx.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 testContextMatcher = 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: testContextMatcher?.testFile,
+      testTitle: testContextMatcher?.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 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;
+}
+function loadTestSource(filePath) {
+  if (!filePath) return void 0;
+  try {
+    return fs3.readFileSync(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
 
 export {
   loadCanaryConfig,
@@ -1075,7 +1284,7 @@ export {
   recordHealingEvent,
   markPatched,
   alreadyPatched,
-  classifyFailure,
-  executeHealActions
+  wrapExpect,
+  wrapPage
 };
-//# sourceMappingURL=chunk-ROTCL5WO.js.map
+//# sourceMappingURL=chunk-TO66FC4R.js.map