assuremind 1.0.2 → 1.1.1

package/dist/cli/index.js

@@ -140,7 +140,7 @@ var init_config = __esm({
     });
     HealingConfigSchema = import_zod.z.object({
       enabled: import_zod.z.boolean(),
-      maxLevel: import_zod.z.number().int().min(1).max(6),
+      maxLevel: import_zod.z.number().int().min(1).max(5),
       dailyBudget: import_zod.z.number().positive(),
       autoPR: import_zod.z.boolean()
     });
@@ -185,7 +185,39 @@ var init_config = __esm({
       profiles: import_zod.z.array(EnvironmentProfileSchema).default([]),
       activeProfile: import_zod.z.string().optional(),
       /** Playwright device descriptor name for emulation (e.g. 'iPhone 15 Pro'). */
-      device: import_zod.z.string().optional()
+      device: import_zod.z.string().optional(),
+      /**
+       * Playwright MCP integration for AI-sighted code generation.
+       *
+       * CI/CD strategy (default):
+       *   - MCP ON for code generation  → AI sees real page elements → 90-95% selector accuracy
+       *   - MCP OFF for test execution  → runner executes pre-generated code, no MCP overhead
+       *
+       * MCP is ONLY used during generation (SmartRouter, Studio, API generate endpoints).
+       * The test runner (engine/runner.ts → code-runner.ts → AsyncFunction) never touches MCP —
+       * it simply executes the pre-generated Playwright code as-is.
+       */
+      mcp: import_zod.z.object({
+        /** Enable MCP-enhanced generation (real page snapshots for AI). ON by default. */
+        enabled: import_zod.z.boolean(),
+        /** Run MCP browser in headless mode. */
+        headless: import_zod.z.boolean(),
+        /** Two-phase: execute action via MCP first, then convert to script. */
+        actThenScript: import_zod.z.boolean(),
+        /** Pre-run element validation using MCP snapshots. */
+        proactiveHealing: import_zod.z.boolean(),
+        /** Timeout per MCP tool call in ms. */
+        actionTimeout: import_zod.z.number().int().positive(),
+        /** Idle timeout before MCP browser auto-disconnects in ms. */
+        idleTimeout: import_zod.z.number().int().positive()
+      }).default({
+        enabled: true,
+        headless: true,
+        actThenScript: false,
+        proactiveHealing: false,
+        actionTimeout: 15e3,
+        idleTimeout: 3e4
+      })
     });
     DEFAULT_CONFIG = {
       baseUrl: "http://localhost:3000",
@@ -218,7 +250,15 @@ var init_config = __esm({
         json: true
       },
       studioPort: 4400,
-      profiles: []
+      profiles: [],
+      mcp: {
+        enabled: true,
+        headless: true,
+        actThenScript: false,
+        proactiveHealing: false,
+        actionTimeout: 15e3,
+        idleTimeout: 3e4
+      }
     };
   }
 });
@@ -331,7 +371,7 @@ var init_init = __esm({
       { dest: ".gitignore", template: "gitignore" },
       { dest: "autotest.config.ts", template: "autotest.config.ts" },
       { dest: "variables/global.json", template: "global-variables.json" },
-      { dest: "AUTOMIND.md", template: "AUTOMIND.md" },
+      { dest: "ASSUREMIND.md", template: "ASSUREMIND.md" },
       { dest: "docs/GETTING-STARTED.md", template: "docs/GETTING-STARTED.md" },
       { dest: "docs/STUDIO.md", template: "docs/STUDIO.md" },
       { dest: "docs/CLI-REFERENCE.md", template: "docs/CLI-REFERENCE.md" }
@@ -923,18 +963,24 @@ var init_static = __esm({
 function sendError(reply, statusCode, message, err) {
   const code = err instanceof AssuremindError ? err.code : "INTERNAL_ERROR";
   const detail = err instanceof Error ? err.message : err !== void 0 ? String(err) : void 0;
-  if (statusCode >= 500) {
+  const isConfigError = err instanceof ConfigError || CONFIG_ERROR_CODES.has(code);
+  const effectiveStatus = isConfigError ? 422 : statusCode;
+  const isJiraConfig = detail?.includes("JIRA_NOT_CONFIGURED") || detail?.includes("Jira not configured");
+  const isXrayConfig = detail?.includes("XRAY_NOT_CONFIGURED") || detail?.includes("Xray not configured");
+  const featureHint = isJiraConfig ? "JIRA_NOT_CONFIGURED" : isXrayConfig ? "XRAY_NOT_CONFIGURED" : isConfigError ? "AI_NOT_CONFIGURED" : void 0;
+  if (effectiveStatus >= 500) {
     logger5.error({ err }, message);
   } else {
     logger5.debug({ err }, message);
   }
-  return reply.status(statusCode).send({
+  return reply.status(effectiveStatus).send({
     error: message,
     ...detail && detail !== message && { detail },
-    code
+    code,
+    ...featureHint && { featureHint }
   });
 }
-var logger5;
+var logger5, CONFIG_ERROR_CODES;
 var init_utils2 = __esm({
   "src/server/utils.ts"() {
     "use strict";
@@ -942,6 +988,12 @@ var init_utils2 = __esm({
     init_errors();
     init_logger();
     logger5 = createChildLogger("server");
+    CONFIG_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ENV_VALIDATION_FAILED",
+      "PROVIDER_ENV_MISSING",
+      "UNKNOWN_PROVIDER",
+      "CONFIG_ERROR"
+    ]);
   }
 });
 
@@ -987,6 +1039,48 @@ async function configRoutes(fastify) {
       return reply.send({ provider: "unknown", model: "unknown" });
     }
   });
+  fastify.get("/config/status", async (_req, reply) => {
+    const env = tryGetEnv();
+    const jiraBaseUrl = process.env["JIRA_BASE_URL"];
+    const jiraEmail = process.env["JIRA_EMAIL"];
+    const jiraApiToken = process.env["JIRA_API_TOKEN"];
+    const jiraConfigured = !!(jiraBaseUrl && jiraEmail && jiraApiToken);
+    const xrayProjectKey = process.env["XRAY_PROJECT_KEY"];
+    const xrayConfigured = jiraConfigured && !!xrayProjectKey;
+    return reply.send({
+      ai: {
+        configured: !!env,
+        provider: env ? String(env.AI_PROVIDER) : null
+      },
+      jira: {
+        configured: jiraConfigured
+      },
+      xray: {
+        configured: xrayConfigured
+      }
+    });
+  });
+  fastify.get("/mcp/status", async (_req, reply) => {
+    try {
+      const config = await readConfig(rootDir);
+      const mcpEnabled = config.mcp?.enabled ?? false;
+      let packageAvailable = false;
+      try {
+        require.resolve("@playwright/mcp");
+        packageAvailable = true;
+      } catch {
+      }
+      return reply.send({
+        enabled: mcpEnabled,
+        packageAvailable,
+        headless: config.mcp?.headless ?? true,
+        actThenScript: config.mcp?.actThenScript ?? false,
+        proactiveHealing: config.mcp?.proactiveHealing ?? false
+      });
+    } catch (err) {
+      return sendError(reply, 500, "Failed to check MCP status", err);
+    }
+  });
 }
 var PatchConfigSchema;
 var init_config2 = __esm({
@@ -2398,8 +2492,308 @@ var init_batch_processor = __esm({
   }
 });
 
+// src/mcp/snapshot-parser.ts
+function parseSnapshot(raw) {
+  if (!raw || !raw.trim()) {
+    return { title: "", interactiveElements: "", accessibilityTree: "" };
+  }
+  const lines = raw.split("\n");
+  let title = "";
+  const elements = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === "-") continue;
+    const pageMatch = trimmed.match(/^-?\s*Page\s+"([^"]*)"/i);
+    if (pageMatch) {
+      title = pageMatch[1] ?? "";
+      continue;
+    }
+    const elementMatch = trimmed.match(
+      /^-?\s*(\w+)\s+"([^"]*)"(?:\s+\[([^\]]*)\])?/
+    );
+    if (!elementMatch) continue;
+    const role = elementMatch[1].toLowerCase();
+    let name = elementMatch[2] ?? "";
+    const attrs = elementMatch[3] ?? "";
+    if (name.length > MAX_TEXT_LEN) {
+      name = name.slice(0, MAX_TEXT_LEN - 1) + "\u2026";
+    }
+    if (!name && !attrs) continue;
+    const isInteractive = INTERACTIVE_ROLES.has(role);
+    const isContext = CONTEXT_ROLES.has(role);
+    if (isInteractive || isContext) {
+      elements.push({ role, name, attrs, isInteractive });
+    }
+  }
+  const interactive = elements.filter((e) => e.isInteractive);
+  const context = elements.filter((e) => !e.isInteractive);
+  const sorted = [...interactive, ...context].slice(0, MAX_ELEMENTS);
+  const interactiveLines = sorted.map((e) => {
+    let line = `${e.role} "${e.name}"`;
+    if (e.attrs) line += ` [${e.attrs}]`;
+    return line;
+  });
+  return {
+    title,
+    interactiveElements: interactiveLines.join("\n"),
+    accessibilityTree: raw.slice(0, 8e3)
+    // Trim full tree for context window
+  };
+}
+var MAX_ELEMENTS, MAX_TEXT_LEN, INTERACTIVE_ROLES, CONTEXT_ROLES;
+var init_snapshot_parser = __esm({
+  "src/mcp/snapshot-parser.ts"() {
+    "use strict";
+    init_cjs_shims();
+    MAX_ELEMENTS = 120;
+    MAX_TEXT_LEN = 80;
+    INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+      "button",
+      "link",
+      "textbox",
+      "checkbox",
+      "radio",
+      "combobox",
+      "listbox",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "searchbox",
+      "slider",
+      "spinbutton",
+      "switch",
+      "tab",
+      "treeitem"
+    ]);
+    CONTEXT_ROLES = /* @__PURE__ */ new Set([
+      "heading",
+      "img",
+      "navigation",
+      "dialog",
+      "alert",
+      "alertdialog",
+      "status",
+      "progressbar",
+      "table",
+      "row",
+      "cell",
+      "columnheader",
+      "rowheader"
+    ]);
+  }
+});
+
+// src/ai/prompts/mcp-action.ts
+function buildMcpActionPrompt(instruction, snapshot) {
+  const user = `Current page accessibility snapshot:
+${snapshot.slice(0, 6e3)}
+
+Step to execute: "${instruction}"
+
+Plan the MCP browser actions needed. Return JSON with the "actions" array.`;
+  return { system: SYSTEM_PROMPT, user };
+}
+var SYSTEM_PROMPT;
+var init_mcp_action = __esm({
+  "src/ai/prompts/mcp-action.ts"() {
+    "use strict";
+    init_cjs_shims();
+    SYSTEM_PROMPT = `You are a browser automation expert. Given a test step instruction and an accessibility snapshot of the current page, plan the exact browser actions needed to accomplish the step.
+
+\u2501\u2501\u2501 OUTPUT FORMAT \u2501\u2501\u2501
+Return ONLY valid JSON \u2014 no markdown, no explanations.
+
+{
+  "actions": [
+    { "tool": "browser_click", "args": { "element": "button 'Login'", "ref": "s1e4" } },
+    { "tool": "browser_type", "args": { "element": "textbox 'Username'", "ref": "s1e2", "text": "Admin" } }
+  ]
+}
+
+\u2501\u2501\u2501 AVAILABLE TOOLS \u2501\u2501\u2501
+browser_click     \u2014 { element: string, ref: string }           Click an element
+browser_type      \u2014 { element: string, ref: string, text: string }  Type text into a field
+browser_select_option \u2014 { element: string, ref: string, values: string[] }  Select dropdown option
+browser_hover     \u2014 { element: string, ref: string }           Hover over element
+browser_press_key \u2014 { key: string }                            Press a keyboard key (Enter, Tab, Escape...)
+browser_navigate  \u2014 { url: string }                            Navigate to a URL
+
+\u2501\u2501\u2501 RULES \u2501\u2501\u2501
+1. Use EXACT element descriptions and refs from the accessibility snapshot
+2. For "enter/type/fill" instructions \u2192 use browser_type
+3. For "click/press/select" instructions \u2192 use browser_click
+4. For navigation instructions \u2192 use browser_navigate
+5. Keep actions minimal \u2014 only what's needed for the instruction
+6. Order matters \u2014 actions execute sequentially
+7. For dropdown/select instructions \u2192 use browser_select_option
+8. If a step requires pressing Enter after typing \u2192 add browser_press_key with key "Enter"
+
+\u2501\u2501\u2501 ELEMENT MATCHING \u2501\u2501\u2501
+Match elements from the snapshot by their role and name:
+  - "Enter username" \u2192 find textbox with name containing "username" or "user"
+  - "Click Login button" \u2192 find button with name containing "Login"
+  - "Select country" \u2192 find combobox/listbox with name containing "country"
+
+Always use the ref value from the snapshot (e.g., "s1e4") \u2014 this is the unique element identifier.`;
+  }
+});
+
+// src/mcp/action-mapper.ts
+async function planMcpActions(provider, instruction, snapshot) {
+  try {
+    const { system, user } = buildMcpActionPrompt(instruction, snapshot);
+    const fakeContext = {
+      url: "",
+      title: "",
+      interactiveElements: "",
+      htmlSnapshot: "",
+      previousSteps: [{ instruction: "SYSTEM", code: system }],
+      variables: {}
+    };
+    const raw = await provider.generateCode(`[MCP_ACTION_PLAN] ${user}`, fakeContext);
+    const cleaned = raw.replace(/```json?\s*/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.actions || !Array.isArray(parsed.actions)) {
+      logger11.warn("AI returned invalid action plan \u2014 no actions array");
+      return [];
+    }
+    const actions = parsed.actions.filter(
+      (a) => a.tool && typeof a.tool === "string" && a.args
+    );
+    logger11.info({ instruction, actionCount: actions.length }, "MCP action plan created");
+    return actions;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger11.warn({ err: msg, instruction }, "Failed to plan MCP actions");
+    return [];
+  }
+}
+var logger11;
+var init_action_mapper = __esm({
+  "src/mcp/action-mapper.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_mcp_action();
+    init_logger();
+    logger11 = createChildLogger("action-mapper");
+  }
+});
+
+// src/mcp/action-to-script.ts
+function convertActionsToScript(actions) {
+  const lines = [];
+  for (const action of actions) {
+    const line = convertSingleAction(action);
+    if (line) {
+      lines.push(line);
+    }
+  }
+  if (lines.length === 0) {
+    logger12.warn("No actions could be converted to script");
+    return "";
+  }
+  return lines.join("\n");
+}
+function convertSingleAction(action) {
+  const args = action.args ?? {};
+  switch (action.tool) {
+    case "browser_navigate": {
+      const url = String(args.url ?? "");
+      if (!url) return null;
+      return `await page.goto('${escapeStr(url)}', { waitUntil: 'networkidle' });`;
+    }
+    case "browser_click": {
+      const locator = elementToLocator(args);
+      if (!locator) return null;
+      return `await ${locator}.click();`;
+    }
+    case "browser_type": {
+      const locator = elementToLocator(args);
+      const text = String(args.text ?? "");
+      if (!locator || !text) return null;
+      return `await ${locator}.fill('${escapeStr(text)}');`;
+    }
+    case "browser_select_option": {
+      const locator = elementToLocator(args);
+      const values = args.values;
+      if (!locator || !values?.length) return null;
+      const valStr = values.map((v) => `'${escapeStr(v)}'`).join(", ");
+      return `await ${locator}.selectOption([${valStr}]);`;
+    }
+    case "browser_hover": {
+      const locator = elementToLocator(args);
+      if (!locator) return null;
+      return `await ${locator}.hover();`;
+    }
+    case "browser_press_key": {
+      const key = String(args.key ?? "");
+      if (!key) return null;
+      return `await page.keyboard.press('${escapeStr(key)}');`;
+    }
+    case "browser_wait": {
+      const time = Number(args.time ?? 1e3);
+      return `await page.waitForTimeout(${time});`;
+    }
+    default: {
+      logger12.debug({ tool: action.tool }, "Unknown MCP action \u2014 skipping");
+      return null;
+    }
+  }
+}
+function elementToLocator(args) {
+  const element = String(args.element ?? "");
+  if (!element) return null;
+  const match = element.match(/^(\w+)\s+['"]([^'"]*)['"]/);
+  if (match) {
+    const role = match[1].toLowerCase();
+    const name = match[2];
+    const roleMap = {
+      button: "button",
+      link: "link",
+      textbox: "textbox",
+      checkbox: "checkbox",
+      radio: "radio",
+      combobox: "combobox",
+      listbox: "listbox",
+      menuitem: "menuitem",
+      option: "option",
+      searchbox: "searchbox",
+      slider: "slider",
+      spinbutton: "spinbutton",
+      switch: "switch",
+      tab: "tab",
+      heading: "heading"
+    };
+    const pwRole = roleMap[role];
+    if (pwRole && name) {
+      return `page.getByRole('${pwRole}', { name: '${escapeStr(name)}' })`;
+    }
+    if ((role === "textbox" || role === "searchbox") && name) {
+      return `page.getByLabel('${escapeStr(name)}')`;
+    }
+  }
+  const textMatch = element.match(/['"]([^'"]+)['"]/);
+  if (textMatch) {
+    return `page.getByText('${escapeStr(textMatch[1])}')`;
+  }
+  return null;
+}
+function escapeStr(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+var logger12;
+var init_action_to_script = __esm({
+  "src/mcp/action-to-script.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    logger12 = createChildLogger("action-to-script");
+  }
+});
+
 // src/ai/smart-router.ts
-var logger11, SmartRouter;
+var logger13, SmartRouter;
 var init_smart_router = __esm({
   "src/ai/smart-router.ts"() {
     "use strict";
@@ -2411,7 +2805,10 @@ var init_smart_router = __esm({
     init_sanitize();
     init_logger();
     init_step_type_detector();
-    logger11 = createChildLogger("smart-router");
+    init_snapshot_parser();
+    init_action_mapper();
+    init_action_to_script();
+    logger13 = createChildLogger("smart-router");
     SmartRouter = class {
       templateEngine;
       cache;
@@ -2419,6 +2816,8 @@ var init_smart_router = __esm({
       batchProcessor;
       primaryProvider;
       fastProvider;
+      mcpSession;
+      actThenScript;
       stats = {
         template: 0,
         cache: 0,
@@ -2430,6 +2829,8 @@ var init_smart_router = __esm({
       constructor(config) {
         this.primaryProvider = config.primaryProvider;
         this.fastProvider = config.fastProvider ?? null;
+        this.mcpSession = config.mcpSession ?? null;
+        this.actThenScript = config.actThenScript ?? false;
         this.cache = config.cache ?? new CodeCache();
         this.templateEngine = new TemplateEngine();
         this.classifier = new ComplexityClassifier();
@@ -2443,7 +2844,7 @@ var init_smart_router = __esm({
           const templateCode = this.templateEngine.tryMatch(instruction);
           if (templateCode !== null) {
             this.stats.template++;
-            logger11.debug({ instruction }, "Template match");
+            logger13.debug({ instruction }, "Template match");
             return { code: fixAntiPatterns(templateCode), strategy: "template", cost: 0, model: "local" };
           }
         }
@@ -2451,16 +2852,26 @@ var init_smart_router = __esm({
         const cached = this.cache.get(cacheKey);
         if (cached !== null) {
           this.stats.cache++;
-          logger11.debug({ instruction }, "Cache hit");
+          logger13.debug({ instruction }, "Cache hit");
           const fixed = fixButtonSelectors(instruction, fixAntiPatterns(cached.code));
           return { code: fixed, strategy: "cache", cost: 0, model: "local" };
         }
+        const enrichedContext = this.mcpSession ? await this.enrichWithMcp(instruction, pageContext) : pageContext;
+        if (this.actThenScript && this.mcpSession && enrichedContext.accessibilityTree) {
+          const actResult = await this.tryActThenScript(instruction, enrichedContext);
+          if (actResult !== null) {
+            this.stats.primary++;
+            this.cache.set(cacheKey, actResult, pageContext.url);
+            return { code: actResult, strategy: "primary", cost: 3e-3, model: "mcp-act" };
+          }
+          logger13.debug({ instruction }, "Act-then-script failed \u2014 falling back to AI generation");
+        }
         const complexity = this.classifier.classify(instruction);
         const usesFast = this.fastProvider !== null && complexity !== "complex";
         const provider = usesFast ? this.fastProvider : this.primaryProvider;
         const strategy = usesFast ? "fast" : "primary";
-        logger11.debug({ instruction, complexity, strategy }, "AI call");
-        const code = await provider.generateCode(instruction, pageContext);
+        logger13.debug({ instruction, complexity, strategy }, "AI call");
+        const code = await provider.generateCode(instruction, enrichedContext);
         this.cache.set(cacheKey, code, pageContext.url);
         if (usesFast) {
           this.stats.fast++;
@@ -2515,6 +2926,418 @@ var init_smart_router = __esm({
       getPrimaryProvider() {
         return this.primaryProvider;
       }
+      /** Exposes the MCP session (e.g. for proactive healing or diagnostics). */
+      getMcpSession() {
+        return this.mcpSession;
+      }
+      // ─── MCP enrichment ─────────────────────────────────────────────────────────
+      /**
+       * Enrich a PageContext with live accessibility data from the MCP browser.
+       * On any failure, returns the original context unchanged (silent fallback).
+       */
+      async enrichWithMcp(_instruction, ctx) {
+        try {
+          const session = this.mcpSession;
+          if (ctx.url && (!session.currentUrl || !this.isSameOriginPath(session.currentUrl, ctx.url))) {
+            logger13.debug({ url: ctx.url }, "MCP: navigating to target URL");
+            await session.navigate(ctx.url);
+          }
+          const raw = await session.snapshot();
+          if (!raw) {
+            logger13.debug("MCP: snapshot returned null \u2014 using blind context");
+            return ctx;
+          }
+          const parsed = parseSnapshot(raw);
+          logger13.info(
+            { elements: parsed.interactiveElements.split("\n").length, title: parsed.title },
+            "MCP: enriched context with live page elements"
+          );
+          return {
+            ...ctx,
+            title: parsed.title || ctx.title,
+            interactiveElements: parsed.interactiveElements || ctx.interactiveElements,
+            accessibilityTree: parsed.accessibilityTree
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger13.warn({ err: msg }, "MCP enrichment failed \u2014 using blind context");
+          return ctx;
+        }
+      }
+      // ─── Act-then-script ───────────────────────────────────────────────────────
+      /**
+       * Two-phase generation: ask AI to plan MCP actions → execute on real browser
+       * → convert successful actions to Playwright code.
+       *
+       * Returns the generated code on success, or null to fall back to standard AI.
+       */
+      async tryActThenScript(instruction, ctx) {
+        try {
+          const session = this.mcpSession;
+          const snapshot = ctx.accessibilityTree ?? "";
+          if (!snapshot) return null;
+          const actions = await planMcpActions(this.primaryProvider, instruction, snapshot);
+          if (actions.length === 0) return null;
+          for (const action of actions) {
+            const args = action.args ?? {};
+            let result = null;
+            switch (action.tool) {
+              case "browser_click":
+                result = await session.click(String(args.element ?? ""), String(args.ref ?? ""));
+                break;
+              case "browser_type":
+                result = await session.fill(String(args.element ?? ""), String(args.ref ?? ""), String(args.text ?? ""));
+                break;
+              case "browser_select_option":
+                result = await session.selectOption(String(args.element ?? ""), String(args.ref ?? ""), args.values ?? []);
+                break;
+              case "browser_hover":
+                result = await session.hover(String(args.element ?? ""), String(args.ref ?? ""));
+                break;
+              case "browser_press_key":
+                result = await session.pressKey(String(args.key ?? ""));
+                break;
+              case "browser_navigate":
+                result = await session.navigate(String(args.url ?? ""));
+                break;
+              default:
+                logger13.debug({ tool: action.tool }, "Unknown MCP action in act-then-script");
+                continue;
+            }
+            if (result === null) {
+              logger13.debug({ tool: action.tool, instruction }, "MCP action failed during act-then-script");
+              return null;
+            }
+          }
+          const code = convertActionsToScript(actions);
+          if (!code) return null;
+          logger13.info({ instruction, actions: actions.length }, "Act-then-script succeeded");
+          return code;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger13.warn({ err: msg, instruction }, "Act-then-script failed");
+          return null;
+        }
+      }
+      isSameOriginPath(a, b) {
+        try {
+          const urlA = new URL(a);
+          const urlB = new URL(b);
+          return urlA.origin === urlB.origin && urlA.pathname === urlB.pathname;
+        } catch {
+          return a === b;
+        }
+      }
+    };
+  }
+});
+
+// src/mcp/mcp-client.ts
+var import_client, import_stdio, logger14, McpClient;
+var init_mcp_client = __esm({
+  "src/mcp/mcp-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_client = require("@modelcontextprotocol/sdk/client/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+    init_logger();
+    logger14 = createChildLogger("mcp-client");
+    McpClient = class {
+      client = null;
+      transport = null;
+      _connected = false;
+      headless;
+      actionTimeout;
+      constructor(config = {}) {
+        this.headless = config.headless ?? true;
+        this.actionTimeout = config.actionTimeout ?? 15e3;
+      }
+      // ─── Lifecycle ──────────────────────────────────────────────────────────────
+      get connected() {
+        return this._connected;
+      }
+      async connect() {
+        if (this._connected) return;
+        const args = ["@playwright/mcp@latest"];
+        if (this.headless) args.push("--headless");
+        this.transport = new import_stdio.StdioClientTransport({
+          command: "npx",
+          args
+        });
+        this.client = new import_client.Client(
+          { name: "assuremind-studio", version: "1.0.0" },
+          { capabilities: {} }
+        );
+        await this.client.connect(this.transport);
+        this._connected = true;
+        logger14.info({ headless: this.headless }, "MCP client connected");
+      }
+      async disconnect() {
+        if (!this._connected || !this.client) return;
+        try {
+          await this.client.close();
+        } catch {
+        }
+        this.client = null;
+        this.transport = null;
+        this._connected = false;
+        logger14.info("MCP client disconnected");
+      }
+      // ─── Browser Navigation ─────────────────────────────────────────────────────
+      /** Navigate to a URL and return the page snapshot. */
+      async navigate(url) {
+        return this.callTool("browser_navigate", { url });
+      }
+      /** Take an accessibility snapshot of the current page. */
+      async snapshot() {
+        return this.callTool("browser_snapshot", {});
+      }
+      // ─── Browser Actions ────────────────────────────────────────────────────────
+      /** Click an element by its accessibility ref. */
+      async click(element, ref) {
+        return this.callTool("browser_click", { element, ref });
+      }
+      /** Fill a text field by accessibility ref. */
+      async fill(element, ref, value) {
+        return this.callTool("browser_type", { element, ref, text: value });
+      }
+      /** Select an option from a dropdown. */
+      async selectOption(element, ref, values) {
+        return this.callTool("browser_select_option", { element, ref, values });
+      }
+      /** Hover over an element. */
+      async hover(element, ref) {
+        return this.callTool("browser_hover", { element, ref });
+      }
+      /** Press a keyboard key. */
+      async pressKey(key) {
+        return this.callTool("browser_press_key", { key });
+      }
+      // ─── Diagnostics ────────────────────────────────────────────────────────────
+      /** Take a screenshot (returns base64 image content). */
+      async screenshot() {
+        return this.callTool("browser_take_screenshot", {});
+      }
+      /** Get console logs from the page. */
+      async consoleLogs() {
+        return this.callTool("browser_console_messages", {});
+      }
+      /** Get network request/response log. */
+      async networkRequests() {
+        return this.callTool("browser_network_requests", {});
+      }
+      // ─── Wait helpers ───────────────────────────────────────────────────────────
+      /** Wait for a condition then return a fresh snapshot. */
+      async waitAndSnapshot(timeMs) {
+        if (timeMs) {
+          return this.callTool("browser_wait", { time: timeMs });
+        }
+        return this.callTool("browser_wait", { time: 1e3 });
+      }
+      // ─── Internal ───────────────────────────────────────────────────────────────
+      /**
+       * Call an MCP tool by name with arguments.
+       * Returns the text content on success, or null on any error/timeout.
+       */
+      async callTool(name, args) {
+        if (!this._connected || !this.client) {
+          logger14.warn({ tool: name }, "MCP callTool called but client not connected");
+          return null;
+        }
+        try {
+          const result = await Promise.race([
+            this.client.callTool({ name, arguments: args }),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error(`MCP tool "${name}" timed out after ${this.actionTimeout}ms`)), this.actionTimeout)
+            )
+          ]);
+          if (result && Array.isArray(result.content)) {
+            const textParts = result.content.filter((c) => c.type === "text").map((c) => c.text);
+            return textParts.join("\n") || null;
+          }
+          return null;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger14.warn({ tool: name, error: msg }, "MCP tool call failed");
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/mcp/mcp-session.ts
+var logger15, McpSession;
+var init_mcp_session = __esm({
+  "src/mcp/mcp-session.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_mcp_client();
+    init_logger();
+    logger15 = createChildLogger("mcp-session");
+    McpSession = class {
+      client;
+      idleTimeout;
+      idleTimer = null;
+      mutex = Promise.resolve();
+      _currentUrl = null;
+      constructor(config = {}) {
+        this.client = new McpClient(config);
+        this.idleTimeout = config.idleTimeout ?? 3e4;
+      }
+      /** The URL the MCP browser is currently on (or null if not navigated). */
+      get currentUrl() {
+        return this._currentUrl;
+      }
+      /** Whether the underlying client is connected. */
+      get connected() {
+        return this.client.connected;
+      }
+      // ─── Connection management ──────────────────────────────────────────────────
+      /** Ensure the client is connected (lazy init). */
+      async ensureConnected() {
+        this.resetIdleTimer();
+        if (!this.client.connected) {
+          await this.client.connect();
+        }
+      }
+      /**
+       * Release the session — starts the idle timer.
+       * If no new calls arrive within `idleTimeout`, the client disconnects.
+       */
+      release() {
+        this.startIdleTimer();
+      }
+      /** Force-disconnect immediately. */
+      async disconnect() {
+        this.clearIdleTimer();
+        this._currentUrl = null;
+        await this.client.disconnect();
+      }
+      // ─── Navigation ─────────────────────────────────────────────────────────────
+      /**
+       * Navigate to a URL (skips if already on that URL).
+       * Returns the accessibility snapshot after navigation.
+       */
+      async navigate(url) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          if (this._currentUrl && this.isSameUrl(this._currentUrl, url)) {
+            logger15.debug({ url }, "Already on URL \u2014 skipping navigation");
+            return this.client.snapshot();
+          }
+          const result = await this.client.navigate(url);
+          if (result !== null) {
+            this._currentUrl = url;
+          }
+          return result;
+        });
+      }
+      /** Take a fresh accessibility snapshot of the current page. */
+      async snapshot() {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.snapshot();
+        });
+      }
+      // ─── Actions (used by act-then-script — Phase 4) ───────────────────────────
+      async click(element, ref) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.click(element, ref);
+        });
+      }
+      async fill(element, ref, value) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.fill(element, ref, value);
+        });
+      }
+      async selectOption(element, ref, values) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.selectOption(element, ref, values);
+        });
+      }
+      async hover(element, ref) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.hover(element, ref);
+        });
+      }
+      async pressKey(key) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.pressKey(key);
+        });
+      }
+      // ─── Diagnostics ────────────────────────────────────────────────────────────
+      async screenshot() {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.screenshot();
+        });
+      }
+      async consoleLogs() {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.consoleLogs();
+        });
+      }
+      async networkRequests() {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.networkRequests();
+        });
+      }
+      async waitAndSnapshot(timeMs) {
+        return this.withMutex(async () => {
+          await this.ensureConnected();
+          return this.client.waitAndSnapshot(timeMs);
+        });
+      }
+      // ─── Internal helpers ───────────────────────────────────────────────────────
+      /** Simple mutex — ensures only one MCP tool call runs at a time. */
+      async withMutex(fn) {
+        let release;
+        const next = new Promise((resolve) => {
+          release = resolve;
+        });
+        const prev = this.mutex;
+        this.mutex = next;
+        await prev;
+        this.resetIdleTimer();
+        try {
+          return await fn();
+        } finally {
+          release();
+        }
+      }
+      isSameUrl(a, b) {
+        try {
+          const urlA = new URL(a);
+          const urlB = new URL(b);
+          return urlA.origin === urlB.origin && urlA.pathname === urlB.pathname;
+        } catch {
+          return a === b;
+        }
+      }
+      startIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(async () => {
+          logger15.info("MCP session idle \u2014 disconnecting");
+          await this.disconnect();
+        }, this.idleTimeout);
+      }
+      resetIdleTimer() {
+        this.clearIdleTimer();
+      }
+      clearIdleTimer() {
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = null;
+        }
+      }
     };
   }
 });
@@ -2575,12 +3398,21 @@ function buildStepToCodePrompt(instruction, context) {
   const prevSteps = context.previousSteps.length > 0 ? context.previousSteps.slice(-5).map((s, i) => `  ${i + 1}. "${s.instruction}"
      ${s.code}`).join("\n") : "  None";
   const vars = Object.keys(context.variables).length > 0 ? Object.entries(context.variables).map(([k, v]) => `  {{${k}}} = ${v}`).join("\n") : "  None";
+  const hasLiveElements = !!(context.interactiveElements && context.accessibilityTree);
+  const elementsSection = hasLiveElements ? `Interactive elements on page (LIVE from actual page \u2014 use exact roles/names):
+${context.interactiveElements}
+
+\u26A0\uFE0F The elements above are LIVE from the actual page via accessibility snapshot.
+Use exact roles and names from these elements. Do NOT guess selectors.` : `Interactive elements on page (use these to pick selectors):
+${context.interactiveElements || "  None captured"}`;
+  const accessibilitySection = context.accessibilityTree ? `
+Full accessibility tree (for additional context):
+${context.accessibilityTree.slice(0, 4e3)}` : "";
   const user = `Current page:
   URL:   ${context.url}
   Title: ${context.title}
 
-Interactive elements on page (use these to pick selectors):
-${context.interactiveElements || "  None captured"}
+${elementsSection}${accessibilitySection}
 
 Previous steps already done (for context):
 ${prevSteps}
@@ -2589,14 +3421,14 @@ Runtime variables:
 ${vars}
 
 Step to implement: "${instruction}"`;
-  return { system: SYSTEM_PROMPT, user };
+  return { system: SYSTEM_PROMPT2, user };
 }
-var SYSTEM_PROMPT;
+var SYSTEM_PROMPT2;
 var init_step_to_code = __esm({
   "src/ai/prompts/step-to-code.ts"() {
     "use strict";
     init_cjs_shims();
-    SYSTEM_PROMPT = `You are a Playwright test automation expert. Convert plain English test steps into executable Playwright TypeScript code.
+    SYSTEM_PROMPT2 = `You are a Playwright test automation expert. Convert plain English test steps into executable Playwright TypeScript code.
 
 \u2501\u2501\u2501 OUTPUT RULES \u2501\u2501\u2501
 1. Return ONLY raw executable code \u2014 no markdown, no \`\`\`, no explanations
@@ -2742,9 +3574,9 @@ Generate a JSON test suite following this exact schema:
 ${SCHEMA_GUIDE}
 
 Important: return only the JSON object, nothing else.`;
-  return { system: SYSTEM_PROMPT2, user };
+  return { system: SYSTEM_PROMPT3, user };
 }
-var OUTLINE_SYSTEM, OUTLINE_SCHEMA, STEPS_SYSTEM, STEPS_SCHEMA, SYSTEM_PROMPT2, SCHEMA_GUIDE;
+var OUTLINE_SYSTEM, OUTLINE_SCHEMA, STEPS_SYSTEM, STEPS_SCHEMA, SYSTEM_PROMPT3, SCHEMA_GUIDE;
 var init_story_to_suite = __esm({
   "src/ai/prompts/story-to-suite.ts"() {
     "use strict";
@@ -2780,7 +3612,7 @@ Rules:
     { "instruction": "Verify the Dashboard heading is visible" }
   ]
 }`;
-    SYSTEM_PROMPT2 = `You are a QA test planning expert. Convert user stories into structured test suites.
+    SYSTEM_PROMPT3 = `You are a QA test planning expert. Convert user stories into structured test suites.
 
 RULES:
 1. Return ONLY valid JSON \u2014 no markdown, no explanations, no code fences
@@ -2812,7 +3644,25 @@ RULES:
 });
 
 // src/ai/prompts/self-heal.ts
-function buildSelfHealPrompt(instruction, failedCode, error, context) {
+function buildSelfHealPrompt(instruction, failedCode, error, context, mcpDiagnostics) {
+  const hasLiveElements = !!(context.interactiveElements && context.accessibilityTree);
+  const elementsSection = hasLiveElements ? `Current interactive elements (LIVE from page snapshot \u2014 use exact names):
+${context.interactiveElements}` : `Current interactive elements:
+${context.interactiveElements || "  None captured"}`;
+  const accessibilitySection = context.accessibilityTree ? `
+Accessibility tree:
+${context.accessibilityTree.slice(0, 3e3)}` : "";
+  let diagnosticsSection = "";
+  if (mcpDiagnostics?.consoleLogs) {
+    diagnosticsSection += `
+Browser console logs (recent errors/warnings):
+${mcpDiagnostics.consoleLogs.slice(0, 1500)}`;
+  }
+  if (mcpDiagnostics?.networkRequests) {
+    diagnosticsSection += `
+Recent network requests:
+${mcpDiagnostics.networkRequests.slice(0, 1500)}`;
+  }
   const user = `A test step has failed. Generate replacement Playwright code.
 
 Original instruction: "${instruction}"
@@ -2827,21 +3677,20 @@ Current page state:
   URL:   ${context.url}
   Title: ${context.title}
 
-Current interactive elements:
-${context.interactiveElements || "  None captured"}
+${elementsSection}
 
 HTML snapshot (partial):
-${context.htmlSnapshot.slice(0, 3e3)}
+${context.htmlSnapshot.slice(0, 3e3)}${accessibilitySection}${diagnosticsSection}
 
 Generate new Playwright code that achieves: "${instruction}"`;
-  return { system: SYSTEM_PROMPT3, user };
+  return { system: SYSTEM_PROMPT4, user };
 }
-var SYSTEM_PROMPT3;
+var SYSTEM_PROMPT4;
 var init_self_heal = __esm({
   "src/ai/prompts/self-heal.ts"() {
     "use strict";
     init_cjs_shims();
-    SYSTEM_PROMPT3 = `You are a Playwright test self-healing expert. A test step has failed due to an infrastructure issue (broken selector, element moved, DOM changed) and you must generate new code that will work with the current page state.
+    SYSTEM_PROMPT4 = `You are a Playwright test self-healing expert. A test step has failed due to an infrastructure issue (broken selector, element moved, DOM changed) and you must generate new code that will work with the current page state.
 
 RULES:
 1. Return ONLY raw executable code \u2014 no markdown, no explanations, no code fences
@@ -2862,14 +3711,23 @@ RULES:
 function buildBatchGeneratePrompt(steps, context) {
   const stepsList = steps.map((s) => `  ${s.index}. "${s.instruction}"`).join("\n");
   const vars = Object.keys(context.variables).length > 0 ? Object.entries(context.variables).map(([k, v]) => `  {{${k}}} = ${v}`).join("\n") : "  None";
+  const hasLiveElements = !!(context.interactiveElements && context.accessibilityTree);
+  const elementsSection = hasLiveElements ? `Interactive elements on page (LIVE from actual page \u2014 use exact roles/names):
+${context.interactiveElements}
+
+\u26A0\uFE0F The elements above are LIVE from the actual page via accessibility snapshot.
+Use exact roles and names from these elements. Do NOT guess selectors.` : `Interactive elements on page (use to choose the right selector):
+${context.interactiveElements || "  None captured"}`;
+  const accessibilitySection = context.accessibilityTree ? `
+Full accessibility tree (for additional context):
+${context.accessibilityTree.slice(0, 4e3)}` : "";
   const user = `Generate Playwright code for these ${steps.length} test steps.
 
 Current page:
   URL:   ${context.url}
   Title: ${context.title}
 
-Interactive elements on page (use to choose the right selector):
-${context.interactiveElements || "  None captured"}
+${elementsSection}${accessibilitySection}
 
 Runtime variables:
 ${vars}
@@ -2886,14 +3744,14 @@ Return JSON:
 }
 
 Return one result per step. Include ALL ${steps.length} steps.`;
-  return { system: SYSTEM_PROMPT4, user };
+  return { system: SYSTEM_PROMPT5, user };
 }
-var SYSTEM_PROMPT4;
+var SYSTEM_PROMPT5;
 var init_batch_generate = __esm({
   "src/ai/prompts/batch-generate.ts"() {
     "use strict";
     init_cjs_shims();
-    SYSTEM_PROMPT4 = `You are a Playwright test automation expert. Generate executable Playwright code for multiple test steps in a single JSON response.
+    SYSTEM_PROMPT5 = `You are a Playwright test automation expert. Generate executable Playwright code for multiple test steps in a single JSON response.
 
 \u2501\u2501\u2501 OUTPUT FORMAT \u2501\u2501\u2501
 1. Return ONLY valid JSON \u2014 no markdown, no \`\`\`, no explanations
@@ -4214,7 +5072,7 @@ function createProvider(overrideProvider, options) {
       );
   }
 }
-function createSmartRouter(rootDir) {
+function createSmartRouter(rootDir, mcpSession, actThenScript) {
   const env = validateEnv();
   const primary = createProvider();
   let fast;
@@ -4223,19 +5081,19 @@ function createSmartRouter(rootDir) {
     if (fastProviderName) {
       try {
         fast = createProvider(fastProviderName);
-        logger12.info({ fast: fastProviderName, primary: String(env.AI_PROVIDER) }, "Tiered mode active");
+        logger16.info({ fast: fastProviderName, primary: String(env.AI_PROVIDER) }, "Tiered mode active");
       } catch (err) {
-        logger12.warn({ err }, "Failed to create fast provider \u2014 tiered mode disabled");
+        logger16.warn({ err }, "Failed to create fast provider \u2014 tiered mode disabled");
       }
     }
   }
   const cachePath = rootDir ? import_path12.default.join(rootDir, "results", ".code-cache.json") : void 0;
   const cache = new CodeCache(cachePath);
-  return new SmartRouter({ primaryProvider: primary, fastProvider: fast, cache });
+  return new SmartRouter({ primaryProvider: primary, fastProvider: fast, cache, mcpSession, actThenScript });
 }
 async function generateSuiteFromStory(story, options) {
   const provider = createProvider();
-  logger12.info({ provider: provider.name, model: provider.model }, "Generating suite from story");
+  logger16.info({ provider: provider.name, model: provider.model }, "Generating suite from story");
   const generated = await provider.generateTestSuite(story);
   const suiteName = options.suiteName ?? generated.name;
   const { suiteDir, suiteId } = await createSuite(options.outputDir, {
@@ -4244,7 +5102,7 @@ async function generateSuiteFromStory(story, options) {
     tags: generated.tags,
     type: options.type ?? "ui"
   });
-  logger12.info({ suiteDir, suiteId, cases: generated.cases.length }, "Suite directory created");
+  logger16.info({ suiteDir, suiteId, cases: generated.cases.length }, "Suite directory created");
   for (const genCase of generated.cases) {
     await createCase(suiteDir, {
       name: genCase.name,
@@ -4262,11 +5120,20 @@ async function generateSuiteFromStory(story, options) {
       }))
     });
   }
-  logger12.info({ suiteId, cases: generated.cases.length }, "Auto-generating code for all steps");
+  logger16.info({ suiteId, cases: generated.cases.length }, "Auto-generating code for all steps");
+  let mcpSession;
   try {
     const config = await readConfig(options.rootDir);
     const variables = await resolveVariables(options.rootDir).catch(() => ({}));
-    const router = createSmartRouter(options.rootDir);
+    if (config.mcp?.enabled) {
+      mcpSession = new McpSession({
+        headless: config.mcp.headless,
+        actionTimeout: config.mcp.actionTimeout,
+        idleTimeout: config.mcp.idleTimeout
+      });
+      logger16.info({ headless: config.mcp.headless }, "MCP session created for suite generation");
+    }
+    const router = createSmartRouter(options.rootDir, mcpSession, config.mcp?.actThenScript);
     const casePaths = await listCasePaths(suiteDir);
     for (const casePath of casePaths) {
       const tc = await readCase(casePath);
@@ -4296,18 +5163,23 @@ async function generateSuiteFromStory(story, options) {
       });
       if (codeGenCount > 0) {
         await updateCase(casePath, { steps: updatedSteps });
-        logger12.info({ caseName: tc.name, generated: codeGenCount, total: tc.steps.length }, "Code generated for case");
+        logger16.info({ caseName: tc.name, generated: codeGenCount, total: tc.steps.length }, "Code generated for case");
       }
     }
     await router.getCache().persist();
-    logger12.info({ suiteId }, "Auto code generation complete");
+    logger16.info({ suiteId }, "Auto code generation complete");
   } catch (codeGenErr) {
-    logger12.warn({ err: codeGenErr, suiteId }, "Auto code generation failed \u2014 steps saved without code");
+    logger16.warn({ err: codeGenErr, suiteId }, "Auto code generation failed \u2014 steps saved without code");
+  } finally {
+    if (mcpSession) {
+      mcpSession.release();
+      logger16.debug("MCP session released after suite generation");
+    }
   }
   const reportPath = import_path12.default.join(options.rootDir, "results", `generated-suite-${toSlug(suiteName)}.json`);
   await import_fs_extra10.default.ensureDir(import_path12.default.dirname(reportPath));
   await import_fs_extra10.default.writeJson(reportPath, { story, generated, suiteDir, suiteId }, { spaces: 2 });
-  logger12.info({ reportPath, suiteId }, "Generation complete");
+  logger16.info({ reportPath, suiteId }, "Generation complete");
   return { suiteId, suiteName };
 }
 async function generateSuitesFromStories(stories, options, ws, concurrency = 3) {
@@ -4318,7 +5190,7 @@ async function generateSuitesFromStories(stories, options, ws, concurrency = 3)
   let failed = 0;
   const failedItems = [];
   ws?.broadcast("story:bulk-start", { jobId, total });
-  logger12.info({ jobId, total, concurrency }, "Bulk story generation started");
+  logger16.info({ jobId, total, concurrency }, "Bulk story generation started");
   let active = 0;
   const queue = [...stories.entries()];
   const results = [];
@@ -4342,12 +5214,12 @@ async function generateSuitesFromStories(stories, options, ws, concurrency = 3)
           suiteName: item.suiteName
         });
         completed++;
-        logger12.info({ jobId, index, completed, total }, "Story processed");
+        logger16.info({ jobId, index, completed, total }, "Story processed");
       } catch (err) {
         failed++;
         const error = err instanceof Error ? err.message : String(err);
         failedItems.push({ index, story: item.story.slice(0, 120), error });
-        logger12.warn({ jobId, index, error }, "Story generation failed \u2014 continuing batch");
+        logger16.warn({ jobId, index, error }, "Story generation failed \u2014 continuing batch");
       }
       ws?.broadcast("story:bulk-progress", {
         jobId,
@@ -4368,10 +5240,10 @@ async function generateSuitesFromStories(stories, options, ws, concurrency = 3)
   await Promise.all(results);
   const doneEvent = { jobId, total, completed, failed, failedItems };
   ws?.broadcast("story:bulk-done", doneEvent);
-  logger12.info({ jobId, completed, failed, total }, "Bulk story generation finished");
+  logger16.info({ jobId, completed, failed, total }, "Bulk story generation finished");
   return doneEvent;
 }
-var import_path12, import_fs_extra10, logger12;
+var import_path12, import_fs_extra10, logger16;
 var init_router = __esm({
   "src/ai/router.ts"() {
     "use strict";
@@ -4383,13 +5255,14 @@ var init_router = __esm({
     init_logger();
     init_smart_router();
     init_code_cache();
+    init_mcp_session();
     init_case_store();
     init_suite_store();
     init_config_store();
     init_variable_store();
     init_sanitize();
     init_step_type_detector();
-    logger12 = createChildLogger("router");
+    logger16 = createChildLogger("router");
   }
 });
 
@@ -4443,6 +5316,7 @@ async function stepRoutes(fastify) {
     }
   });
   fastify.post("/suites/:suiteId/cases/:caseId/steps/:stepId/generate", async (req, reply) => {
+    let mcpSession;
     try {
       const caseDir = await resolveCasePath(req.params.suiteId, req.params.caseId);
       if (!caseDir) return reply.status(404).send({ error: `Case "${req.params.caseId}" not found` });
@@ -4452,10 +5326,16 @@ async function stepRoutes(fastify) {
         return reply.status(404).send({ error: `Step "${req.params.stepId}" not found` });
       }
       const variables = await resolveVariables(rootDir).catch(() => ({}));
-      const router = createSmartRouter(rootDir);
-      const config = await Promise.resolve().then(() => (init_config_store(), config_store_exports)).then(
-        (m) => m.readConfig(rootDir)
-      );
+      const config = await readConfig(rootDir);
+      const useMcp = req.body?.useMcp ?? config.mcp?.enabled;
+      if (useMcp) {
+        mcpSession = new McpSession({
+          headless: config.mcp?.headless ?? true,
+          actionTimeout: config.mcp?.actionTimeout ?? 15e3,
+          idleTimeout: config.mcp?.idleTimeout ?? 3e4
+        });
+      }
+      const router = createSmartRouter(rootDir, mcpSession, useMcp ? config.mcp?.actThenScript : false);
       const result = await router.generate(step.instruction, {
         url: config.baseUrl,
         title: "",
@@ -4469,12 +5349,15 @@ async function stepRoutes(fastify) {
       );
       await router.getCache().persist();
       const updated = await updateCase(caseDir, { steps: updatedSteps });
-      return reply.send({ step: updated.steps.find((s) => s.id === step.id), strategy: result.strategy, cost: result.cost });
+      return reply.send({ step: updated.steps.find((s) => s.id === step.id), strategy: result.strategy, cost: result.cost, mcpUsed: !!mcpSession });
     } catch (err) {
       return sendError(reply, 500, "Failed to generate code for step", err);
+    } finally {
+      mcpSession?.release();
     }
   });
   fastify.post("/suites/:suiteId/cases/:caseId/steps/generate-all", async (req, reply) => {
+    let mcpSession;
     try {
       const caseDir = await resolveCasePath(req.params.suiteId, req.params.caseId);
       if (!caseDir) return reply.status(404).send({ error: `Case "${req.params.caseId}" not found` });
@@ -4484,10 +5367,16 @@ async function stepRoutes(fastify) {
         return reply.send({ message: "All steps already have code", generated: 0 });
       }
       const variables = await resolveVariables(rootDir).catch(() => ({}));
-      const config = await Promise.resolve().then(() => (init_config_store(), config_store_exports)).then(
-        (m) => m.readConfig(rootDir)
-      );
-      const router = createSmartRouter(rootDir);
+      const config = await readConfig(rootDir);
+      const useMcp = req.body?.useMcp ?? config.mcp?.enabled;
+      if (useMcp) {
+        mcpSession = new McpSession({
+          headless: config.mcp?.headless ?? true,
+          actionTimeout: config.mcp?.actionTimeout ?? 15e3,
+          idleTimeout: config.mcp?.idleTimeout ?? 3e4
+        });
+      }
+      const router = createSmartRouter(rootDir, mcpSession, useMcp ? config.mcp?.actThenScript : false);
       const batchSteps = emptySteps.map((s) => ({
         instruction: s.instruction,
         context: {
@@ -4519,9 +5408,11 @@ async function stepRoutes(fastify) {
         });
       }
       const updated = await updateCase(caseDir, { steps: updatedSteps });
-      return reply.send({ generated: actuallyGenerated, case: updated });
+      return reply.send({ generated: actuallyGenerated, case: updated, mcpUsed: !!mcpSession });
     } catch (err) {
       return sendError(reply, 500, "Failed to generate code for steps", err);
+    } finally {
+      mcpSession?.release();
     }
   });
   fastify.patch("/suites/:suiteId/cases/:caseId/steps/reorder", async (req, reply) => {
@@ -4588,7 +5479,9 @@ var init_steps = __esm({
     init_case_store();
     init_suite_store();
     init_variable_store();
+    init_config_store();
     init_router();
+    init_mcp_session();
     init_utils2();
     AddStepBody = import_zod8.z.object({
       instruction: import_zod8.z.string().min(1),
@@ -4621,7 +5514,7 @@ async function readHooks(suiteDir) {
   const raw = await readJson(filePath);
   const result = SuiteHooksSchema.safeParse(raw);
   if (!result.success) {
-    logger13.warn({ path: filePath, errors: result.error.issues }, "Invalid hooks.json \u2014 returning defaults");
+    logger17.warn({ path: filePath, errors: result.error.issues }, "Invalid hooks.json \u2014 returning defaults");
     return { ...EMPTY_HOOKS };
   }
   return result.data;
@@ -4640,7 +5533,7 @@ ${issues}`,
     );
   }
   await atomicWriteJson(filePath, result.data);
-  logger13.debug({ path: filePath }, "Hooks written");
+  logger17.debug({ path: filePath }, "Hooks written");
 }
 async function addHookStep(suiteDir, hookType, instruction, order) {
   const hooks = await readHooks(suiteDir);
@@ -4690,7 +5583,7 @@ async function updateHookStep(suiteDir, hookType, stepId, patch) {
   await writeHooks(suiteDir, hooks);
   return hooks;
 }
-var import_path14, import_fs_extra11, import_crypto3, logger13, HOOKS_FILE, EMPTY_HOOKS;
+var import_path14, import_fs_extra11, import_crypto3, logger17, HOOKS_FILE, EMPTY_HOOKS;
 var init_hooks_store = __esm({
   "src/storage/hooks-store.ts"() {
     "use strict";
@@ -4702,7 +5595,7 @@ var init_hooks_store = __esm({
     init_errors();
     init_logger();
     init_utils();
-    logger13 = createChildLogger("hooks-store");
+    logger17 = createChildLogger("hooks-store");
     HOOKS_FILE = "hooks.json";
     EMPTY_HOOKS = {
       before_all: [],
@@ -5041,7 +5934,7 @@ ${issues}`,
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   const filePath = reportFilePath(healingDir, report.runId);
   await atomicWriteJson(filePath, schema.data);
-  logger14.info({ runId: report.runId, totalHeals: report.totalHeals }, "Healing report saved");
+  logger18.info({ runId: report.runId, totalHeals: report.totalHeals }, "Healing report saved");
 }
 async function readHealingReport(rootDir, runId) {
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
@@ -5073,7 +5966,7 @@ async function readPendingEvents(rootDir) {
   const raw = await readJson(filePath);
   const result = HealingEventSchema.array().safeParse(raw);
   if (!result.success) {
-    logger14.warn({ path: filePath }, "Pending healing file is malformed \u2014 resetting");
+    logger18.warn({ path: filePath }, "Pending healing file is malformed \u2014 resetting");
     return [];
   }
   return result.data;
@@ -5088,7 +5981,7 @@ function pruneToLimit(events) {
   });
   const excess = events.length - MAX_HEALING_EVENTS;
   const toDelete = new Set(byPriority.slice(0, excess).map((e) => e.id));
-  logger14.info(
+  logger18.info(
     { excess, deleted: toDelete.size },
     "Auto-pruning healing events to enforce cap"
   );
@@ -5126,7 +6019,7 @@ async function acceptHealingEvent(rootDir, eventId) {
   };
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   await atomicWriteJson(pendingFilePath(healingDir), pending);
-  logger14.info({ eventId }, "Healing event accepted");
+  logger18.info({ eventId }, "Healing event accepted");
   return pending[idx];
 }
 async function rejectHealingEvent(rootDir, eventId) {
@@ -5146,7 +6039,7 @@ async function rejectHealingEvent(rootDir, eventId) {
   };
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   await atomicWriteJson(pendingFilePath(healingDir), pending);
-  logger14.info({ eventId }, "Healing event rejected");
+  logger18.info({ eventId }, "Healing event rejected");
   return pending[idx];
 }
 async function deleteHealingEvent(rootDir, eventId) {
@@ -5154,7 +6047,7 @@ async function deleteHealingEvent(rootDir, eventId) {
   const filtered = events.filter((e) => e.id !== eventId);
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   await atomicWriteJson(pendingFilePath(healingDir), filtered);
-  logger14.info({ eventId }, "Healing event deleted");
+  logger18.info({ eventId }, "Healing event deleted");
 }
 async function deleteHealingEvents(rootDir, eventIds) {
   const events = await readPendingEvents(rootDir);
@@ -5163,7 +6056,7 @@ async function deleteHealingEvents(rootDir, eventIds) {
   const deleted = events.length - filtered.length;
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   await atomicWriteJson(pendingFilePath(healingDir), filtered);
-  logger14.info({ count: deleted }, "Healing events bulk-deleted");
+  logger18.info({ count: deleted }, "Healing events bulk-deleted");
   return deleted;
 }
 async function clearAllHealingEvents(rootDir) {
@@ -5171,7 +6064,7 @@ async function clearAllHealingEvents(rootDir) {
   const count = events.length;
   const healingDir = import_path16.default.join(rootDir, HEALING_DIR);
   await atomicWriteJson(pendingFilePath(healingDir), []);
-  logger14.info({ count }, "All healing events cleared");
+  logger18.info({ count }, "All healing events cleared");
   return count;
 }
 async function getHealingStats(rootDir) {
@@ -5194,7 +6087,7 @@ async function listHealingReportIds(rootDir) {
   );
   return withStats.sort((a, b) => b.mtime - a.mtime).map((x) => x.id);
 }
-var import_path16, import_fs_extra12, logger14, HEALING_DIR, PENDING_FILE, REPORT_PREFIX, MAX_HEALING_EVENTS, PRUNE_PRIORITY;
+var import_path16, import_fs_extra12, logger18, HEALING_DIR, PENDING_FILE, REPORT_PREFIX, MAX_HEALING_EVENTS, PRUNE_PRIORITY;
 var init_healing_store = __esm({
   "src/storage/healing-store.ts"() {
     "use strict";
@@ -5205,7 +6098,7 @@ var init_healing_store = __esm({
     init_errors();
     init_logger();
     init_utils();
-    logger14 = createChildLogger("healing-store");
+    logger18 = createChildLogger("healing-store");
     HEALING_DIR = import_path16.default.join("results", "healing");
     PENDING_FILE = "pending.json";
     REPORT_PREFIX = "healing-report-";
@@ -5251,7 +6144,7 @@ async function healingRoutes(fastify) {
     try {
       const event = await acceptHealingEvent(rootDir, req.params.id);
       await applyHealToCase(testsDir, event.caseId, event.stepId, event.healedCode);
-      logger15.info({ id: req.params.id, caseId: event.caseId, stepId: event.stepId }, "Healing accepted and applied");
+      logger19.info({ id: req.params.id, caseId: event.caseId, stepId: event.stepId }, "Healing accepted and applied");
       return reply.send(event);
     } catch (err) {
       return sendError(reply, 500, "Failed to accept healing event", err);
@@ -5274,7 +6167,7 @@ async function healingRoutes(fastify) {
           await acceptHealingEvent(rootDir, event.id);
           await applyHealToCase(testsDir, event.caseId, event.stepId, event.healedCode);
           results.push({ id: event.id, status: "accepted" });
-          logger15.info({ id: event.id }, "Bulk healing accepted");
+          logger19.info({ id: event.id }, "Bulk healing accepted");
         } catch (err) {
           results.push({ id: event.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
         }
@@ -5363,7 +6256,7 @@ async function findCasePath(testsDir, caseId) {
   }
   return null;
 }
-var import_path17, import_zod12, logger15, ApplyFromReportBody, DeleteBulkBody;
+var import_path17, import_zod12, logger19, ApplyFromReportBody, DeleteBulkBody;
 var init_healing2 = __esm({
   "src/server/routes/healing.ts"() {
     "use strict";
@@ -5374,7 +6267,7 @@ var init_healing2 = __esm({
     init_case_store();
     init_utils2();
     init_logger();
-    logger15 = createChildLogger("routes/healing");
+    logger19 = createChildLogger("routes/healing");
     ApplyFromReportBody = import_zod12.z.object({
       reportPath: import_zod12.z.string().min(1)
     });
@@ -5526,7 +6419,7 @@ ${issues}`,
   }
   const filePath = runFilePath(import_path18.default.join(rootDir, RESULTS_DIR), result.runId);
   await atomicWriteJson(filePath, schema.data);
-  logger16.info({ runId: result.runId, status: result.status }, "Run result saved");
+  logger20.info({ runId: result.runId, status: result.status }, "Run result saved");
 }
 async function readResult(rootDir, runId) {
   const filePath = runFilePath(import_path18.default.join(rootDir, RESULTS_DIR), runId);
@@ -5583,7 +6476,7 @@ async function listResults(rootDir, limit = 20) {
         suiteIds: result.suites.map((s) => s.suiteId)
       });
     } catch (err) {
-      logger16.warn({ runId: id, err }, "Failed to read run result \u2014 skipping");
+      logger20.warn({ runId: id, err }, "Failed to read run result \u2014 skipping");
     }
   }
   return results;
@@ -5598,9 +6491,9 @@ async function deleteResult(rootDir, runId) {
     );
   }
   await import_fs_extra13.default.remove(filePath);
-  logger16.info({ runId }, "Run result deleted");
+  logger20.info({ runId }, "Run result deleted");
 }
-var import_path18, import_fs_extra13, logger16, RESULTS_DIR, RUNS_DIR;
+var import_path18, import_fs_extra13, logger20, RESULTS_DIR, RUNS_DIR;
 var init_result_store = __esm({
   "src/storage/result-store.ts"() {
     "use strict";
@@ -5611,21 +6504,185 @@ var init_result_store = __esm({
     init_errors();
     init_logger();
     init_utils();
-    logger16 = createChildLogger("result-store");
+    logger20 = createChildLogger("result-store");
     RESULTS_DIR = "results";
     RUNS_DIR = "runs";
   }
 });
 
+// src/mcp/proactive-checker.ts
+function extractSelectors(code) {
+  const results = [];
+  for (const pattern of SELECTOR_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    let match;
+    while ((match = pattern.regex.exec(code)) !== null) {
+      if (pattern.type === "getByRole") {
+        results.push({
+          selector: match[0],
+          type: pattern.type,
+          role: match[1],
+          name: match[2]
+        });
+      } else {
+        results.push({
+          selector: match[0],
+          type: pattern.type,
+          name: match[1]
+        });
+      }
+    }
+  }
+  return results;
+}
+function fuzzyMatch(targetName, snapshotElements, targetRole) {
+  const lowerTarget = targetName.toLowerCase();
+  for (const el of snapshotElements) {
+    const nameMatch = el.match(/"([^"]+)"/);
+    if (nameMatch && nameMatch[1].toLowerCase() === lowerTarget) {
+      if (!targetRole || el.toLowerCase().startsWith(targetRole.toLowerCase())) {
+        return el;
+      }
+    }
+  }
+  for (const el of snapshotElements) {
+    const nameMatch = el.match(/"([^"]+)"/);
+    if (nameMatch) {
+      const elName = nameMatch[1].toLowerCase();
+      if (elName.includes(lowerTarget) || lowerTarget.includes(elName)) {
+        if (!targetRole || el.toLowerCase().startsWith(targetRole.toLowerCase())) {
+          return el;
+        }
+      }
+    }
+  }
+  if (targetRole) {
+    const sameRole = snapshotElements.filter(
+      (el) => el.toLowerCase().startsWith(targetRole.toLowerCase())
+    );
+    if (sameRole.length > 0) {
+      let bestScore = 0;
+      let bestMatch;
+      for (const el of sameRole) {
+        const nameMatch = el.match(/"([^"]+)"/);
+        if (nameMatch) {
+          const score = similarity(lowerTarget, nameMatch[1].toLowerCase());
+          if (score > bestScore) {
+            bestScore = score;
+            bestMatch = el;
+          }
+        }
+      }
+      if (bestScore > 0.3) return bestMatch;
+    }
+  }
+  return void 0;
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  const longer = a.length > b.length ? a : b;
+  const shorter = a.length > b.length ? b : a;
+  if (longer.length === 0) return 1;
+  let matches = 0;
+  for (let i = 0; i < shorter.length; i++) {
+    if (longer.includes(shorter[i])) matches++;
+  }
+  return matches / longer.length;
+}
+async function checkSelectors(mcpSession, url, code) {
+  const selectors = extractSelectors(code);
+  if (selectors.length === 0) {
+    return { url, ok: true, total: 0, matched: 0, missing: 0, checks: [] };
+  }
+  await mcpSession.navigate(url);
+  const raw = await mcpSession.snapshot();
+  if (!raw) {
+    logger21.warn({ url }, "Proactive check: snapshot returned null \u2014 skipping validation");
+    return { url, ok: true, total: selectors.length, matched: 0, missing: 0, checks: [] };
+  }
+  const parsed = parseSnapshot(raw);
+  const snapshotElements = parsed.interactiveElements.split("\n").filter(Boolean);
+  const checks = [];
+  for (const sel of selectors) {
+    const targetName = sel.name ?? "";
+    let found = false;
+    for (const el of snapshotElements) {
+      const nameMatch = el.match(/"([^"]+)"/);
+      if (nameMatch) {
+        const elName = nameMatch[1].toLowerCase();
+        if (elName === targetName.toLowerCase()) {
+          if (sel.role) {
+            if (el.toLowerCase().startsWith(sel.role.toLowerCase())) {
+              found = true;
+              break;
+            }
+          } else {
+            found = true;
+            break;
+          }
+        }
+      }
+    }
+    const check2 = {
+      selector: sel.selector,
+      type: sel.type,
+      found
+    };
+    if (!found) {
+      const suggestion = fuzzyMatch(targetName, snapshotElements, sel.role);
+      if (suggestion) {
+        check2.suggestion = suggestion;
+      }
+    }
+    checks.push(check2);
+  }
+  const matched = checks.filter((c) => c.found).length;
+  const missing = checks.filter((c) => !c.found).length;
+  logger21.info(
+    { url, total: checks.length, matched, missing },
+    "Proactive selector check complete"
+  );
+  return {
+    url,
+    ok: missing === 0,
+    total: checks.length,
+    matched,
+    missing,
+    checks
+  };
+}
+var logger21, SELECTOR_PATTERNS;
+var init_proactive_checker = __esm({
+  "src/mcp/proactive-checker.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_snapshot_parser();
+    init_logger();
+    logger21 = createChildLogger("proactive-checker");
+    SELECTOR_PATTERNS = [
+      // getByRole('button', { name: 'Login' })
+      { regex: /getByRole\(\s*['"](\w+)['"]\s*,\s*\{[^}]*name:\s*['"]([^'"]+)['"]/g, type: "getByRole" },
+      // getByLabel('Username')
+      { regex: /getByLabel\(\s*['"]([^'"]+)['"]/g, type: "getByLabel" },
+      // getByPlaceholder('Enter email')
+      { regex: /getByPlaceholder\(\s*['"]([^'"]+)['"]/g, type: "getByPlaceholder" },
+      // getByText('Welcome')
+      { regex: /getByText\(\s*['"]([^'"]+)['"]/g, type: "getByText" },
+      // getByTestId('submit-btn')
+      { regex: /getByTestId\(\s*['"]([^'"]+)['"]/g, type: "getByTestId" }
+    ];
+  }
+});
+
 // src/engine/browser-manager.ts
-var import_playwright, logger17, BrowserManager;
+var import_playwright, logger22, BrowserManager;
 var init_browser_manager = __esm({
   "src/engine/browser-manager.ts"() {
     "use strict";
     init_cjs_shims();
     import_playwright = require("playwright");
     init_logger();
-    logger17 = createChildLogger("browser-manager");
+    logger22 = createChildLogger("browser-manager");
     BrowserManager = class {
       browsers = /* @__PURE__ */ new Map();
       // ─── Launch ───────────────────────────────────────────────────────────────
@@ -5635,14 +6692,14 @@ var init_browser_manager = __esm({
         const launcher = browserName === "firefox" ? import_playwright.firefox : browserName === "webkit" ? import_playwright.webkit : import_playwright.chromium;
         const browser = await launcher.launch({ headless: config.headless });
         this.browsers.set(browserName, browser);
-        logger17.info({ browser: browserName, headless: config.headless }, "Browser launched");
+        logger22.info({ browser: browserName, headless: config.headless }, "Browser launched");
         return browser;
       }
       // ─── Context ──────────────────────────────────────────────────────────────
       async newContext(browser, config, videosDir) {
         const deviceDescriptor = config.device && import_playwright.devices[config.device] ? import_playwright.devices[config.device] : null;
         if (config.device && !deviceDescriptor) {
-          logger17.warn({ device: config.device }, "Unknown Playwright device \u2014 falling back to configured viewport");
+          logger22.warn({ device: config.device }, "Unknown Playwright device \u2014 falling back to configured viewport");
         }
         const contextOptions = {
           // Do NOT set baseURL here — it causes Playwright to pre-navigate the page
@@ -5755,7 +6812,7 @@ var init_browser_manager = __esm({
           close: async () => {
           }
         };
-        logger17.info("Created API-only request context (zero browser)");
+        logger22.info("Created API-only request context (zero browser)");
         return fakePage;
       }
       /** Closes all API request contexts. */
@@ -5780,11 +6837,11 @@ var init_browser_manager = __esm({
               await context.tracing.stop();
             }
           } catch (err) {
-            logger17.debug({ err }, "Tracing stop failed \u2014 ignoring");
+            logger22.debug({ err }, "Tracing stop failed \u2014 ignoring");
           }
         }
         await context.close().catch((err) => {
-          logger17.debug({ err }, "Context close failed \u2014 ignoring");
+          logger22.debug({ err }, "Context close failed \u2014 ignoring");
         });
       }
       /** Closes all open browsers and API contexts. Called at the end of every run. */
@@ -5793,9 +6850,9 @@ var init_browser_manager = __esm({
         for (const [name, browser] of this.browsers) {
           try {
             await browser.close();
-            logger17.debug({ browser: name }, "Browser closed");
+            logger22.debug({ browser: name }, "Browser closed");
           } catch (err) {
-            logger17.warn({ err, browser: name }, "Error closing browser");
+            logger22.warn({ err, browser: name }, "Error closing browser");
           }
         }
         this.browsers.clear();
@@ -5808,13 +6865,13 @@ var init_browser_manager = __esm({
 });
 
 // src/engine/healing-budget.ts
-var logger18, ENVIRONMENTAL_PATTERNS, HealingBudget;
+var logger23, ENVIRONMENTAL_PATTERNS, HealingBudget;
 var init_healing_budget = __esm({
   "src/engine/healing-budget.ts"() {
     "use strict";
     init_cjs_shims();
     init_logger();
-    logger18 = createChildLogger("healing-budget");
+    logger23 = createChildLogger("healing-budget");
     ENVIRONMENTAL_PATTERNS = [
       /timeout/i,
       /ECONNREFUSED/i,
@@ -5837,7 +6894,7 @@ var init_healing_budget = __esm({
       // ─── Main decision ────────────────────────────────────────────────────────
       shouldHeal(failure) {
         if (this.spent >= this.dailyBudget) {
-          logger18.warn(
+          logger23.warn(
             { spent: this.spent, budget: this.dailyBudget },
             "Daily healing budget exhausted"
           );
@@ -5871,7 +6928,7 @@ var init_healing_budget = __esm({
       /** Call after each AI healing call with the estimated cost. */
       recordSpend(amountUsd) {
         this.spent += amountUsd;
-        logger18.debug({ spend: amountUsd, total: this.spent }, "Healing budget spend recorded");
+        logger23.debug({ spend: amountUsd, total: this.spent }, "Healing budget spend recorded");
       }
       /** Call when a healing attempt itself fails (AI returned bad code, etc.). */
       recordHealFailure(stepId) {
@@ -5893,7 +6950,7 @@ var init_healing_budget = __esm({
 });
 
 // src/engine/healing-report.ts
-var import_crypto4, logger19, HealingReporter;
+var import_crypto4, logger24, HealingReporter;
 var init_healing_report = __esm({
   "src/engine/healing-report.ts"() {
     "use strict";
@@ -5901,7 +6958,7 @@ var init_healing_report = __esm({
     import_crypto4 = require("crypto");
     init_healing_store();
     init_logger();
-    logger19 = createChildLogger("healing-report");
+    logger24 = createChildLogger("healing-report");
     HealingReporter = class {
       events = [];
       /** Records a successful healing event (called by executor after each healed step). */
@@ -5923,7 +6980,7 @@ var init_healing_report = __esm({
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         this.events.push(event);
-        logger19.info(
+        logger24.info(
           { stepId: input.stepId, strategy: input.strategy, level: input.level },
           "Healing event recorded"
         );
@@ -5949,15 +7006,15 @@ var init_healing_report = __esm({
         };
         try {
           await writeHealingReport(rootDir, report);
-          logger19.info({ runId, count: this.events.length }, "Healing report written");
+          logger24.info({ runId, count: this.events.length }, "Healing report written");
         } catch (err) {
-          logger19.error({ err, runId }, "Failed to write healing report");
+          logger24.error({ err, runId }, "Failed to write healing report");
         }
         for (const event of this.events) {
           try {
             await appendPendingEvent(rootDir, event);
           } catch (err) {
-            logger19.warn({ err, eventId: event.id }, "Failed to append pending healing event");
+            logger24.warn({ err, eventId: event.id }, "Failed to append pending healing event");
           }
         }
       }
@@ -6149,7 +7206,7 @@ function buildCategoryHtml(caseName, pageLoads, category) {
 </body>
 </html>`;
 }
-var import_path19, import_crypto5, import_fs_extra14, logger20, AllureReporter;
+var import_path19, import_crypto5, import_fs_extra14, logger25, AllureReporter;
 var init_allure_reporter = __esm({
   "src/engine/allure-reporter.ts"() {
     "use strict";
@@ -6158,7 +7215,7 @@ var init_allure_reporter = __esm({
     import_crypto5 = require("crypto");
     import_fs_extra14 = __toESM(require("fs-extra"));
     init_logger();
-    logger20 = createChildLogger("allure-reporter");
+    logger25 = createChildLogger("allure-reporter");
     AllureReporter = class {
       resultsDir;
       environment;
@@ -6180,9 +7237,9 @@ var init_allure_reporter = __esm({
             logFileName = import_path19.default.basename(runResult.logFilePath);
             await this.copyAttachment(runResult.logFilePath).catch(() => {
             });
-            logger20.debug({ logFile: logFileName }, "Log file copied to Allure results");
+            logger25.debug({ logFile: logFileName }, "Log file copied to Allure results");
           } catch {
-            logger20.debug("Failed to copy log file to Allure results");
+            logger25.debug("Failed to copy log file to Allure results");
           }
         }
         let written = 0;
@@ -6192,7 +7249,7 @@ var init_allure_reporter = __esm({
             written++;
           }
         }
-        logger20.info({ dir: this.resultsDir, written }, "Allure results written");
+        logger25.info({ dir: this.resultsDir, written }, "Allure results written");
       }
       // ─── Internal ─────────────────────────────────────────────────────────────
       async writeTestResult(suite, tc, logFileName) {
@@ -6311,12 +7368,12 @@ async function generateAllureReport(rootDir, runId) {
   const resultsDir = import_path20.default.join(rootDir, "results", "allure-results", runId);
   const reportDir = import_path20.default.join(rootDir, "results", "allure-report", runId);
   if (!await import_fs_extra15.default.pathExists(resultsDir)) {
-    logger21.debug({ resultsDir }, "No allure-results dir for run \u2014 skipping report generation");
+    logger26.debug({ resultsDir }, "No allure-results dir for run \u2014 skipping report generation");
     return false;
   }
   const files = await import_fs_extra15.default.readdir(resultsDir);
   if (files.length === 0) {
-    logger21.debug({ runId }, "allure-results is empty \u2014 skipping report generation");
+    logger26.debug({ runId }, "allure-results is empty \u2014 skipping report generation");
     return false;
   }
   try {
@@ -6325,21 +7382,21 @@ async function generateAllureReport(rootDir, runId) {
       ["generate", resultsDir, "--output", reportDir, "--clean", "--single-file"],
       isWindows ? { shell: true } : {}
     );
-    logger21.info({ reportDir, runId }, "Allure HTML report generated");
+    logger26.info({ reportDir, runId }, "Allure HTML report generated");
     return true;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.includes("java") || msg.includes("Java") || msg.includes("JAVA")) {
-      logger21.warn(
+      logger26.warn(
         "Allure report generation skipped \u2014 Java is not installed. Install Java (https://adoptium.net) to enable Allure HTML reports."
       );
     } else {
-      logger21.warn({ err: msg, runId }, "Allure report generation failed");
+      logger26.warn({ err: msg, runId }, "Allure report generation failed");
     }
     return false;
   }
 }
-var import_path20, import_fs_extra15, import_child_process2, import_util, execFileAsync, logger21, isWindows, alluireBin;
+var import_path20, import_fs_extra15, import_child_process2, import_util, execFileAsync, logger26, isWindows, alluireBin;
 var init_allure_generator = __esm({
   "src/engine/allure-generator.ts"() {
     "use strict";
@@ -6350,7 +7407,7 @@ var init_allure_generator = __esm({
     import_util = require("util");
     init_logger();
     execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
-    logger21 = createChildLogger("allure-generator");
+    logger26 = createChildLogger("allure-generator");
     isWindows = process.platform === "win32";
     alluireBin = import_path20.default.resolve(
       __dirname,
@@ -6638,7 +7695,7 @@ async function extractPageContext(page, previousSteps, variables) {
       }
       return lines.join("\n");
     },
-    { maxElements: MAX_ELEMENTS, maxTextLen: MAX_TEXT_LEN }
+    { maxElements: MAX_ELEMENTS2, maxTextLen: MAX_TEXT_LEN2 }
   ).catch(() => "");
   const htmlSnapshot = await page.evaluate(
     ({ maxLen }) => document.body?.innerHTML?.slice(0, maxLen) ?? "",
@@ -6653,13 +7710,13 @@ async function extractPageContext(page, previousSteps, variables) {
     variables
   };
 }
-var MAX_ELEMENTS, MAX_TEXT_LEN, MAX_HTML_LEN;
+var MAX_ELEMENTS2, MAX_TEXT_LEN2, MAX_HTML_LEN;
 var init_context_extractor = __esm({
   "src/engine/context-extractor.ts"() {
     "use strict";
     init_cjs_shims();
-    MAX_ELEMENTS = 120;
-    MAX_TEXT_LEN = 80;
+    MAX_ELEMENTS2 = 120;
+    MAX_TEXT_LEN2 = 80;
     MAX_HTML_LEN = 8e3;
   }
 });
@@ -6897,7 +7954,7 @@ function parseMultiStrategies(raw) {
   }
   return stripped.split("\n").map((s) => s.trim()).filter((s) => s.length > 0 && s.startsWith("await"));
 }
-var logger22, SelfHealer;
+var logger27, SelfHealer;
 var init_self_healing = __esm({
   "src/engine/self-healing.ts"() {
     "use strict";
@@ -6909,7 +7966,7 @@ var init_self_healing = __esm({
     init_logger();
     init_code_runner();
     init_step_type_detector();
-    logger22 = createChildLogger("self-healing");
+    logger27 = createChildLogger("self-healing");
     SelfHealer = class {
       constructor(provider, maxLevel) {
         this.provider = provider;
@@ -6924,7 +7981,7 @@ var init_self_healing = __esm({
        */
       async heal(step, failure, previousSteps, page, variables, baseUrl) {
         if (failure.failureKind === "assertion") {
-          logger22.info(
+          logger27.info(
             { stepId: step.id },
             "Assertion failure \u2014 skipping all healing levels (possible application bug)"
           );
@@ -6933,10 +7990,10 @@ var init_self_healing = __esm({
         const isApi = step.stepType === "api" || detectStepType(step.instruction) === "api";
         for (let level = 1; level <= this.maxLevel; level++) {
           if (isApi && (level === 3 || level === 4)) {
-            logger22.debug({ stepId: step.id, level }, `Skipping DOM-specific level ${level} for API step`);
+            logger27.debug({ stepId: step.id, level }, `Skipping DOM-specific level ${level} for API step`);
             continue;
           }
-          logger22.debug({ stepId: step.id, level, isApi }, `Attempting heal level ${level}`);
+          logger27.debug({ stepId: step.id, level, isApi }, `Attempting heal level ${level}`);
           try {
             const result = await this.tryLevel(
               level,
@@ -6949,14 +8006,14 @@ var init_self_healing = __esm({
               isApi
             );
             if (result !== null) {
-              logger22.info({ stepId: step.id, level, strategy: result.strategy }, "Healing succeeded");
+              logger27.info({ stepId: step.id, level, strategy: result.strategy }, "Healing succeeded");
               return result;
             }
           } catch (err) {
-            logger22.debug({ err, level, stepId: step.id }, `Level ${level} healing attempt threw`);
+            logger27.debug({ err, level, stepId: step.id }, `Level ${level} healing attempt threw`);
           }
         }
-        logger22.warn({ stepId: step.id, maxLevel: this.maxLevel }, "All healing levels exhausted");
+        logger27.warn({ stepId: step.id, maxLevel: this.maxLevel }, "All healing levels exhausted");
         return null;
       }
       // ─── Level dispatcher ─────────────────────────────────────────────────────
@@ -6991,7 +8048,7 @@ var init_self_healing = __esm({
         if (this.provider.supportsVision) {
           try {
             const som = await captureSetOfMarks(page);
-            logger22.debug({ stepId: step.id }, "Level 2: using SoM vision healing");
+            logger27.debug({ stepId: step.id }, "Level 2: using SoM vision healing");
             const code2 = await this.provider.analyzeWithSoM(
               som.screenshot,
               som.elementMap,
@@ -7001,7 +8058,7 @@ var init_self_healing = __esm({
             await executeCode(sanitized2, page);
             return { code: sanitized2, level: 2, strategy: "regenerate" };
           } catch (visionErr) {
-            logger22.debug({ stepId: step.id, err: visionErr }, "SoM vision failed, falling back to text regeneration");
+            logger27.debug({ stepId: step.id, err: visionErr }, "SoM vision failed, falling back to text regeneration");
             await cleanupSoMOverlay(page);
           }
         }
@@ -7057,12 +8114,12 @@ var init_self_healing = __esm({
       // Produces inspectable Playwright code (not pixel coordinates).
       async level4Visual(step, page, variables, baseUrl) {
         if (!this.provider.supportsVision) {
-          logger22.debug({ stepId: step.id }, "Skipping SoM visual healing \u2014 provider lacks vision");
+          logger27.debug({ stepId: step.id }, "Skipping SoM visual healing \u2014 provider lacks vision");
           return null;
         }
         try {
           const som = await captureSetOfMarks(page);
-          logger22.debug(
+          logger27.debug(
             { stepId: step.id, elementCount: som.elements.length },
             "Level 4: SoM screenshot captured"
           );
@@ -7076,7 +8133,7 @@ var init_self_healing = __esm({
           return { code: sanitized, level: 4, strategy: "visual" };
         } catch (err) {
           await cleanupSoMOverlay(page);
-          logger22.debug({ stepId: step.id, err }, "Level 4 SoM failed");
+          logger27.debug({ stepId: step.id, err }, "Level 4 SoM failed");
           return null;
         }
       }
@@ -7101,7 +8158,7 @@ var init_self_healing = __esm({
       }
       // ─── Level 6: Manual (human in the loop) ─────────────────────────────────
       level6Manual(step, failure) {
-        logger22.warn(
+        logger27.warn(
           { stepId: step.id, instruction: step.instruction, error: failure.error },
           "Level 6: manual intervention required \u2014 marking step for human review"
         );
@@ -7126,17 +8183,17 @@ async function executeStep(step, page, ctx) {
   const mergedVars = { ...ctx.variables, ...Object.fromEntries(ctx.sharedVariables) };
   const hasTokens = step.generatedCode.includes("{{");
   if (hasTokens) {
-    logger23.warn(
+    logger28.warn(
       { stepId: step.id, variableKeys: Object.keys(mergedVars), variableCount: Object.keys(mergedVars).length },
       "Interpolating variables into step code"
     );
   }
   const code = interpolate(step.generatedCode, mergedVars, ctx.config.baseUrl);
   if (hasTokens) {
-    logger23.warn({ stepId: step.id, before: step.generatedCode, after: code }, "Variable interpolation result");
+    logger28.warn({ stepId: step.id, before: step.generatedCode, after: code }, "Variable interpolation result");
   }
   if (!code.trim() && step.stepType !== "mock") {
-    logger23.warn({ stepId: step.id }, "Step has no generated code \u2014 skipping");
+    logger28.warn({ stepId: step.id }, "Step has no generated code \u2014 skipping");
     return buildResult(step, "skipped", code, Date.now() - start);
   }
   if (step.stepType === "mock" && step.mockUrl && step.mockResponse) {
@@ -7161,7 +8218,7 @@ async function executeStep(step, page, ctx) {
   const runtimeCtx = {
     setVariable: (key, value) => {
       ctx.sharedVariables.set(key, value);
-      logger23.info({ stepId: step.id, key, value: value.slice(0, 50) }, "Runtime variable set");
+      logger28.info({ stepId: step.id, key, value: value.slice(0, 50) }, "Runtime variable set");
     },
     getVariable: (key) => ctx.sharedVariables.get(key)
   };
@@ -7201,7 +8258,7 @@ async function executeStep(step, page, ctx) {
     } catch (err) {
       lastErr = err;
       if (attempt < stepRetries) {
-        logger23.debug({ stepId: step.id, attempt, stepRetries }, "Step failed \u2014 retrying");
+        logger28.debug({ stepId: step.id, attempt, stepRetries }, "Step failed \u2014 retrying");
         continue;
       }
     }
@@ -7209,7 +8266,7 @@ async function executeStep(step, page, ctx) {
   const firstErr = lastErr;
   {
     const errorMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
-    logger23.debug({ stepId: step.id, error: errorMsg }, "Step failed on first attempt");
+    logger28.debug({ stepId: step.id, error: errorMsg }, "Step failed on first attempt");
     const failAuditUrl = step.runAudit && step.stepType !== "api" ? (() => {
       try {
         return page.url() || void 0;
@@ -7223,7 +8280,7 @@ async function executeStep(step, page, ctx) {
     }
     const failureKind = classifyError(errorMsg);
     if (failureKind === "assertion") {
-      logger23.info(
+      logger28.info(
         { stepId: step.id, error: errorMsg },
         "Assertion failure detected \u2014 NOT healing (possible application bug)"
       );
@@ -7232,7 +8289,7 @@ async function executeStep(step, page, ctx) {
     if (!ctx.config.healing.enabled) {
       return { ...buildResult(step, "failed", code, Date.now() - start, errorMsg, screenshotPath), ...failAuditUrl ? { auditUrl: failAuditUrl } : {} };
     }
-    logger23.debug({ stepId: step.id, failureKind }, "Infrastructure failure \u2014 attempting to heal");
+    logger28.debug({ stepId: step.id, failureKind }, "Infrastructure failure \u2014 attempting to heal");
     const failure = {
       stepId: step.id,
       instruction: step.instruction,
@@ -7243,7 +8300,7 @@ async function executeStep(step, page, ctx) {
     };
     const decision = ctx.budget.shouldHeal(failure);
     if (!decision.heal) {
-      logger23.info({ stepId: step.id, reason: decision.reason }, "Healing skipped");
+      logger28.info({ stepId: step.id, reason: decision.reason }, "Healing skipped");
       return { ...buildResult(step, "failed", code, Date.now() - start, errorMsg, screenshotPath), ...failAuditUrl ? { auditUrl: failAuditUrl } : {} };
     }
     const healer = new SelfHealer(ctx.provider, ctx.config.healing.maxLevel);
@@ -7274,7 +8331,7 @@ async function executeStep(step, page, ctx) {
             pageUrl: page.url()
           });
         }
-        logger23.info(
+        logger28.info(
           { stepId: step.id, level: healResult.level, strategy: healResult.strategy, codeChanged },
           codeChanged ? "Step passed after healing (code NOT saved \u2014 awaits human review)" : "Step passed after smart retry (no code change)"
         );
@@ -7290,7 +8347,7 @@ async function executeStep(step, page, ctx) {
       }
     } catch (healErr) {
       const healErrMsg = healErr instanceof Error ? healErr.message : String(healErr);
-      logger23.warn({ stepId: step.id, error: healErrMsg }, "Healing threw an error");
+      logger28.warn({ stepId: step.id, error: healErrMsg }, "Healing threw an error");
       ctx.budget.recordHealFailure(step.id);
     }
     return { ...buildResult(step, "failed", code, Date.now() - start, errorMsg, screenshotPath), ...failAuditUrl ? { auditUrl: failAuditUrl } : {} };
@@ -7320,7 +8377,7 @@ async function captureScreenshot(page, ctx, stepId, suffix) {
     await page.screenshot({ path: screenshotPath, fullPage: true });
     return screenshotPath;
   } catch (err) {
-    logger23.debug({ err }, "Screenshot capture failed");
+    logger28.debug({ err }, "Screenshot capture failed");
     return void 0;
   }
 }
@@ -7332,7 +8389,7 @@ function withTimeout(promise, ms) {
     )
   ]);
 }
-var import_path21, logger23, ASSERTION_PATTERNS, INFRA_PATTERNS;
+var import_path21, logger28, ASSERTION_PATTERNS, INFRA_PATTERNS;
 var init_executor = __esm({
   "src/engine/executor.ts"() {
     "use strict";
@@ -7344,7 +8401,7 @@ var init_executor = __esm({
     init_step_type_detector();
     init_logger();
     init_code_runner();
-    logger23 = createChildLogger("executor");
+    logger28 = createChildLogger("executor");
     ASSERTION_PATTERNS = [
       /expect\(.*\)\.(toBe|toEqual|toContain|toMatch|toHaveText|toHaveValue|toBeChecked|toBeVisible|toBeHidden|toBeEnabled|toBeDisabled|toHaveCount|toHaveAttribute|toHaveClass|toHaveCSS|toHaveURL|toHaveTitle)/i,
       /AssertionError/i,
@@ -7567,7 +8624,7 @@ async function loadDataRows(rootDir, dataSource) {
       }
       const raw = await import_fs_extra16.default.readJson(filePath);
       if (!Array.isArray(raw)) throw new Error("JSON data file must contain an array of objects");
-      logger24.info({ path: filePath, rows: raw.length }, "Loaded JSON data rows");
+      logger29.info({ path: filePath, rows: raw.length }, "Loaded JSON data rows");
       return raw.map(
         (row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, String(v)]))
       );
@@ -7590,14 +8647,14 @@ async function loadDataRows(rootDir, dataSource) {
         });
         return row;
       });
-      logger24.info({ path: filePath, rows: rows.length }, "Loaded CSV data rows");
+      logger29.info({ path: filePath, rows: rows.length }, "Loaded CSV data rows");
       return rows;
     }
     default:
       return [];
   }
 }
-var import_path22, import_fs_extra16, logger24;
+var import_path22, import_fs_extra16, logger29;
 var init_data_loader = __esm({
   "src/engine/data-loader.ts"() {
     "use strict";
@@ -7605,7 +8662,7 @@ var init_data_loader = __esm({
     import_path22 = __toESM(require("path"));
     import_fs_extra16 = __toESM(require("fs-extra"));
     init_logger();
-    logger24 = createChildLogger("data-loader");
+    logger29 = createChildLogger("data-loader");
   }
 });
 
@@ -9584,7 +10641,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
   if (envUrl) {
     autotestConfig = { ...autotestConfig, baseUrl: envUrl };
   }
-  logger25.info({ runId, runConfig, environment: activeEnv, baseUrl: autotestConfig.baseUrl }, "Run started");
+  logger30.info({ runId, runConfig, environment: activeEnv, baseUrl: autotestConfig.baseUrl }, "Run started");
   const runLog = await createRunLogFile(rootDir, runId);
   const logToFile = (level, msg, data) => {
     const ts = (/* @__PURE__ */ new Date()).toISOString();
@@ -9598,7 +10655,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
   try {
     const pairs = await collectWork(testsDir, runConfig);
     if (pairs.length === 0) {
-      logger25.warn({ runConfig }, "No tests matched the run config");
+      logger30.warn({ runConfig }, "No tests matched the run config");
     }
     const variables = await loadVariables(rootDir, runConfig.env);
     const sharedVariables = /* @__PURE__ */ new Map();
@@ -9609,16 +10666,53 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
           const rows = await loadDataRows(rootDir, pair.testCase.dataSource);
           if (rows.length > 0) {
             rows.forEach((row, idx) => expandedPairs.push({ ...pair, dataRow: row, dataRowIndex: idx }));
-            logger25.info({ caseId: pair.testCase.id, rows: rows.length }, "Expanded data-driven case");
+            logger30.info({ caseId: pair.testCase.id, rows: rows.length }, "Expanded data-driven case");
             continue;
           }
         } catch (err) {
-          logger25.warn({ err, caseId: pair.testCase.id }, "Failed to load data rows \u2014 running case once");
+          logger30.warn({ err, caseId: pair.testCase.id }, "Failed to load data rows \u2014 running case once");
         }
       }
       expandedPairs.push(pair);
     }
     ws?.broadcast("run:start", { runId, totalTests: expandedPairs.length });
+    if (autotestConfig.mcp?.proactiveHealing && autotestConfig.mcp?.enabled) {
+      logger30.info("Proactive healing enabled \u2014 validating selectors before run");
+      let mcpChecker = null;
+      try {
+        mcpChecker = new McpSession({
+          headless: autotestConfig.mcp.headless,
+          actionTimeout: autotestConfig.mcp.actionTimeout,
+          idleTimeout: autotestConfig.mcp.idleTimeout
+        });
+        for (const pair of expandedPairs) {
+          for (const step of pair.testCase.steps) {
+            if (!step.generatedCode.trim()) continue;
+            const result = await checkSelectors(mcpChecker, autotestConfig.baseUrl, step.generatedCode);
+            if (!result.ok) {
+              ws?.broadcast("healing:proactive", {
+                runId,
+                caseId: pair.testCase.id,
+                stepId: step.id,
+                instruction: step.instruction,
+                missing: result.checks.filter((c) => !c.found).map((c) => ({
+                  selector: c.selector,
+                  suggestion: c.suggestion
+                }))
+              });
+              logger30.warn(
+                { stepId: step.id, missing: result.missing },
+                `Proactive check: ${result.missing} selector(s) may be broken`
+              );
+            }
+          }
+        }
+      } catch (err) {
+        logger30.warn({ err }, "Proactive healing check failed \u2014 continuing with run");
+      } finally {
+        await mcpChecker?.disconnect();
+      }
+    }
     const smartRouter = createSmartRouter(rootDir);
     const provider = smartRouter.getPrimaryProvider();
     const budget = new HealingBudget(autotestConfig.healing.dailyBudget);
@@ -9628,7 +10722,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
       ({ suite, testCase }) => (isSuiteApiOnly(suite) || isCaseApiOnly(testCase)) && !isSuiteAudit(suite)
     );
     if (allApiOnly) {
-      logger25.info("All test cases are API-only \u2014 no browser will be launched");
+      logger30.info("All test cases are API-only \u2014 no browser will be launched");
       logToFile("info", "API-only run detected \u2014 skipping browser launch");
     }
     const browserInstances = /* @__PURE__ */ new Map();
@@ -9738,7 +10832,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
     }
     await healingReporter.flush(rootDir, runId);
     await smartRouter.getCache().persist();
-    logger25.info(
+    logger30.info(
       {
         runId,
         passed: runResult.passed,
@@ -9765,7 +10859,7 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
   let page;
   if (apiOnly) {
     page = await browserManager.createApiOnlyPage(config.baseUrl);
-    logger25.debug({ caseName: testCase.name }, "API-only case \u2014 zero browser, using standalone HTTP client");
+    logger30.debug({ caseName: testCase.name }, "API-only case \u2014 zero browser, using standalone HTTP client");
   } else {
     if (!browser) throw new Error("Browser required for UI test cases");
     context = await browserManager.newContext(browser, caseConfig, import_path25.default.join(rootDir, "results", "videos"));
@@ -9987,7 +11081,7 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
               logToFile?.("info", `  Perf: ${entry.score ?? "--"} | A11y: ${entry.a11yScore ?? "--"} | SEO: ${entry.seoScore ?? "--"} | FCP: ${entry.fcp != null ? (entry.fcp / 1e3).toFixed(2) + "s" : "--"} | LCP: ${entry.lcp != null ? (entry.lcp / 1e3).toFixed(2) + "s" : "--"} | CLS: ${entry.cls?.toFixed(3) ?? "--"} | TTFB: ${entry.ttfb != null ? (entry.ttfb / 1e3).toFixed(2) + "s" : "--"}`);
             } catch (auditErr) {
               const errMsg = auditErr instanceof Error ? auditErr.message : String(auditErr);
-              logger25.warn({ url, err: errMsg }, "Lighthouse audit failed for URL");
+              logger30.warn({ url, err: errMsg }, "Lighthouse audit failed for URL");
               logToFile?.("warn", `  Lighthouse failed for ${url}: ${errMsg}`);
               pageLoads.push({
                 url,
@@ -10008,7 +11102,7 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
           }
         } catch (lhErr) {
           const errMsg = lhErr instanceof Error ? lhErr.message : String(lhErr);
-          logger25.warn({ err: errMsg }, "Lighthouse import/init failed");
+          logger30.warn({ err: errMsg }, "Lighthouse import/init failed");
           logToFile?.("warn", `  Lighthouse init failed: ${errMsg}`);
           const recordedIndices = new Set(pageLoads.map((p) => p.stepIndex));
           for (const { s, idx } of navigatedSteps) {
@@ -10104,7 +11198,7 @@ async function collectWork(testsDir, runConfig) {
     }
     const suiteDir = await findSuiteDirById(testsDir, suite.id);
     if (!suiteDir) {
-      logger25.warn({ suiteId: suite.id }, "Suite directory not found \u2014 skipping");
+      logger30.warn({ suiteId: suite.id }, "Suite directory not found \u2014 skipping");
       continue;
     }
     const cases = await listCases(suiteDir);
@@ -10126,10 +11220,10 @@ async function loadVariables(rootDir, env) {
   try {
     const resolved = await resolveVariables(rootDir, env ?? "dev");
     const count = Object.keys(resolved).length;
-    logger25.info({ count, env: env ?? "dev", rootDir }, "Variables loaded");
+    logger30.info({ count, env: env ?? "dev", rootDir }, "Variables loaded");
     return resolved;
   } catch (err) {
-    logger25.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to load variables \u2014 running without variable substitution");
+    logger30.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to load variables \u2014 running without variable substitution");
     return {};
   }
 }
@@ -10200,7 +11294,7 @@ function buildRunResult(runId, startedAt, finishedAt, suites, environment) {
     skipped
   };
 }
-var import_path25, import_crypto6, import_fs_extra17, logger25;
+var import_path25, import_crypto6, import_fs_extra17, logger30;
 var init_runner = __esm({
   "src/engine/runner.ts"() {
     "use strict";
@@ -10213,6 +11307,8 @@ var init_runner = __esm({
     init_variable_store();
     init_result_store();
     init_router();
+    init_mcp_session();
+    init_proactive_checker();
     init_browser_manager();
     init_healing_budget();
     init_healing_report();
@@ -10223,7 +11319,7 @@ var init_runner = __esm({
     init_data_loader();
     init_step_type_detector();
     init_logger();
-    logger25 = createChildLogger("runner");
+    logger30 = createChildLogger("runner");
   }
 });
 
@@ -10257,7 +11353,7 @@ async function runRoutes(fastify) {
       };
       const wsManager = fastify.wsManager;
       const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      logger26.info({ runConfig }, "Run requested via API");
+      logger31.info({ runConfig }, "Run requested via API");
       runTests(rootDir, runConfig, autotestConfig, wsManager).then((result) => {
         wsManager.broadcast("run:complete", {
           runId: result.runId,
@@ -10266,9 +11362,9 @@ async function runRoutes(fastify) {
           skipped: result.skipped,
           duration: result.duration
         });
-        logger26.info({ runId: result.runId, status: result.status }, "API-triggered run complete");
+        logger31.info({ runId: result.runId, status: result.status }, "API-triggered run complete");
       }).catch((err) => {
-        logger26.error({ err }, "API-triggered run failed");
+        logger31.error({ err }, "API-triggered run failed");
         wsManager.broadcast("run:error", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -10299,7 +11395,7 @@ async function runRoutes(fastify) {
     }
   });
 }
-var import_zod14, logger26, ScreenshotMode, VideoMode, TraceMode, StartRunBody, ListRunsQuery;
+var import_zod14, logger31, ScreenshotMode, VideoMode, TraceMode, StartRunBody, ListRunsQuery;
 var init_run2 = __esm({
   "src/server/routes/run.ts"() {
     "use strict";
@@ -10310,7 +11406,7 @@ var init_run2 = __esm({
     init_result_store();
     init_utils2();
     init_logger();
-    logger26 = createChildLogger("routes/run");
+    logger31 = createChildLogger("routes/run");
     ScreenshotMode = import_zod14.z.enum(["off", "on", "only-on-failure"]);
     VideoMode = import_zod14.z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
     TraceMode = import_zod14.z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
@@ -10400,7 +11496,7 @@ async function parseSwaggerSpec(urlOrJson) {
                 specUrl = new URL(specUrl, url).href;
               }
               urls.unshift(specUrl);
-              logger27.info({ specUrl, pattern: pattern.source }, "Extracted spec URL from HTML page");
+              logger32.info({ specUrl, pattern: pattern.source }, "Extracted spec URL from HTML page");
             }
           }
         }
@@ -10412,7 +11508,7 @@ async function parseSwaggerSpec(urlOrJson) {
     const errors = [];
     for (const tryUrl of uniqueUrls) {
       try {
-        logger27.debug({ tryUrl }, "Trying to fetch OpenAPI spec");
+        logger32.debug({ tryUrl }, "Trying to fetch OpenAPI spec");
         const res = await fetch(tryUrl, {
           headers: { Accept: "application/json, application/yaml, */*" },
           signal: AbortSignal.timeout(15e3)
@@ -10427,7 +11523,7 @@ async function parseSwaggerSpec(urlOrJson) {
               spec = isJson ? JSON.parse(text) : import_js_yaml.default.load(text);
               if (spec && (spec.openapi || spec.swagger || spec.paths)) {
                 fetched = true;
-                logger27.info({ tryUrl, format: isYaml ? "YAML" : "JSON" }, "Successfully fetched OpenAPI spec");
+                logger32.info({ tryUrl, format: isYaml ? "YAML" : "JSON" }, "Successfully fetched OpenAPI spec");
                 break;
               }
               errors.push(`${tryUrl}: Parsed but not a valid OpenAPI spec`);
@@ -10441,7 +11537,7 @@ async function parseSwaggerSpec(urlOrJson) {
                 if (parsed && typeof parsed === "object" && (parsed.openapi || parsed.swagger || parsed.paths)) {
                   spec = parsed;
                   fetched = true;
-                  logger27.info({ tryUrl, format: "YAML (text/plain)" }, "Successfully fetched OpenAPI spec");
+                  logger32.info({ tryUrl, format: "YAML (text/plain)" }, "Successfully fetched OpenAPI spec");
                   break;
                 }
               } catch {
@@ -10530,17 +11626,17 @@ function parseSpec(spec) {
       });
     }
   }
-  logger27.info({ title, endpointCount: endpoints.length }, "Parsed OpenAPI spec");
+  logger32.info({ title, endpointCount: endpoints.length }, "Parsed OpenAPI spec");
   return { title, baseUrl, endpoints };
 }
-var import_js_yaml, logger27;
+var import_js_yaml, logger32;
 var init_swagger_parser = __esm({
   "src/ai/swagger-parser.ts"() {
     "use strict";
     init_cjs_shims();
     import_js_yaml = __toESM(require("js-yaml"));
     init_logger();
-    logger27 = createChildLogger("swagger-parser");
+    logger32 = createChildLogger("swagger-parser");
   }
 });
 
@@ -10592,11 +11688,11 @@ function adfToText(node) {
 async function fetchJiraIssue(issueKey) {
   const config = getJiraConfig();
   if (!config) {
-    throw new Error("Jira not configured \u2014 set JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN in your .env file.");
+    throw new Error("Jira not configured \u2014 set JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN in your .env file. [JIRA_NOT_CONFIGURED]");
   }
   const authHeader = "Basic " + Buffer.from(`${config.email}:${config.apiToken}`).toString("base64");
   const url = `${config.baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}?fields=summary,description,comment,issuetype,status,priority,labels,customfield_10020`;
-  logger28.info({ issueKey, url: url.replace(/\/rest.*/, "/...") }, "Fetching Jira issue");
+  logger33.info({ issueKey, url: url.replace(/\/rest.*/, "/...") }, "Fetching Jira issue");
   const res = await fetch(url, {
     method: "GET",
     headers: {
@@ -10725,19 +11821,19 @@ async function storyRoutes(fastify) {
           try {
             const jiraContent = await fetchJiraIssue(issueKey);
             storyText = buildEnrichedStory(jiraContent, parsed.data.story || void 0);
-            logger28.info({ issueKey }, "Enriched story with Jira content");
+            logger33.info({ issueKey }, "Enriched story with Jira content");
           } catch (jiraErr) {
             if (!storyText || storyText.length < 10) {
               return sendError(reply, 400, "Jira fetch failed and no user story provided", jiraErr);
             }
-            logger28.warn({ err: jiraErr }, "Failed to fetch Jira issue \u2014 proceeding with user story only");
+            logger33.warn({ err: jiraErr }, "Failed to fetch Jira issue \u2014 proceeding with user story only");
           }
         }
       }
       if (!storyText || storyText.length < 10) {
         return reply.status(400).send({ error: "Not enough content to generate tests. Provide a story or a valid Jira link." });
       }
-      logger28.info({ suiteName: parsed.data.suiteName }, "Story generation requested");
+      logger33.info({ suiteName: parsed.data.suiteName }, "Story generation requested");
       const { suiteId, suiteName } = await generateSuiteFromStory(storyText, {
         rootDir,
         outputDir: testsDir,
@@ -10765,7 +11861,7 @@ async function storyRoutes(fastify) {
     const { stories, concurrency } = parsed.data;
     const testsDir = import_path26.default.join(rootDir, "tests");
     const wsManager = fastify.wsManager;
-    logger28.info({ total: stories.length, concurrency }, "Bulk story generation requested");
+    logger33.info({ total: stories.length, concurrency }, "Bulk story generation requested");
     const enrichedStories = await Promise.all(
       stories.map(async (item) => {
         if (!item.jiraUrl) return { story: item.story, suiteName: item.suiteName };
@@ -10778,7 +11874,7 @@ async function storyRoutes(fastify) {
             suiteName: item.suiteName ?? jiraContent.summary
           };
         } catch {
-          logger28.warn({ issueKey }, "Failed to fetch Jira issue for bulk item \u2014 using raw story");
+          logger33.warn({ issueKey }, "Failed to fetch Jira issue for bulk item \u2014 using raw story");
           return { story: item.story, suiteName: item.suiteName };
         }
       })
@@ -10789,7 +11885,7 @@ async function storyRoutes(fastify) {
       wsManager,
       concurrency
     ).catch((err) => {
-      logger28.error({ err }, "Bulk story generation error");
+      logger33.error({ err }, "Bulk story generation error");
     });
     return reply.status(202).send({
       message: `Processing ${stories.length} stories in the background`,
@@ -10831,7 +11927,7 @@ async function storyRoutes(fastify) {
     }
     try {
       const spec = await parseSwaggerSpec(parsed.data.specUrl);
-      logger28.info({ title: spec.title, endpoints: spec.endpoints.length }, "Parsed OpenAPI spec");
+      logger33.info({ title: spec.title, endpoints: spec.endpoints.length }, "Parsed OpenAPI spec");
       let endpoints = spec.endpoints;
       if (parsed.data.tags && parsed.data.tags.length > 0) {
         const tagSet = new Set(parsed.data.tags.map((t) => t.toLowerCase()));
@@ -10843,7 +11939,7 @@ async function storyRoutes(fastify) {
       const MAX_ENDPOINTS = 20;
       const totalEndpoints = endpoints.length;
       if (endpoints.length > MAX_ENDPOINTS) {
-        logger28.warn({ total: endpoints.length, max: MAX_ENDPOINTS }, "Capping endpoints to max");
+        logger33.warn({ total: endpoints.length, max: MAX_ENDPOINTS }, "Capping endpoints to max");
         endpoints = endpoints.slice(0, MAX_ENDPOINTS);
       }
       const storyLines = [
@@ -10895,7 +11991,7 @@ async function storyRoutes(fastify) {
     }
   });
 }
-var import_path26, import_zod15, logger28, GenerateStoryBody, FetchJiraBody;
+var import_path26, import_zod15, logger33, GenerateStoryBody, FetchJiraBody;
 var init_story = __esm({
   "src/server/routes/story.ts"() {
     "use strict";
@@ -10906,7 +12002,7 @@ var init_story = __esm({
     init_swagger_parser();
     init_utils2();
     init_logger();
-    logger28 = createChildLogger("routes/story");
+    logger33 = createChildLogger("routes/story");
     GenerateStoryBody = import_zod15.z.object({
       story: import_zod15.z.string().default(""),
       suiteName: import_zod15.z.string().min(1).optional(),
@@ -10947,14 +12043,14 @@ async function reportRoutes(fastify) {
   fastify.delete("/report/:runId", async (req, reply) => {
     try {
       await deleteResult(rootDir, req.params.runId);
-      logger29.info({ runId: req.params.runId }, "Run result deleted");
+      logger34.info({ runId: req.params.runId }, "Run result deleted");
       return reply.status(204).send();
     } catch {
       return reply.status(404).send({ error: `Report for run "${req.params.runId}" not found` });
     }
   });
 }
-var import_zod16, logger29, ListReportsQuery;
+var import_zod16, logger34, ListReportsQuery;
 var init_report = __esm({
   "src/server/routes/report.ts"() {
     "use strict";
@@ -10963,7 +12059,7 @@ var init_report = __esm({
     init_result_store();
     init_utils2();
     init_logger();
-    logger29 = createChildLogger("routes/report");
+    logger34 = createChildLogger("routes/report");
     ListReportsQuery = import_zod16.z.object({
       limit: import_zod16.z.coerce.number().int().positive().max(100).default(20)
     });
@@ -11070,13 +12166,13 @@ function toAdf(text) {
   }));
   return { type: "doc", version: 1, content: paragraphs };
 }
-var logger30, XrayClient;
+var logger35, XrayClient;
 var init_client = __esm({
   "src/xray/client.ts"() {
     "use strict";
     init_cjs_shims();
     init_logger();
-    logger30 = createChildLogger("xray-client");
+    logger35 = createChildLogger("xray-client");
     XrayClient = class {
       config;
       authHeader;
@@ -11092,7 +12188,7 @@ var init_client = __esm({
       // ─── Jira REST API helpers ──────────────────────────────────────────────────
       async jiraRequest(method, path37, body) {
         const url = `${this.config.jiraBaseUrl}/rest/api/3${path37}`;
-        logger30.debug({ method, url }, "Jira API request");
+        logger35.debug({ method, url }, "Jira API request");
         const headers = {
           "Authorization": this.authHeader,
           "Accept": "application/json"
@@ -11107,7 +12203,7 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger30.error({ status: res.status, url, body: text }, "Jira API error");
+          logger35.error({ status: res.status, url, body: text }, "Jira API error");
           throw new Error(`Jira API ${method} ${path37} \u2192 ${res.status}: ${text}`);
         }
         if (res.status === 204) return void 0;
@@ -11139,7 +12235,7 @@ var init_client = __esm({
         const token = await this.getXrayToken();
         const baseUrl = token ? "https://xray.cloud.getxray.app/api/v2" : `${this.config.jiraBaseUrl}/rest/raven/2.0/api`;
         const url = `${baseUrl}${path37}`;
-        logger30.debug({ method, url }, "Xray API request");
+        logger35.debug({ method, url }, "Xray API request");
         const headers = {
           "Accept": "application/json"
         };
@@ -11158,7 +12254,7 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger30.error({ status: res.status, url, body: text }, "Xray API error");
+          logger35.error({ status: res.status, url, body: text }, "Xray API error");
           throw new Error(`Xray API ${method} ${path37} \u2192 ${res.status}: ${text}`);
         }
         if (res.status === 204) return void 0;
@@ -11227,7 +12323,7 @@ var init_client = __esm({
         warnings
       }
     }`;
-        logger30.info({ caseName: testCase.name, projectKey: this.config.projectKey, folderPath }, "Creating Test via Xray Cloud GraphQL");
+        logger35.info({ caseName: testCase.name, projectKey: this.config.projectKey, folderPath }, "Creating Test via Xray Cloud GraphQL");
         const result = await this.xrayGraphQL(mutation);
         if (!result?.createTest?.test) {
           throw new Error("Xray createTest returned no test data");
@@ -11236,9 +12332,9 @@ var init_client = __esm({
         const jiraKey = test.jira?.key ?? "";
         const warnings = result.createTest.warnings;
         if (warnings && warnings.length > 0) {
-          logger30.warn({ warnings, jiraKey }, "Xray createTest warnings");
+          logger35.warn({ warnings, jiraKey }, "Xray createTest warnings");
         }
-        logger30.info({ issueId: test.issueId, jiraKey, stepCount: testCase.steps.length, folderPath }, "Xray Test created via GraphQL");
+        logger35.info({ issueId: test.issueId, jiraKey, stepCount: testCase.steps.length, folderPath }, "Xray Test created via GraphQL");
         return { id: test.issueId, key: jiraKey, self: "" };
       }
       /** Xray Server/DC: create via Jira REST API */
@@ -11251,7 +12347,7 @@ var init_client = __esm({
           issuetype: { name: issueType },
           labels: ["assuremind", ...testCase.tags]
         };
-        logger30.info({ caseName: testCase.name, projectKey: this.config.projectKey }, "Creating Xray Test via Jira REST");
+        logger35.info({ caseName: testCase.name, projectKey: this.config.projectKey }, "Creating Xray Test via Jira REST");
         const result = await this.jiraRequest("POST", "/issue", { fields });
         if (testCase.steps.length > 0) {
           await this.addTestStepsServerDC(result.key, testCase.steps);
@@ -11267,7 +12363,7 @@ var init_client = __esm({
           description: toAdf(testCase.description || `Automated test case: ${testCase.name}`),
           labels: ["assuremind", ...testCase.tags]
         };
-        logger30.info({ issueKey: testIssue.key, caseName: testCase.name }, "Updating Xray Test");
+        logger35.info({ issueKey: testIssue.key, caseName: testCase.name }, "Updating Xray Test");
         await this.jiraRequest("PUT", `/issue/${testIssue.key}`, { fields });
         if (testCase.steps.length > 0) {
           await this.replaceTestSteps(testIssue, testCase.steps);
@@ -11306,7 +12402,7 @@ var init_client = __esm({
         warnings
       }
     }`;
-        logger30.info({ suiteName: suite.name, projectKey: this.config.projectKey, testCount: testIssueIds?.length }, "Creating Test Set via Xray Cloud GraphQL");
+        logger35.info({ suiteName: suite.name, projectKey: this.config.projectKey, testCount: testIssueIds?.length }, "Creating Test Set via Xray Cloud GraphQL");
         const result = await this.xrayGraphQL(mutation);
         if (!result?.createTestSet?.testSet) {
           throw new Error("Xray createTestSet returned no data");
@@ -11315,9 +12411,9 @@ var init_client = __esm({
         const jiraKey = testSet.jira?.key ?? "";
         const warnings = result.createTestSet.warnings;
         if (warnings && warnings.length > 0) {
-          logger30.warn({ warnings, jiraKey }, "Xray createTestSet warnings");
+          logger35.warn({ warnings, jiraKey }, "Xray createTestSet warnings");
         }
-        logger30.info({ issueId: testSet.issueId, jiraKey }, "Xray Test Set created via GraphQL");
+        logger35.info({ issueId: testSet.issueId, jiraKey }, "Xray Test Set created via GraphQL");
         return { id: testSet.issueId, key: jiraKey, self: "" };
       }
       /** Xray Server/DC: create via Jira REST API */
@@ -11330,7 +12426,7 @@ var init_client = __esm({
           issuetype: { name: issueType },
           labels: ["assuremind", ...suite.tags]
         };
-        logger30.info({ suiteName: suite.name, projectKey: this.config.projectKey }, "Creating Xray Test Set via Jira REST");
+        logger35.info({ suiteName: suite.name, projectKey: this.config.projectKey }, "Creating Xray Test Set via Jira REST");
         const result = await this.jiraRequest("POST", "/issue", { fields });
         return { id: result.id, key: result.key, self: result.self };
       }
@@ -11343,7 +12439,7 @@ var init_client = __esm({
           description: toAdf(suite.description || `Automated test suite: ${suite.name}`),
           labels: ["assuremind", ...suite.tags]
         };
-        logger30.info({ issueKey, suiteName: suite.name }, "Updating Xray Test Set");
+        logger35.info({ issueKey, suiteName: suite.name }, "Updating Xray Test Set");
         await this.jiraRequest("PUT", `/issue/${issueKey}`, { fields });
       }
       // ─── Test Steps ────────────────────────────────────────────────────────────
@@ -11360,7 +12456,7 @@ var init_client = __esm({
         if (this.isXrayCloud) {
           const xrayId = await this.resolveXrayIssueId(testIssue.key, "Test");
           if (!xrayId) {
-            logger30.warn({ testKey: testIssue.key }, "Cannot add steps \u2014 Test not found in Xray yet");
+            logger35.warn({ testKey: testIssue.key }, "Cannot add steps \u2014 Test not found in Xray yet");
             return;
           }
           await this.addTestStepsCloud(xrayId, steps);
@@ -11395,16 +12491,16 @@ var init_client = __esm({
           } catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
             if (errMsg.includes("not found")) {
-              logger30.warn({ xrayIssueId }, "Xray issue not found during step add \u2014 aborting");
+              logger35.warn({ xrayIssueId }, "Xray issue not found during step add \u2014 aborting");
               break;
             }
-            logger30.warn({ xrayIssueId, step: action, err: errMsg }, "Failed to add test step");
+            logger35.warn({ xrayIssueId, step: action, err: errMsg }, "Failed to add test step");
           }
         }
         if (added > 0) {
-          logger30.info({ xrayIssueId, added, total: steps.length }, "Test steps added via Xray Cloud GraphQL");
+          logger35.info({ xrayIssueId, added, total: steps.length }, "Test steps added via Xray Cloud GraphQL");
         } else if (steps.length > 0) {
-          logger30.warn({ xrayIssueId }, "Failed to add any steps");
+          logger35.warn({ xrayIssueId }, "Failed to add any steps");
         }
       }
       /** Xray Server/DC — use REST API /test/{key}/step */
@@ -11417,14 +12513,14 @@ var init_client = __esm({
         }));
         try {
           await this.xrayRequest("PUT", `/test/${testIssueKey}/step`, xraySteps);
-          logger30.debug({ testIssueKey, stepCount: steps.length }, "Test steps added");
+          logger35.debug({ testIssueKey, stepCount: steps.length }, "Test steps added");
         } catch (err) {
-          logger30.warn({ testIssueKey, err }, "Bulk step add failed, trying one-by-one");
+          logger35.warn({ testIssueKey, err }, "Bulk step add failed, trying one-by-one");
           for (const step of xraySteps) {
             try {
               await this.xrayRequest("POST", `/test/${testIssueKey}/step`, step);
             } catch (stepErr) {
-              logger30.warn({ testIssueKey, step: step.index, err: stepErr }, "Individual step add failed");
+              logger35.warn({ testIssueKey, step: step.index, err: stepErr }, "Individual step add failed");
             }
           }
         }
@@ -11436,7 +12532,7 @@ var init_client = __esm({
         if (this.isXrayCloud) {
           const xrayId = await this.resolveXrayIssueId(testIssue.key, "Test");
           if (!xrayId) {
-            logger30.warn({ testKey: testIssue.key }, "Cannot replace steps \u2014 Test not found in Xray");
+            logger35.warn({ testKey: testIssue.key }, "Cannot replace steps \u2014 Test not found in Xray");
             return;
           }
           await this.addTestStepsCloud(xrayId, steps);
@@ -11448,7 +12544,7 @@ var init_client = __esm({
             await this.xrayRequest("DELETE", `/test/${testIssue.key}/step/${step.id}`);
           }
         } catch {
-          logger30.debug({ testIssueKey: testIssue.key }, "No existing steps to delete (or endpoint unavailable)");
+          logger35.debug({ testIssueKey: testIssue.key }, "No existing steps to delete (or endpoint unavailable)");
         }
         await this.addTestStepsServerDC(testIssue.key, steps);
       }
@@ -11467,9 +12563,9 @@ var init_client = __esm({
             await this.xrayRequest("POST", `/testset/${testSet.key}/test`, {
               add: tests.map((t) => t.key)
             });
-            logger30.info({ testSetKey: testSet.key, count: tests.length }, "Tests linked to Test Set");
+            logger35.info({ testSetKey: testSet.key, count: tests.length }, "Tests linked to Test Set");
           } catch (err) {
-            logger30.warn({ testSetKey: testSet.key, err }, "Xray link API failed, trying Jira issue links");
+            logger35.warn({ testSetKey: testSet.key, err }, "Xray link API failed, trying Jira issue links");
             await this.linkViaJiraIssueLinks(testSet.key, tests.map((t) => t.key));
           }
         }
@@ -11479,10 +12575,10 @@ var init_client = __esm({
        * Resolves Xray internal IDs first (they differ from Jira numeric IDs).
        */
       async linkTestsCloud(testSet, tests) {
-        logger30.info({ testSetKey: testSet.key, testKeys: tests.map((t) => t.key) }, "Resolving Xray IDs for linking");
+        logger35.info({ testSetKey: testSet.key, testKeys: tests.map((t) => t.key) }, "Resolving Xray IDs for linking");
         const xrayTestSetId = await this.resolveXrayIssueId(testSet.key, "Test Set");
         if (!xrayTestSetId) {
-          logger30.error({ testSetKey: testSet.key }, "Cannot link \u2014 Test Set not found in Xray");
+          logger35.error({ testSetKey: testSet.key }, "Cannot link \u2014 Test Set not found in Xray");
           return;
         }
         const xrayTestIds = [];
@@ -11491,11 +12587,11 @@ var init_client = __esm({
           if (xrayTestId) {
             xrayTestIds.push(xrayTestId);
           } else {
-            logger30.warn({ testKey: test.key }, "Could not resolve Xray ID for test \u2014 skipping");
+            logger35.warn({ testKey: test.key }, "Could not resolve Xray ID for test \u2014 skipping");
           }
         }
         if (xrayTestIds.length === 0) {
-          logger30.warn({ testSetKey: testSet.key }, "No test IDs resolved \u2014 skipping link");
+          logger35.warn({ testSetKey: testSet.key }, "No test IDs resolved \u2014 skipping link");
           return;
         }
         try {
@@ -11511,7 +12607,7 @@ var init_client = __esm({
         }`
           );
           if (result) {
-            logger30.info({
+            logger35.info({
               testSetKey: testSet.key,
               xrayTestSetId,
               count: xrayTestIds.length,
@@ -11520,7 +12616,7 @@ var init_client = __esm({
             }, "Tests linked to Test Set via Xray Cloud");
           }
         } catch (err) {
-          logger30.error({ testSetKey: testSet.key, xrayTestSetId, err: err instanceof Error ? err.message : String(err) }, "linkTestsCloud failed");
+          logger35.error({ testSetKey: testSet.key, xrayTestSetId, err: err instanceof Error ? err.message : String(err) }, "linkTestsCloud failed");
         }
       }
       sleep(ms) {
@@ -11536,7 +12632,7 @@ var init_client = __esm({
               outwardIssue: { key: testKey }
             });
           } catch (linkErr) {
-            logger30.error({ testSetKey, testKey, err: linkErr }, "Failed to link test to test set");
+            logger35.error({ testSetKey, testKey, err: linkErr }, "Failed to link test to test set");
           }
         }
       }
@@ -11549,7 +12645,7 @@ var init_client = __esm({
        */
       async createFolderAndAddTests(folderName, tests) {
         if (!this.isXrayCloud) {
-          logger30.debug("Folder creation skipped \u2014 only supported on Xray Cloud");
+          logger35.debug("Folder creation skipped \u2014 only supported on Xray Cloud");
           return;
         }
         if (tests.length === 0) return;
@@ -11571,11 +12667,11 @@ var init_client = __esm({
             }
           }`
             );
-            logger30.info({ folderPath, projectId }, "Test Repository folder created");
+            logger35.info({ folderPath, projectId }, "Test Repository folder created");
           } catch (folderErr) {
             const errMsg = folderErr instanceof Error ? folderErr.message : String(folderErr);
             if (errMsg.includes("already exists")) {
-              logger30.info({ folderPath }, "Test Repository folder already exists \u2014 reusing");
+              logger35.info({ folderPath }, "Test Repository folder already exists \u2014 reusing");
             } else {
               throw folderErr;
             }
@@ -11586,14 +12682,14 @@ var init_client = __esm({
             if (xrayId) {
               xrayTestIds.push(xrayId);
             } else {
-              logger30.warn({ testKey: test.key }, "Could not resolve Xray ID for folder \u2014 skipping");
+              logger35.warn({ testKey: test.key }, "Could not resolve Xray ID for folder \u2014 skipping");
             }
           }
           if (xrayTestIds.length === 0) {
-            logger30.warn({ folderPath }, "No Xray IDs resolved \u2014 cannot add tests to folder");
+            logger35.warn({ folderPath }, "No Xray IDs resolved \u2014 cannot add tests to folder");
             return;
           }
-          logger30.info({ folderPath, xrayTestIds }, "Adding tests to folder with resolved Xray IDs");
+          logger35.info({ folderPath, xrayTestIds }, "Adding tests to folder with resolved Xray IDs");
           try {
             await this.xrayGraphQL(
               `mutation {
@@ -11607,12 +12703,12 @@ var init_client = __esm({
             }
           }`
             );
-            logger30.info({ folderPath, count: xrayTestIds.length }, "Tests added to folder");
+            logger35.info({ folderPath, count: xrayTestIds.length }, "Tests added to folder");
           } catch (addErr) {
-            logger30.warn({ folderPath, err: addErr instanceof Error ? addErr.message : String(addErr) }, "Failed to add tests to folder");
+            logger35.warn({ folderPath, err: addErr instanceof Error ? addErr.message : String(addErr) }, "Failed to add tests to folder");
           }
         } catch (err) {
-          logger30.error({ folderName, err: err instanceof Error ? err.message : String(err) }, "FAILED to create folder or add tests \u2014 tests exist but are unorganized");
+          logger35.error({ folderName, err: err instanceof Error ? err.message : String(err) }, "FAILED to create folder or add tests \u2014 tests exist but are unorganized");
         }
       }
       // ─── Xray Cloud GraphQL helper ────────────────────────────────────────────
@@ -11630,12 +12726,12 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger30.warn({ status: res.status, body: text }, "Xray Cloud GraphQL request failed");
+          logger35.warn({ status: res.status, body: text }, "Xray Cloud GraphQL request failed");
           throw new Error(`Xray GraphQL \u2192 ${res.status}: ${text}`);
         }
         const result = await res.json();
         if (result.errors && result.errors.length > 0) {
-          logger30.warn({ errors: result.errors }, "Xray Cloud GraphQL returned errors");
+          logger35.warn({ errors: result.errors }, "Xray Cloud GraphQL returned errors");
           throw new Error(`Xray GraphQL errors: ${result.errors.map((e) => e.message).join("; ")}`);
         }
         return result.data ?? null;
@@ -11653,7 +12749,7 @@ var init_client = __esm({
         const delays = [0, 5e3, 1e4, 2e4];
         for (let attempt = 0; attempt < delays.length; attempt++) {
           if (delays[attempt] > 0) {
-            logger30.info({ jiraKey, attempt, delay: delays[attempt] }, `Waiting ${delays[attempt] / 1e3}s before retry`);
+            logger35.info({ jiraKey, attempt, delay: delays[attempt] }, `Waiting ${delays[attempt] / 1e3}s before retry`);
             await this.sleep(delays[attempt]);
           }
           try {
@@ -11666,21 +12762,21 @@ var init_client = __esm({
               }
             }
           }`;
-            logger30.info({ jiraKey, attempt, query: queryName }, `Querying Xray for ${type} issueId`);
+            logger35.info({ jiraKey, attempt, query: queryName }, `Querying Xray for ${type} issueId`);
             const result = await this.xrayGraphQL(gql);
             const queryResult = result?.[resultField];
-            logger30.info({ jiraKey, attempt, total: queryResult?.total, resultCount: queryResult?.results?.length, raw: JSON.stringify(queryResult) }, `Xray ${queryName} response`);
+            logger35.info({ jiraKey, attempt, total: queryResult?.total, resultCount: queryResult?.results?.length, raw: JSON.stringify(queryResult) }, `Xray ${queryName} response`);
             const items = queryResult?.results;
             if (items && items.length > 0 && items[0].issueId) {
-              logger30.info({ jiraKey, xrayIssueId: items[0].issueId, attempt }, `Resolved Xray issueId for ${type}`);
+              logger35.info({ jiraKey, xrayIssueId: items[0].issueId, attempt }, `Resolved Xray issueId for ${type}`);
               return items[0].issueId;
             }
-            logger30.warn({ jiraKey, attempt, total: queryResult?.total }, `Xray has not indexed ${type} yet \u2014 no results`);
+            logger35.warn({ jiraKey, attempt, total: queryResult?.total }, `Xray has not indexed ${type} yet \u2014 no results`);
           } catch (err) {
-            logger30.warn({ jiraKey, attempt, err: err instanceof Error ? err.message : String(err) }, `resolveXrayIssueId attempt ${attempt} failed`);
+            logger35.warn({ jiraKey, attempt, err: err instanceof Error ? err.message : String(err) }, `resolveXrayIssueId attempt ${attempt} failed`);
           }
         }
-        logger30.error({ jiraKey }, `Could not resolve Xray issueId for ${type} after ${delays.length} attempts`);
+        logger35.error({ jiraKey }, `Could not resolve Xray issueId for ${type} after ${delays.length} attempts`);
         return null;
       }
       // ─── Validation ────────────────────────────────────────────────────────────
@@ -11760,7 +12856,7 @@ async function readXrayMapping(rootDir) {
   const raw = await readJson(filePath);
   const result = XrayMappingFileSchema.safeParse(raw);
   if (!result.success) {
-    logger31.warn({ path: filePath, errors: result.error.issues }, "Invalid xray-mapping.json \u2014 returning empty");
+    logger36.warn({ path: filePath, errors: result.error.issues }, "Invalid xray-mapping.json \u2014 returning empty");
     return { projectKey: "", suites: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
   return result.data;
@@ -11770,7 +12866,7 @@ async function writeXrayMapping(rootDir, mapping) {
   await import_fs_extra20.default.ensureDir(import_path29.default.dirname(filePath));
   const data = { ...mapping, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await atomicWriteJson(filePath, data);
-  logger31.debug({ path: filePath }, "Xray mapping written");
+  logger36.debug({ path: filePath }, "Xray mapping written");
 }
 function findSuiteMapping(mapping, suiteId) {
   return mapping.suites.find((s) => s.suiteId === suiteId);
@@ -11802,7 +12898,7 @@ function upsertCaseMapping(suiteMapping, caseMapping) {
   }
   return { ...suiteMapping, cases };
 }
-var import_path29, import_fs_extra20, logger31, MAPPING_FILE;
+var import_path29, import_fs_extra20, logger36, MAPPING_FILE;
 var init_xray_store = __esm({
   "src/storage/xray-store.ts"() {
     "use strict";
@@ -11812,7 +12908,7 @@ var init_xray_store = __esm({
     init_xray();
     init_utils();
     init_logger();
-    logger31 = createChildLogger("xray-store");
+    logger36 = createChildLogger("xray-store");
     MAPPING_FILE = "xray-mapping.json";
   }
 });
@@ -11833,7 +12929,7 @@ function caseHash(tc) {
     steps: tc.steps.map((s) => ({ instruction: s.instruction, code: s.generatedCode }))
   });
 }
-var import_crypto7, logger32, XrayService;
+var import_crypto7, logger37, XrayService;
 var init_service = __esm({
   "src/xray/service.ts"() {
     "use strict";
@@ -11844,7 +12940,7 @@ var init_service = __esm({
     init_suite_store();
     init_case_store();
     init_logger();
-    logger32 = createChildLogger("xray-service");
+    logger37 = createChildLogger("xray-service");
     XrayService = class {
       client;
       rootDir;
@@ -11952,7 +13048,7 @@ var init_service = __esm({
         const results = [];
         let sm = findSuiteMapping(mapping, suiteId);
         if (sm) {
-          logger32.info({ suiteId }, "Suite already mapped in Xray \u2014 delegating to sync");
+          logger37.info({ suiteId }, "Suite already mapped in Xray \u2014 delegating to sync");
           return this.syncSuite(suiteId);
         }
         const folderPath = `/${suite.name}`;
@@ -11981,7 +13077,7 @@ var init_service = __esm({
             await writeXrayMapping(this.rootDir, mapping);
             createdTestIssueIds.push(test.id);
             results.push({ success: true, caseId: tc.id, xrayKey: test.key, xrayId: test.id, action: "created" });
-            logger32.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
+            logger37.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
           } catch (err) {
             results.push({
               success: false,
@@ -12001,9 +13097,9 @@ var init_service = __esm({
         if (allTestPairs.length > 0) {
           try {
             await this.client.createFolderAndAddTests(suite.name, allTestPairs);
-            logger32.info({ folderPath, testCount: allTestPairs.length }, "Tests organized into folder");
+            logger37.info({ folderPath, testCount: allTestPairs.length }, "Tests organized into folder");
           } catch (err) {
-            logger32.warn({ folderPath, err: err instanceof Error ? err.message : String(err) }, "Folder organization failed (non-fatal)");
+            logger37.warn({ folderPath, err: err instanceof Error ? err.message : String(err) }, "Folder organization failed (non-fatal)");
           }
         }
         if (!findSuiteMapping(mapping, suiteId)?.xrayTestSetId) {
@@ -12020,7 +13116,7 @@ var init_service = __esm({
             mapping = upsertSuiteMapping(mapping, sm);
             await writeXrayMapping(this.rootDir, mapping);
             results.push({ success: true, suiteId, xrayKey: testSet.key, action: "created" });
-            logger32.info({ suiteId, xrayKey: testSet.key, testCount: createdTestIssueIds.length }, "Test Set created with linked tests");
+            logger37.info({ suiteId, xrayKey: testSet.key, testCount: createdTestIssueIds.length }, "Test Set created with linked tests");
           } catch (err) {
             results.push({
               success: false,
@@ -12089,7 +13185,7 @@ var init_service = __esm({
               { key: caseResult.result.xrayKey, id: caseResult.result.xrayId }
             ]);
           } catch (err) {
-            logger32.warn({ err: err instanceof Error ? err.message : String(err) }, "Folder organization failed for single case (non-fatal)");
+            logger37.warn({ err: err instanceof Error ? err.message : String(err) }, "Folder organization failed for single case (non-fatal)");
           }
         }
         if (caseResult.result.xrayId && sm.xrayTestSetIssueId) {
@@ -12099,7 +13195,7 @@ var init_service = __esm({
               [{ key: caseResult.result.xrayKey ?? "", id: caseResult.result.xrayId }]
             );
           } catch (err) {
-            logger32.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to link test to test set");
+            logger37.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to link test to test set");
           }
         }
         return this.summarizeResults([caseResult.result]);
@@ -12130,7 +13226,7 @@ var init_service = __esm({
           const updatedSm = upsertCaseMapping(sm, cm);
           const updatedMapping = upsertSuiteMapping(mapping, updatedSm);
           await writeXrayMapping(this.rootDir, updatedMapping);
-          logger32.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
+          logger37.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
           return {
             result: { success: true, caseId: tc.id, xrayKey: test.key, xrayId: test.id, action: "created" },
             mapping: updatedMapping
@@ -12196,7 +13292,7 @@ var init_service = __esm({
             mapping = upsertSuiteMapping(mapping, sm);
             await writeXrayMapping(this.rootDir, mapping);
             results.push({ success: true, suiteId, xrayKey: testSet.key, action: "created" });
-            logger32.info({ suiteId, xrayKey: testSet.key }, "Test Set created during sync (was missing)");
+            logger37.info({ suiteId, xrayKey: testSet.key }, "Test Set created during sync (was missing)");
           } catch (err) {
             results.push({
               success: false,
@@ -12292,11 +13388,11 @@ var init_service = __esm({
                 try {
                   await this.client.createFolderAndAddTests(suite.name, newTests);
                 } catch (folderErr) {
-                  logger32.warn({ err: folderErr instanceof Error ? folderErr.message : String(folderErr) }, "Folder organization failed for synced tests (non-fatal)");
+                  logger37.warn({ err: folderErr instanceof Error ? folderErr.message : String(folderErr) }, "Folder organization failed for synced tests (non-fatal)");
                 }
               }
             } catch (err) {
-              logger32.warn({ err }, "Failed to link new tests to test set");
+              logger37.warn({ err }, "Failed to link new tests to test set");
             }
           }
         }
@@ -12414,9 +13510,11 @@ async function xrayRoutes(fastify) {
   function requireService(reply) {
     const service = createService();
     if (!service) {
-      reply.status(400).send({
+      reply.status(422).send({
         error: "Xray integration not configured",
-        details: "Set JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN, and XRAY_PROJECT_KEY in your .env file."
+        detail: "Set JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN, and XRAY_PROJECT_KEY in your .env file.",
+        code: "CONFIG_ERROR",
+        featureHint: "XRAY_NOT_CONFIGURED"
       });
       return null;
     }
@@ -12451,7 +13549,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger33.info("Creating all suites and cases in Xray");
+      logger38.info("Creating all suites and cases in Xray");
       const result = await service.createAll();
       return reply.send(result);
     } catch (err) {
@@ -12462,7 +13560,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger33.info({ suiteId: req.params.suiteId }, "Creating suite in Xray");
+      logger38.info({ suiteId: req.params.suiteId }, "Creating suite in Xray");
       const result = await service.createSuite(req.params.suiteId);
       return reply.send(result);
     } catch (err) {
@@ -12486,7 +13584,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger33.info("Syncing all suites and cases with Xray");
+      logger38.info("Syncing all suites and cases with Xray");
       const result = await service.syncAll();
       return reply.send(result);
     } catch (err) {
@@ -12497,7 +13595,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger33.info({ suiteId: req.params.suiteId }, "Syncing suite with Xray");
+      logger38.info({ suiteId: req.params.suiteId }, "Syncing suite with Xray");
       const result = await service.syncSuite(req.params.suiteId);
       return reply.send(result);
     } catch (err) {
@@ -12528,7 +13626,7 @@ async function xrayRoutes(fastify) {
     }
   });
 }
-var logger33;
+var logger38;
 var init_xray2 = __esm({
   "src/server/routes/xray.ts"() {
     "use strict";
@@ -12536,12 +13634,12 @@ var init_xray2 = __esm({
     init_service();
     init_utils2();
     init_logger();
-    logger33 = createChildLogger("xray-routes");
+    logger38 = createChildLogger("xray-routes");
   }
 });
 
 // src/git/service.ts
-var import_simple_git, import_fs_extra21, import_path30, logger34, GitService;
+var import_simple_git, import_fs_extra21, import_path30, logger39, GitService;
 var init_service2 = __esm({
   "src/git/service.ts"() {
     "use strict";
@@ -12550,7 +13648,7 @@ var init_service2 = __esm({
     import_fs_extra21 = __toESM(require("fs-extra"));
     import_path30 = __toESM(require("path"));
     init_logger();
-    logger34 = createChildLogger("git-service");
+    logger39 = createChildLogger("git-service");
     GitService = class {
       git;
       rootDir;
@@ -12612,7 +13710,7 @@ var init_service2 = __esm({
         try {
           await this.git.checkout(branch);
           this.broadcastLog("Checkout branch", "done", branch);
-          logger34.info({ branch }, "Switched branch");
+          logger39.info({ branch }, "Switched branch");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           this.broadcastLog("Checkout branch", "error", msg);
@@ -12630,7 +13728,7 @@ var init_service2 = __esm({
           const hash = result.commit || "unknown";
           this.broadcastLog("Create commit", "done", hash);
           this.broadcastDone("commit");
-          logger34.info({ hash, message }, "Commit created");
+          logger39.info({ hash, message }, "Commit created");
           return hash;
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -12647,7 +13745,7 @@ var init_service2 = __esm({
           await this.git.pull(void 0, void 0, opts);
           this.broadcastLog(label, "done", rebase ? "Rebase successful" : "Pull successful");
           this.broadcastDone("pull");
-          logger34.info({ rebase }, "Pull completed");
+          logger39.info({ rebase }, "Pull completed");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (msg.includes("CONFLICT") || msg.includes("conflict") || msg.includes("could not apply")) {
@@ -12669,7 +13767,7 @@ var init_service2 = __esm({
           await this.git.push();
           this.broadcastLog("Push to origin", "done");
           this.broadcastDone("push");
-          logger34.info("Push completed");
+          logger39.info("Push completed");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           this.broadcastLog("Push to origin", "error", msg);
@@ -12716,7 +13814,7 @@ var init_service2 = __esm({
             throw pushErr;
           }
           this.broadcastDone("full-sync");
-          logger34.info("Full sync completed");
+          logger39.info("Full sync completed");
         } catch (err) {
           this.broadcastDone("full-sync");
           throw err;
@@ -12778,7 +13876,7 @@ var init_service2 = __esm({
         const fullPath = import_path30.default.join(this.rootDir, filePath);
         await import_fs_extra21.default.writeFile(fullPath, resolvedContent, "utf-8");
         await this.git.add(filePath);
-        logger34.info({ filePath }, "Conflict resolved");
+        logger39.info({ filePath }, "Conflict resolved");
       }
       async continueRebase() {
         this.broadcastLog("Continuing rebase...", "running");
@@ -12813,7 +13911,8 @@ function fakePageContext(content) {
     title: "Git Operations",
     interactiveElements: "",
     htmlSnapshot: content,
-    previousSteps: []
+    previousSteps: [],
+    variables: {}
   };
 }
 async function generateCommitMessage(diff) {
@@ -12852,10 +13951,10 @@ async function generateCommitMessage(diff) {
     cleaned = cleaned.replace(/^["'`]+|["'`]+$/g, "");
     cleaned = cleaned.replace(/^(commit message:?\s*)/i, "");
     cleaned = cleaned.split("\n")[0].trim();
-    logger35.info({ messageLength: cleaned.length }, "AI commit message generated");
+    logger40.info({ messageLength: cleaned.length }, "AI commit message generated");
     return cleaned || "chore: update files";
   } catch (err) {
-    logger35.warn({ err: err instanceof Error ? err.message : String(err) }, "AI commit message generation failed");
+    logger40.warn({ err: err instanceof Error ? err.message : String(err) }, "AI commit message generation failed");
     return "chore: update files";
   }
 }
@@ -12882,21 +13981,21 @@ ${theirs}`);
     const provider = createProvider(void 0, { temperature: 0.4 });
     let result = await provider.generateCode(instruction, context);
     result = result.replace(/^```[\w]*\n?/, "").replace(/\n?```$/, "");
-    logger35.info({ filePath, resultLength: result.length }, "AI conflict resolution generated");
+    logger40.info({ filePath, resultLength: result.length }, "AI conflict resolution generated");
     return result;
   } catch (err) {
-    logger35.warn({ filePath, err: err instanceof Error ? err.message : String(err) }, "AI conflict resolution failed");
+    logger40.warn({ filePath, err: err instanceof Error ? err.message : String(err) }, "AI conflict resolution failed");
     throw err;
   }
 }
-var logger35;
+var logger40;
 var init_ai = __esm({
   "src/git/ai.ts"() {
     "use strict";
     init_cjs_shims();
     init_router();
     init_logger();
-    logger35 = createChildLogger("git-ai");
+    logger40 = createChildLogger("git-ai");
   }
 });
 
@@ -12913,7 +14012,7 @@ async function gitRoutes(fastify) {
       _isGitRepo = true;
     } catch {
       _isGitRepo = false;
-      logger36.info("Project directory is not a git repository \u2014 git features disabled");
+      logger41.info("Project directory is not a git repository \u2014 git features disabled");
     }
     return _isGitRepo;
   };
@@ -13116,7 +14215,7 @@ async function gitRoutes(fastify) {
     }
   });
 }
-var import_path31, import_zod18, logger36, CheckoutBody, CommitBody, PullBody, FullSyncBody, ResolveConflictBody, ResolveConflictAIBody;
+var import_path31, import_zod18, logger41, CheckoutBody, CommitBody, PullBody, FullSyncBody, ResolveConflictBody, ResolveConflictAIBody;
 var init_git = __esm({
   "src/server/routes/git.ts"() {
     "use strict";
@@ -13127,7 +14226,7 @@ var init_git = __esm({
     init_ai();
     init_utils2();
     init_logger();
-    logger36 = createChildLogger("git-routes");
+    logger41 = createChildLogger("git-routes");
     CheckoutBody = import_zod18.z.object({ branch: import_zod18.z.string().min(1) });
     CommitBody = import_zod18.z.object({ message: import_zod18.z.string().min(1) });
     PullBody = import_zod18.z.object({ rebase: import_zod18.z.boolean().optional() });
@@ -13234,7 +14333,7 @@ async function dataFileRoutes(fastify) {
         }
       } catch {
       }
-      logger37.info({ filename: safeName, rowCount }, "Data file uploaded");
+      logger42.info({ filename: safeName, rowCount }, "Data file uploaded");
       return reply.status(201).send({
         filename: safeName,
         path: `data/${safeName}`,
@@ -13252,7 +14351,7 @@ async function dataFileRoutes(fastify) {
       const content = String(body.content ?? "");
       await import_fs_extra22.default.ensureDir(dataDir);
       await import_fs_extra22.default.writeFile(filePath, content, "utf8");
-      logger37.info({ filename }, "Data file updated");
+      logger42.info({ filename }, "Data file updated");
       return reply.send({ filename, path: `data/${filename}` });
     } catch (err) {
       return sendError(reply, 500, "Failed to update data file", err);
@@ -13266,14 +14365,14 @@ async function dataFileRoutes(fastify) {
         return reply.status(404).send({ error: `Data file "${filename}" not found` });
       }
       await import_fs_extra22.default.remove(filePath);
-      logger37.info({ filename }, "Data file deleted");
+      logger42.info({ filename }, "Data file deleted");
       return reply.status(204).send();
     } catch (err) {
       return sendError(reply, 500, "Failed to delete data file", err);
     }
   });
 }
-var import_path32, import_fs_extra22, logger37, ALLOWED_EXTENSIONS;
+var import_path32, import_fs_extra22, logger42, ALLOWED_EXTENSIONS;
 var init_data_files = __esm({
   "src/server/routes/data-files.ts"() {
     "use strict";
@@ -13282,7 +14381,7 @@ var init_data_files = __esm({
     import_fs_extra22 = __toESM(require("fs-extra"));
     init_utils2();
     init_logger();
-    logger37 = createChildLogger("routes/data-files");
+    logger42 = createChildLogger("routes/data-files");
     ALLOWED_EXTENSIONS = [".json", ".csv"];
   }
 });
@@ -13820,15 +14919,15 @@ async function startServer(options) {
   await fastify.register(stepLibraryRoutes, { prefix: "/api" });
   await registerStatic(fastify, rootDir);
   await fastify.listen({ port, host: "127.0.0.1" });
-  logger38.info({ port, rootDir }, `Assuremind Studio listening on http://127.0.0.1:${port}`);
+  logger43.info({ port, rootDir }, `Assuremind Studio listening on http://127.0.0.1:${port}`);
   return {
     async close() {
       await fastify.close();
-      logger38.info("Server closed");
+      logger43.info("Server closed");
     }
   };
 }
-var import_fastify, import_cors, import_websocket, logger38;
+var import_fastify, import_cors, import_websocket, logger43;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
@@ -13859,7 +14958,7 @@ var init_server = __esm({
     init_flakiness();
     init_step_library();
     init_logger();
-    logger38 = createChildLogger("server");
+    logger43 = createChildLogger("server");
   }
 });
 
@@ -13875,13 +14974,11 @@ async function runStudio(options = {}) {
   });
   process.stdout.write("\n");
   printInfo("Starting Assuremind Studio\u2026\n");
-  try {
-    validateEnv();
-  } catch (err) {
-    printError(
-      err instanceof ConfigError ? err.message : `Environment validation failed: ${err instanceof Error ? err.message : String(err)}`
+  const env = tryGetEnv();
+  if (!env) {
+    printWarn(
+      "AI provider not configured. The Studio will start, but AI features\n  (test generation, code generation, self-healing) require a valid\n  AI_PROVIDER and its API key in your .env file.\n  See .env.example for details.\n"
     );
-    process.exit(1);
   }
   let port;
   try {