assuremind 1.1.2 → 1.2.1

package/dist/cli/index.js

@@ -186,6 +186,44 @@ var init_config = __esm({
       activeProfile: import_zod.z.string().optional(),
       /** Playwright device descriptor name for emulation (e.g. 'iPhone 15 Pro'). */
       device: import_zod.z.string().optional(),
+      /**
+       * RAG (Retrieval-Augmented Generation) — semantic memory from past runs.
+       *
+       * The AI learns from every generation and healing event:
+       *   - Code Corpus: retrieve similar past steps during generation
+       *   - Healing Corpus: retrieve similar past fixes during self-healing
+       *   - Error Catalog: track recurring error patterns for preventive generation
+       */
+      rag: import_zod.z.object({
+        /** Master switch for RAG memory. */
+        enabled: import_zod.z.boolean(),
+        /** Code Corpus — semantic retrieval of similar instruction→code mappings. */
+        codeCorpus: import_zod.z.object({
+          enabled: import_zod.z.boolean(),
+          maxEntries: import_zod.z.number().int().positive(),
+          similarityThreshold: import_zod.z.number().min(0).max(1),
+          directUseThreshold: import_zod.z.number().min(0).max(1)
+        }),
+        /** Healing Corpus — retrieve similar past healing events during self-healing. */
+        healingCorpus: import_zod.z.object({
+          enabled: import_zod.z.boolean(),
+          maxEntries: import_zod.z.number().int().positive(),
+          similarityThreshold: import_zod.z.number().min(0).max(1)
+        }),
+        /** Error Catalog — aggregate recurring error patterns per URL. */
+        errorCatalog: import_zod.z.object({
+          enabled: import_zod.z.boolean(),
+          maxEntries: import_zod.z.number().int().positive()
+        }),
+        /** Embedding strategy: 'tfidf' (local, free, offline). */
+        embedder: import_zod.z.literal("tfidf")
+      }).default({
+        enabled: true,
+        codeCorpus: { enabled: true, maxEntries: 500, similarityThreshold: 0.65, directUseThreshold: 0.9 },
+        healingCorpus: { enabled: true, maxEntries: 300, similarityThreshold: 0.6 },
+        errorCatalog: { enabled: true, maxEntries: 200 },
+        embedder: "tfidf"
+      }),
       /**
        * Playwright MCP integration for AI-sighted code generation.
        *
@@ -251,6 +289,13 @@ var init_config = __esm({
       },
       studioPort: 4400,
       profiles: [],
+      rag: {
+        enabled: true,
+        codeCorpus: { enabled: true, maxEntries: 500, similarityThreshold: 0.65, directUseThreshold: 0.9 },
+        healingCorpus: { enabled: true, maxEntries: 300, similarityThreshold: 0.6 },
+        errorCatalog: { enabled: true, maxEntries: 200 },
+        embedder: "tfidf"
+      },
       mcp: {
         enabled: true,
         headless: true,
@@ -1107,7 +1152,7 @@ var init_suite = __esm({
       order: import_zod3.z.number().int().positive(),
       instruction: import_zod3.z.string().min(1),
       generatedCode: import_zod3.z.string(),
-      strategy: import_zod3.z.enum(["template", "cache", "batch", "fast", "primary"]),
+      strategy: import_zod3.z.enum(["template", "cache", "rag", "batch", "fast", "primary", "recorder"]),
       stepType: import_zod3.z.enum(["ui", "api", "mock"]).default("ui"),
       lastHealed: import_zod3.z.string().nullable(),
       timeout: import_zod3.z.number().int().positive().optional(),
@@ -1115,8 +1160,10 @@ var init_suite = __esm({
       mockUrl: import_zod3.z.string().optional(),
       mockResponse: import_zod3.z.string().optional(),
       mockStatus: import_zod3.z.number().int().optional(),
-      runAudit: import_zod3.z.boolean().optional()
+      runAudit: import_zod3.z.boolean().optional(),
       // Mark this step as a Lighthouse audit checkpoint
+      soft: import_zod3.z.boolean().optional()
+      // Use expect.soft() — test continues on assertion failure
     });
     DataSourceSchema = import_zod3.z.object({
       type: import_zod3.z.enum(["inline", "json-file", "csv-file"]),
@@ -2140,6 +2187,27 @@ var init_template_engine = __esm({
         regex: /^(?:verify|check)\s+(?:the\s+)?["'](.+?)["']\s+(?:field|input)\s+(?:has value|contains|equals)\s+["'](.+?)["']$/i,
         gen: (m) => `await expect(page.getByLabel('${m[1]}')).toHaveValue('${m[2]}');`
       },
+      // ── Soft Assertions (expect.soft — test continues on failure) ──
+      {
+        regex: /^soft\s+(?:verify|check|assert|ensure|confirm)\s+(?:that\s+)?["'](.+?)["']\s+(?:is\s+)?(?:visible|shown|displayed|present|appears)$/i,
+        gen: (m) => `await expect.soft(page.getByText('${m[1]}')).toBeVisible();`
+      },
+      {
+        regex: /^soft\s+(?:verify|check|assert)\s+(?:that\s+)?["'](.+?)["']\s+(?:is\s+)?(?:not visible|hidden|not shown|gone|disappeared|not present)$/i,
+        gen: (m) => `await expect.soft(page.getByText('${m[1]}')).not.toBeVisible();`
+      },
+      {
+        regex: /^soft\s+(?:verify|check)\s+(?:the\s+)?(?:page\s+)?title\s+(?:is|contains)\s+["'](.+?)["']$/i,
+        gen: (m) => `await expect.soft(page).toHaveTitle(/${m[1]}/);`
+      },
+      {
+        regex: /^soft\s+(?:verify|check)\s+(?:the\s+)?url\s+(?:is|contains|matches)\s+["'](.+?)["']$/i,
+        gen: (m) => `await expect.soft(page).toHaveURL(/${(m[1] ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/);`
+      },
+      {
+        regex: /^soft\s+(?:verify|check)\s+(?:the\s+)?["'](.+?)["']\s+(?:field|input)\s+(?:has value|contains|equals)\s+["'](.+?)["']$/i,
+        gen: (m) => `await expect.soft(page.getByLabel('${m[1]}')).toHaveValue('${m[2]}');`
+      },
       // ── Keyboard ──
       {
         regex: /^press\s+(.+)$/i,
@@ -2818,9 +2886,11 @@ var init_smart_router = __esm({
       fastProvider;
       mcpSession;
       actThenScript;
+      ragManager;
       stats = {
         template: 0,
         cache: 0,
+        rag: 0,
         batch: 0,
         fast: 0,
         primary: 0,
@@ -2831,6 +2901,7 @@ var init_smart_router = __esm({
         this.fastProvider = config.fastProvider ?? null;
         this.mcpSession = config.mcpSession ?? null;
         this.actThenScript = config.actThenScript ?? false;
+        this.ragManager = config.ragManager ?? null;
         this.cache = config.cache ?? new CodeCache();
         this.templateEngine = new TemplateEngine();
         this.classifier = new ComplexityClassifier();
@@ -2856,7 +2927,33 @@ var init_smart_router = __esm({
           const fixed = fixButtonSelectors(instruction, fixAntiPatterns(cached.code));
           return { code: fixed, strategy: "cache", cost: 0, model: "local" };
         }
+        let ragExamples = [];
+        let errorWarnings = [];
+        if (this.ragManager) {
+          try {
+            const matches = this.ragManager.codeCorpus.retrieve(instruction, pageContext.url);
+            if (matches.length > 0 && matches[0].score >= 0.9) {
+              const best = matches[0];
+              this.stats.rag++;
+              logger13.info({ instruction, score: best.score, matchedInstruction: best.instruction }, "RAG direct hit");
+              const fixed = fixButtonSelectors(instruction, fixAntiPatterns(best.code));
+              this.cache.set(cacheKey, fixed, pageContext.url);
+              return { code: fixed, strategy: "rag", cost: 0, model: "local" };
+            }
+            ragExamples = matches.filter((m) => m.score >= 0.65);
+            if (ragExamples.length > 0) {
+              logger13.debug({ instruction, examples: ragExamples.length, topScore: ragExamples[0].score }, "RAG examples found");
+            }
+            errorWarnings = this.ragManager.errorCatalog.getWarnings(pageContext.url);
+            if (errorWarnings.length > 0) {
+              logger13.debug({ url: pageContext.url, warnings: errorWarnings.length }, "RAG error warnings");
+            }
+          } catch (err) {
+            logger13.debug({ err }, "RAG retrieval failed \u2014 continuing without memory");
+          }
+        }
         const enrichedContext = this.mcpSession ? await this.enrichWithMcp(instruction, pageContext) : pageContext;
+        const contextWithRag = ragExamples.length > 0 || errorWarnings.length > 0 ? { ...enrichedContext, _ragExamples: ragExamples, _errorWarnings: errorWarnings } : enrichedContext;
         if (this.actThenScript && this.mcpSession && enrichedContext.accessibilityTree) {
           const actResult = await this.tryActThenScript(instruction, enrichedContext);
           if (actResult !== null) {
@@ -2870,8 +2967,8 @@ var init_smart_router = __esm({
         const usesFast = this.fastProvider !== null && complexity !== "complex";
         const provider = usesFast ? this.fastProvider : this.primaryProvider;
         const strategy = usesFast ? "fast" : "primary";
-        logger13.debug({ instruction, complexity, strategy }, "AI call");
-        const code = await provider.generateCode(instruction, enrichedContext);
+        logger13.debug({ instruction, complexity, strategy, ragExamples: ragExamples.length, errorWarnings: errorWarnings.length }, "AI call");
+        const code = await provider.generateCode(instruction, contextWithRag);
         this.cache.set(cacheKey, code, pageContext.url);
         if (usesFast) {
           this.stats.fast++;
@@ -2910,7 +3007,7 @@ var init_smart_router = __esm({
       }
       // ─── Stats (shown in Studio dashboard) ───────────────────────────────────
       getStats() {
-        const freeCalls = this.stats.template + this.stats.cache;
+        const freeCalls = this.stats.template + this.stats.cache + this.stats.rag;
         return {
           ...this.stats,
           freeCalls,
@@ -2930,6 +3027,10 @@ var init_smart_router = __esm({
       getMcpSession() {
         return this.mcpSession;
       }
+      /** Exposes the RAG manager for feedback loop (executor records pass/fail). */
+      getRagManager() {
+        return this.ragManager;
+      }
       // ─── MCP enrichment ─────────────────────────────────────────────────────────
       /**
        * Enrich a PageContext with live accessibility data from the MCP browser.
@@ -3408,6 +3509,17 @@ ${context.interactiveElements || "  None captured"}`;
   const accessibilitySection = context.accessibilityTree ? `
 Full accessibility tree (for additional context):
 ${context.accessibilityTree.slice(0, 4e3)}` : "";
+  const ragCtx = context;
+  const ragExamples = ragCtx._ragExamples ?? [];
+  const errorWarnings = ragCtx._errorWarnings ?? [];
+  const ragSection = ragExamples.length > 0 ? `
+Similar past steps that worked (use as reference \u2014 adapt, don't copy blindly):
+${ragExamples.slice(0, 3).map((ex, i) => `  ${i + 1}. "${ex.instruction}" (similarity: ${(ex.score * 100).toFixed(0)}%)
+     ${ex.code}`).join("\n")}` : "";
+  const errorSection = errorWarnings.length > 0 ? `
+Known issues on this page (avoid these patterns):
+${errorWarnings.slice(0, 3).map((w, i) => `  ${i + 1}. ${w.errorPattern} (occurred ${w.frequency}x)${w.suggestedFix ? `
+     Suggested fix: ${w.suggestedFix}` : ""}`).join("\n")}` : "";
   const user = `Current page:
   URL:   ${context.url}
   Title: ${context.title}
@@ -3420,7 +3532,7 @@ ${prevSteps}
 Runtime variables:
 ${vars}
 
-Step to implement: "${instruction}"`;
+Step to implement: "${instruction}"${ragSection}${errorSection}`;
   return { system: SYSTEM_PROMPT2, user };
 }
 var SYSTEM_PROMPT2;
@@ -3533,6 +3645,12 @@ Input value:     await expect(page.getByLabel('Email')).toHaveValue('user@exampl
 Not visible:     await expect(page.getByText('Error')).not.toBeVisible()
 Count:           await expect(page.getByRole('listitem')).toHaveCount(5)
 
+\u2501\u2501\u2501 SOFT ASSERTIONS (test continues on failure, failures collected at end) \u2501\u2501\u2501
+When the instruction starts with "Soft verify" or "Soft assert" or "Soft check", use expect.soft() instead of expect():
+  await expect.soft(page).toHaveURL(/dashboard/)
+  await expect.soft(page.getByText('Welcome')).toBeVisible()
+  await expect.soft(page.getByLabel('Email')).toHaveValue('user@example.com')
+
 For "verify user is on X page" \u2192 use toHaveURL() or check for a heading/element specific to that page.`;
   }
 });
@@ -3821,7 +3939,12 @@ Input value:     await expect(page.getByLabel('Email')).toHaveValue('user@test.c
 Not visible:     await expect(page.getByText('Error')).not.toBeVisible()
 
 "Verify user is on X page" \u2192 await expect(page).toHaveURL(/x-page-path/)
-                           OR await expect(page.getByRole('heading', { name: 'X' })).toBeVisible()`;
+                           OR await expect(page.getByRole('heading', { name: 'X' })).toBeVisible()
+
+\u2501\u2501\u2501 SOFT ASSERTIONS (test continues on failure) \u2501\u2501\u2501
+When instruction starts with "Soft verify/assert/check", use expect.soft():
+  await expect.soft(page.getByText('Welcome')).toBeVisible()
+  await expect.soft(page).toHaveURL(/dashboard/)`;
   }
 });
 
@@ -5072,7 +5195,7 @@ function createProvider(overrideProvider, options) {
       );
   }
 }
-function createSmartRouter(rootDir, mcpSession, actThenScript) {
+function createSmartRouter(rootDir, mcpSession, actThenScript, ragManager) {
   const env = validateEnv();
   const primary = createProvider();
   let fast;
@@ -5089,7 +5212,7 @@ function createSmartRouter(rootDir, mcpSession, actThenScript) {
   }
   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, mcpSession, actThenScript });
+  return new SmartRouter({ primaryProvider: primary, fastProvider: fast, cache, mcpSession, actThenScript, ragManager });
 }
 async function generateSuiteFromStory(story, options) {
   const provider = createProvider();
@@ -5289,9 +5412,10 @@ async function stepRoutes(fastify) {
         id: `step-${(0, import_crypto2.randomUUID)().slice(0, 8)}`,
         order: insertOrder,
         instruction: parsed.data.instruction,
-        generatedCode: "",
-        strategy: "primary",
-        lastHealed: null
+        generatedCode: parsed.data.generatedCode ?? "",
+        strategy: parsed.data.generatedCode ? parsed.data.strategy ?? "recorder" : "primary",
+        lastHealed: null,
+        ...parsed.data.soft ? { soft: true } : {}
       };
       const updatedSteps = [
         ...tc.steps.map((s) => s.order >= insertOrder ? { ...s, order: s.order + 1 } : s),
@@ -5344,8 +5468,12 @@ async function stepRoutes(fastify) {
         previousSteps: tc.steps.filter((s) => s.order < step.order && s.generatedCode).map((s) => ({ instruction: s.instruction, code: s.generatedCode })),
         variables
       });
+      let finalCode = result.code;
+      if (step.soft && finalCode) {
+        finalCode = finalCode.replace(/\bexpect\(/g, "expect.soft(");
+      }
       const updatedSteps = tc.steps.map(
-        (s) => s.id === step.id ? { ...s, generatedCode: result.code, strategy: result.strategy } : s
+        (s) => s.id === step.id ? { ...s, generatedCode: finalCode, strategy: result.strategy } : s
       );
       await router.getCache().persist();
       const updated = await updateCase(caseDir, { steps: updatedSteps });
@@ -5396,7 +5524,8 @@ async function stepRoutes(fastify) {
         const r = codeMap.get(s.id);
         if (r && r.code.trim()) {
           actuallyGenerated++;
-          return { ...s, generatedCode: r.code, strategy: r.strategy };
+          const code = s.soft ? r.code.replace(/\bexpect\(/g, "expect.soft(") : r.code;
+          return { ...s, generatedCode: code, strategy: r.strategy };
         }
         return s;
       });
@@ -5459,6 +5588,16 @@ async function stepRoutes(fastify) {
         if (parsed.data.auditUrl !== void 0) patch.auditUrl = parsed.data.auditUrl;
         if (parsed.data.lighthouseCategories !== void 0) patch.lighthouseCategories = parsed.data.lighthouseCategories;
         if (parsed.data.runAudit !== void 0) patch.runAudit = parsed.data.runAudit;
+        if (parsed.data.soft !== void 0) {
+          patch.soft = parsed.data.soft;
+          if (s.generatedCode) {
+            if (parsed.data.soft) {
+              patch.generatedCode = s.generatedCode.replace(/\bexpect\(/g, "expect.soft(");
+            } else {
+              patch.generatedCode = s.generatedCode.replace(/\bexpect\.soft\(/g, "expect(");
+            }
+          }
+        }
         return { ...s, ...patch };
       });
       const updated = await updateCase(caseDir, { steps: updatedSteps });
@@ -5485,7 +5624,10 @@ var init_steps = __esm({
     init_utils2();
     AddStepBody = import_zod8.z.object({
       instruction: import_zod8.z.string().min(1),
-      order: import_zod8.z.number().int().positive().optional()
+      order: import_zod8.z.number().int().positive().optional(),
+      generatedCode: import_zod8.z.string().optional(),
+      strategy: import_zod8.z.enum(["template", "cache", "rag", "batch", "fast", "primary", "recorder"]).optional(),
+      soft: import_zod8.z.boolean().optional()
     });
     ReorderBody = import_zod8.z.object({
       stepIds: import_zod8.z.array(import_zod8.z.string().min(1))
@@ -5500,7 +5642,8 @@ var init_steps = __esm({
       mockStatus: import_zod8.z.number().int().optional(),
       auditUrl: import_zod8.z.string().optional(),
       lighthouseCategories: import_zod8.z.array(import_zod8.z.enum(["performance", "accessibility", "seo"])).optional(),
-      runAudit: import_zod8.z.boolean().optional()
+      runAudit: import_zod8.z.boolean().optional(),
+      soft: import_zod8.z.boolean().optional()
     });
   }
 });
@@ -6510,6 +6653,726 @@ var init_result_store = __esm({
   }
 });
 
+// src/rag/embedder.ts
+function tokenize(text) {
+  const cleaned = text.toLowerCase().replace(/\{\{[^}]+\}\}/g, " __var__ ").replace(/"([^"]+)"/g, (_m, p1) => ` ${p1} `).replace(/'([^']+)'/g, (_m, p1) => ` ${p1} `).replace(/[^a-z0-9\s-]/g, " ").trim();
+  const words = cleaned.split(/\s+/).filter((w) => w.length > 1 && !STOPWORDS.has(w));
+  const tokens = [...words];
+  for (let i = 0; i < words.length - 1; i++) {
+    tokens.push(`${words[i]}_${words[i + 1]}`);
+  }
+  return tokens;
+}
+function hashTerm(term) {
+  const hash = (0, import_crypto4.createHash)("md5").update(term).digest();
+  return hash.readUInt32LE(0) % VECTOR_DIM;
+}
+var import_crypto4, import_fs_extra14, VECTOR_DIM, STOPWORDS, TfIdfEmbedder;
+var init_embedder = __esm({
+  "src/rag/embedder.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_crypto4 = require("crypto");
+    import_fs_extra14 = require("fs-extra");
+    VECTOR_DIM = 256;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "need",
+      "dare",
+      "ought",
+      "to",
+      "of",
+      "in",
+      "for",
+      "on",
+      "with",
+      "at",
+      "by",
+      "from",
+      "as",
+      "into",
+      "through",
+      "during",
+      "before",
+      "after",
+      "above",
+      "below",
+      "between",
+      "out",
+      "off",
+      "over",
+      "under",
+      "again",
+      "further",
+      "then",
+      "once",
+      "that",
+      "this",
+      "these",
+      "those",
+      "and",
+      "but",
+      "or",
+      "nor",
+      "not",
+      "so",
+      "very",
+      "just",
+      "than",
+      "too",
+      "also",
+      "it",
+      "its"
+    ]);
+    TfIdfEmbedder = class {
+      constructor(vocabPath) {
+        this.vocabPath = vocabPath;
+      }
+      vocab = { docCount: 0, termDocFreq: {} };
+      dirty = false;
+      /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+      /** Load persisted IDF vocabulary from disk */
+      async load() {
+        try {
+          this.vocab = await (0, import_fs_extra14.readJson)(this.vocabPath);
+        } catch {
+          this.vocab = { docCount: 0, termDocFreq: {} };
+        }
+      }
+      /** Persist IDF vocabulary to disk */
+      async save() {
+        if (!this.dirty) return;
+        await (0, import_fs_extra14.outputJson)(this.vocabPath, this.vocab, { spaces: 0 });
+        this.dirty = false;
+      }
+      /* ── Training ──────────────────────────────────────────────────────────── */
+      /**
+       * Add a document to the IDF computation.
+       * Call this for every instruction ingested into a corpus.
+       */
+      addDocument(text) {
+        const tokens = new Set(tokenize(text));
+        this.vocab.docCount++;
+        for (const term of tokens) {
+          this.vocab.termDocFreq[term] = (this.vocab.termDocFreq[term] ?? 0) + 1;
+        }
+        this.dirty = true;
+      }
+      /**
+       * Batch-add multiple documents at once (initial corpus load).
+       */
+      addDocuments(texts) {
+        for (const text of texts) {
+          this.addDocument(text);
+        }
+      }
+      /* ── Embedding ─────────────────────────────────────────────────────────── */
+      /**
+       * Convert a text string into a fixed-dimension TF-IDF vector.
+       * Uses hashing trick to map terms to buckets (no explicit vocabulary limit).
+       */
+      embed(text) {
+        const tokens = tokenize(text);
+        if (tokens.length === 0) return new Array(VECTOR_DIM).fill(0);
+        const tf = {};
+        for (const token of tokens) {
+          tf[token] = (tf[token] ?? 0) + 1;
+        }
+        const vector = new Array(VECTOR_DIM).fill(0);
+        const N = Math.max(this.vocab.docCount, 1);
+        for (const [term, count] of Object.entries(tf)) {
+          const termFreq = count / tokens.length;
+          const docFreq = this.vocab.termDocFreq[term] ?? 0;
+          const idf = Math.log(1 + N / (1 + docFreq));
+          const tfidf = termFreq * idf;
+          const bucket = hashTerm(term);
+          vector[bucket] += tfidf;
+        }
+        const mag = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        if (mag > 0) {
+          for (let i = 0; i < vector.length; i++) {
+            vector[i] /= mag;
+          }
+        }
+        return vector;
+      }
+      /** Current corpus size */
+      get documentCount() {
+        return this.vocab.docCount;
+      }
+    };
+  }
+});
+
+// src/rag/similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  return denom === 0 ? 0 : dot / denom;
+}
+var init_similarity = __esm({
+  "src/rag/similarity.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/rag/vector-store.ts
+var import_fs_extra15, VectorStore;
+var init_vector_store = __esm({
+  "src/rag/vector-store.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs_extra15 = require("fs-extra");
+    init_similarity();
+    VectorStore = class {
+      constructor(filePath, maxEntries = 500) {
+        this.filePath = filePath;
+        this.maxEntries = maxEntries;
+      }
+      documents = [];
+      dirty = false;
+      /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+      async load() {
+        if (await (0, import_fs_extra15.pathExists)(this.filePath)) {
+          try {
+            const data = await (0, import_fs_extra15.readJson)(this.filePath);
+            this.documents = data.documents ?? [];
+          } catch {
+            this.documents = [];
+          }
+        }
+      }
+      async persist() {
+        if (!this.dirty) return;
+        const data = { version: 1, documents: this.documents };
+        await (0, import_fs_extra15.outputJson)(this.filePath, data, { spaces: 0 });
+        this.dirty = false;
+      }
+      /* ── CRUD ──────────────────────────────────────────────────────────────── */
+      /** Add a document. Auto-prunes if maxEntries exceeded. */
+      add(id, text, vector, metadata) {
+        this.documents = this.documents.filter((d) => d.id !== id);
+        const now2 = Date.now();
+        this.documents.push({ id, text, vector, metadata, createdAt: now2, updatedAt: now2 });
+        this.dirty = true;
+        if (this.documents.length > this.maxEntries) {
+          this.prune();
+        }
+      }
+      /** Update metadata for an existing document */
+      update(id, metadata) {
+        const doc = this.documents.find((d) => d.id === id);
+        if (!doc) return false;
+        doc.metadata = { ...doc.metadata, ...metadata };
+        doc.updatedAt = Date.now();
+        this.dirty = true;
+        return true;
+      }
+      /** Remove a document by ID */
+      remove(id) {
+        const before = this.documents.length;
+        this.documents = this.documents.filter((d) => d.id !== id);
+        if (this.documents.length !== before) {
+          this.dirty = true;
+          return true;
+        }
+        return false;
+      }
+      /** Get a document by ID */
+      get(id) {
+        return this.documents.find((d) => d.id === id);
+      }
+      /** Check if a document exists */
+      has(id) {
+        return this.documents.some((d) => d.id === id);
+      }
+      /** Number of documents in the store */
+      get size() {
+        return this.documents.length;
+      }
+      /* ── Search ────────────────────────────────────────────────────────────── */
+      /**
+       * Find the top-K most similar documents to a query vector.
+       * Only returns documents above the similarity threshold.
+       */
+      search(queryVector, topK = 5, threshold = 0.5) {
+        const scored = [];
+        for (const doc of this.documents) {
+          const score = cosineSimilarity(queryVector, doc.vector);
+          if (score >= threshold) {
+            scored.push({
+              id: doc.id,
+              text: doc.text,
+              metadata: doc.metadata,
+              score
+            });
+          }
+        }
+        scored.sort((a, b) => {
+          if (Math.abs(a.score - b.score) > 1e-3) return b.score - a.score;
+          const docA = this.documents.find((d) => d.id === a.id);
+          const docB = this.documents.find((d) => d.id === b.id);
+          return docB.updatedAt - docA.updatedAt;
+        });
+        return scored.slice(0, topK);
+      }
+      /* ── Internal ──────────────────────────────────────────────────────────── */
+      /** Remove oldest entries to stay within maxEntries limit */
+      prune() {
+        const sorted = [...this.documents].sort((a, b) => a.updatedAt - b.updatedAt);
+        const excess = sorted.length - this.maxEntries;
+        if (excess > 0) {
+          const toRemove = new Set(sorted.slice(0, excess).map((d) => d.id));
+          this.documents = this.documents.filter((d) => !toRemove.has(d.id));
+        }
+      }
+    };
+  }
+});
+
+// src/rag/code-corpus.ts
+function generateId(instruction, url) {
+  const normalized = `${instruction.toLowerCase().trim()}|${normalizeUrl2(url)}`;
+  return (0, import_crypto5.createHash)("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function normalizeUrl2(url) {
+  if (!url) return "";
+  try {
+    const u = new URL(url);
+    const path37 = u.pathname.replace(/\/\d+/g, "/*");
+    return `${u.hostname}${path37}`;
+  } catch {
+    return url;
+  }
+}
+function boostBySuccess(score, success, fail) {
+  const total = success + fail;
+  if (total === 0) return score;
+  const successRate = success / total;
+  return score * (1 + 0.05 * successRate);
+}
+function toMatch(doc) {
+  return {
+    id: doc.id,
+    instruction: doc.metadata.instruction,
+    code: doc.metadata.code,
+    urlPattern: doc.metadata.urlPattern,
+    score: doc.score,
+    successCount: doc.metadata.successCount,
+    failCount: doc.metadata.failCount
+  };
+}
+var import_crypto5, MAX_CONSECUTIVE_FAILS, CodeCorpus;
+var init_code_corpus = __esm({
+  "src/rag/code-corpus.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_crypto5 = require("crypto");
+    MAX_CONSECUTIVE_FAILS = 2;
+    CodeCorpus = class {
+      constructor(store, embedder) {
+        this.store = store;
+        this.embedder = embedder;
+      }
+      /* ── Ingest ────────────────────────────────────────────────────────────── */
+      /**
+       * Add a successful instruction → code mapping to the corpus.
+       * Called after a step passes execution.
+       */
+      ingest(instruction, code, url) {
+        const id = generateId(instruction, url);
+        const urlPattern = normalizeUrl2(url);
+        const embedText = `${instruction} ${urlPattern}`;
+        const existing = this.store.get(id);
+        if (existing) {
+          this.store.update(id, {
+            ...existing.metadata,
+            code,
+            successCount: existing.metadata.successCount + 1,
+            consecutiveFails: 0
+          });
+          return;
+        }
+        this.embedder.addDocument(embedText);
+        const vector = this.embedder.embed(embedText);
+        this.store.add(id, embedText, vector, {
+          instruction,
+          code,
+          urlPattern,
+          successCount: 1,
+          failCount: 0,
+          consecutiveFails: 0
+        });
+      }
+      /* ── Retrieve ──────────────────────────────────────────────────────────── */
+      /**
+       * Find similar past instructions in the corpus.
+       * Returns matches ranked by similarity score.
+       */
+      retrieve(instruction, url = "", topK = 3, threshold = 0.65) {
+        if (this.store.size === 0) return [];
+        const urlPattern = normalizeUrl2(url);
+        const queryText = `${instruction} ${urlPattern}`;
+        const queryVector = this.embedder.embed(queryText);
+        const results = this.store.search(queryVector, topK * 2, threshold);
+        const boosted = results.map((r) => ({
+          ...r,
+          score: boostBySuccess(r.score, r.metadata.successCount, r.metadata.failCount)
+        }));
+        boosted.sort((a, b) => b.score - a.score);
+        return boosted.slice(0, topK).map(toMatch);
+      }
+      /* ── Feedback ──────────────────────────────────────────────────────────── */
+      /**
+       * Record the outcome of using a corpus entry.
+       * Removes entries that fail too many times consecutively.
+       */
+      recordOutcome(id, passed) {
+        const doc = this.store.get(id);
+        if (!doc) return;
+        if (passed) {
+          this.store.update(id, {
+            ...doc.metadata,
+            successCount: doc.metadata.successCount + 1,
+            consecutiveFails: 0
+          });
+        } else {
+          const newConsecutive = doc.metadata.consecutiveFails + 1;
+          if (newConsecutive >= MAX_CONSECUTIVE_FAILS) {
+            this.store.remove(id);
+            return;
+          }
+          this.store.update(id, {
+            ...doc.metadata,
+            failCount: doc.metadata.failCount + 1,
+            consecutiveFails: newConsecutive
+          });
+        }
+      }
+      /** Number of entries in the corpus */
+      get size() {
+        return this.store.size;
+      }
+    };
+  }
+});
+
+// src/rag/healing-corpus.ts
+function generateId2(instruction, error) {
+  const normalized = `${instruction.toLowerCase().trim()}|${normalizeError(error)}`;
+  return (0, import_crypto6.createHash)("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function normalizeError(error) {
+  return error.replace(/\d+ms/g, "Nms").replace(/\d+/g, "N").replace(/["'][^"']*["']/g, "'...'").replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function normalizeUrl3(url) {
+  if (!url) return "";
+  try {
+    const u = new URL(url);
+    return `${u.hostname}${u.pathname.replace(/\/\d+/g, "/*")}`;
+  } catch {
+    return url;
+  }
+}
+function toMatch2(doc) {
+  return {
+    id: doc.id,
+    instruction: doc.metadata.instruction,
+    error: doc.metadata.error,
+    failedCode: doc.metadata.failedCode,
+    healedCode: doc.metadata.healedCode,
+    strategy: doc.metadata.strategy,
+    level: doc.metadata.level,
+    score: doc.score,
+    successCount: doc.metadata.successCount
+  };
+}
+var import_crypto6, HealingCorpus;
+var init_healing_corpus = __esm({
+  "src/rag/healing-corpus.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_crypto6 = require("crypto");
+    HealingCorpus = class {
+      constructor(store, embedder) {
+        this.store = store;
+        this.embedder = embedder;
+      }
+      /* ── Ingest ────────────────────────────────────────────────────────────── */
+      /**
+       * Record a successful healing event in the corpus.
+       * Called when self-healing produces a working fix.
+       */
+      ingest(event) {
+        const id = generateId2(event.instruction, event.error);
+        const urlPattern = normalizeUrl3(event.url);
+        const embedText = `${event.instruction} ${normalizeError(event.error)}`;
+        const existing = this.store.get(id);
+        if (existing) {
+          this.store.update(id, {
+            ...existing.metadata,
+            healedCode: event.healedCode,
+            strategy: event.strategy,
+            level: event.level,
+            successCount: existing.metadata.successCount + 1
+          });
+          return;
+        }
+        this.embedder.addDocument(embedText);
+        const vector = this.embedder.embed(embedText);
+        this.store.add(id, embedText, vector, {
+          instruction: event.instruction,
+          error: normalizeError(event.error),
+          failedCode: event.failedCode,
+          healedCode: event.healedCode,
+          strategy: event.strategy,
+          level: event.level,
+          urlPattern,
+          successCount: 1
+        });
+      }
+      /* ── Retrieve ──────────────────────────────────────────────────────────── */
+      /**
+       * Find similar past healing events.
+       * Searches by instruction + error pattern similarity.
+       */
+      retrieve(instruction, error, topK = 3, threshold = 0.6) {
+        if (this.store.size === 0) return [];
+        const queryText = `${instruction} ${normalizeError(error)}`;
+        const queryVector = this.embedder.embed(queryText);
+        const results = this.store.search(queryVector, topK, threshold);
+        return results.map(toMatch2);
+      }
+      /** Number of entries */
+      get size() {
+        return this.store.size;
+      }
+    };
+  }
+});
+
+// src/rag/error-catalog.ts
+function generateId3(errorPattern, urlPattern) {
+  const key = `${errorPattern}|${urlPattern}`;
+  return (0, import_crypto7.createHash)("sha256").update(key).digest("hex").slice(0, 16);
+}
+function normalizeError2(error) {
+  return error.replace(/\d+ms/g, "Nms").replace(/\d+/g, "N").replace(/["'][^"']*["']/g, "'...'").replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function normalizeUrl4(url) {
+  if (!url) return "";
+  try {
+    const u = new URL(url);
+    return `${u.hostname}${u.pathname.replace(/\/\d+/g, "/*")}`;
+  } catch {
+    return url;
+  }
+}
+function toWarning(doc) {
+  const fixes = doc.metadata.commonFixes;
+  return {
+    errorPattern: doc.metadata.errorPattern,
+    urlPattern: doc.metadata.urlPattern,
+    frequency: doc.metadata.frequency,
+    suggestedFix: fixes.length > 0 ? fixes[fixes.length - 1] : null,
+    score: doc.score
+  };
+}
+var import_crypto7, ErrorCatalog;
+var init_error_catalog = __esm({
+  "src/rag/error-catalog.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_crypto7 = require("crypto");
+    ErrorCatalog = class {
+      constructor(store, embedder) {
+        this.store = store;
+        this.embedder = embedder;
+      }
+      /* ── Record ────────────────────────────────────────────────────────────── */
+      /**
+       * Record a test failure. If the error pattern already exists,
+       * increment frequency. If a fix is provided, add it to commonFixes.
+       */
+      record(error, url, fixCode) {
+        const errorPattern = normalizeError2(error);
+        const urlPattern = normalizeUrl4(url);
+        const id = generateId3(errorPattern, urlPattern);
+        const embedText = `${errorPattern} ${urlPattern}`;
+        const existing = this.store.get(id);
+        if (existing) {
+          const fixes = [...existing.metadata.commonFixes];
+          if (fixCode && !fixes.includes(fixCode)) {
+            fixes.push(fixCode);
+            if (fixes.length > 5) fixes.shift();
+          }
+          this.store.update(id, {
+            ...existing.metadata,
+            frequency: existing.metadata.frequency + 1,
+            lastSeen: Date.now(),
+            commonFixes: fixes
+          });
+          return;
+        }
+        this.embedder.addDocument(embedText);
+        const vector = this.embedder.embed(embedText);
+        this.store.add(id, embedText, vector, {
+          errorPattern,
+          urlPattern,
+          frequency: 1,
+          lastSeen: Date.now(),
+          commonFixes: fixCode ? [fixCode] : []
+        });
+      }
+      /* ── Retrieve ──────────────────────────────────────────────────────────── */
+      /**
+       * Get known error patterns for a URL.
+       * Used during code generation to warn the AI about known pitfalls.
+       */
+      getWarnings(url, topK = 5) {
+        if (this.store.size === 0) return [];
+        const urlPattern = normalizeUrl4(url);
+        const queryVector = this.embedder.embed(urlPattern);
+        const results = this.store.search(queryVector, topK * 2, 0.3);
+        const recurring = results.filter((r) => r.metadata.frequency >= 2);
+        recurring.sort((a, b) => b.metadata.frequency - a.metadata.frequency);
+        return recurring.slice(0, topK).map(toWarning);
+      }
+      /** Number of tracked patterns */
+      get size() {
+        return this.store.size;
+      }
+    };
+  }
+});
+
+// src/rag/rag-manager.ts
+var import_path19, import_fs_extra16, logger21, RagManager;
+var init_rag_manager = __esm({
+  "src/rag/rag-manager.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path19 = require("path");
+    import_fs_extra16 = require("fs-extra");
+    init_embedder();
+    init_vector_store();
+    init_code_corpus();
+    init_healing_corpus();
+    init_error_catalog();
+    init_logger();
+    logger21 = createChildLogger("rag");
+    RagManager = class _RagManager {
+      codeCorpus;
+      healingCorpus;
+      errorCatalog;
+      embedder;
+      codeStore;
+      healingStore;
+      errorStore;
+      constructor(embedder, codeStore, healingStore, errorStore) {
+        this.embedder = embedder;
+        this.codeStore = codeStore;
+        this.healingStore = healingStore;
+        this.errorStore = errorStore;
+        this.codeCorpus = new CodeCorpus(codeStore, embedder);
+        this.healingCorpus = new HealingCorpus(healingStore, embedder);
+        this.errorCatalog = new ErrorCatalog(errorStore, embedder);
+      }
+      /* ── Factory ───────────────────────────────────────────────────────────── */
+      /**
+       * Create and initialize a RagManager.
+       * Loads all corpora from disk. Safe to call if files don't exist yet.
+       */
+      static async create(rootDir, config) {
+        const ragDir = (0, import_path19.join)(rootDir, "results", ".rag");
+        await (0, import_fs_extra16.ensureDir)(ragDir);
+        logger21.info({ ragDir }, "Initializing RAG manager");
+        const embedder = new TfIdfEmbedder((0, import_path19.join)(ragDir, "idf-vocab.json"));
+        await embedder.load();
+        const codeStore = new VectorStore(
+          (0, import_path19.join)(ragDir, "code-corpus.json"),
+          config.codeCorpus.maxEntries
+        );
+        const healingStore = new VectorStore(
+          (0, import_path19.join)(ragDir, "healing-corpus.json"),
+          config.healingCorpus.maxEntries
+        );
+        const errorStore = new VectorStore(
+          (0, import_path19.join)(ragDir, "error-catalog.json"),
+          config.errorCatalog.maxEntries
+        );
+        await Promise.all([
+          codeStore.load(),
+          healingStore.load(),
+          errorStore.load()
+        ]);
+        logger21.info(
+          {
+            codeCorpus: codeStore.size,
+            healingCorpus: healingStore.size,
+            errorCatalog: errorStore.size,
+            idfDocuments: embedder.documentCount
+          },
+          "RAG corpora loaded"
+        );
+        return new _RagManager(embedder, codeStore, healingStore, errorStore);
+      }
+      /* ── Persistence ───────────────────────────────────────────────────────── */
+      /** Persist all corpora and the embedder vocabulary to disk */
+      async persist() {
+        await Promise.all([
+          this.embedder.save(),
+          this.codeStore.persist(),
+          this.healingStore.persist(),
+          this.errorStore.persist()
+        ]);
+        logger21.debug("RAG corpora persisted");
+      }
+      /* ── Stats ─────────────────────────────────────────────────────────────── */
+      getStats() {
+        return {
+          codeCorpus: this.codeStore.size,
+          healingCorpus: this.healingStore.size,
+          errorCatalog: this.errorStore.size,
+          idfVocab: this.embedder.documentCount
+        };
+      }
+    };
+  }
+});
+
 // src/mcp/proactive-checker.ts
 function extractSelectors(code) {
   const results = [];
@@ -6597,7 +7460,7 @@ async function checkSelectors(mcpSession, url, code) {
   await mcpSession.navigate(url);
   const raw = await mcpSession.snapshot();
   if (!raw) {
-    logger21.warn({ url }, "Proactive check: snapshot returned null \u2014 skipping validation");
+    logger22.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);
@@ -6638,7 +7501,7 @@ async function checkSelectors(mcpSession, url, code) {
   }
   const matched = checks.filter((c) => c.found).length;
   const missing = checks.filter((c) => !c.found).length;
-  logger21.info(
+  logger22.info(
     { url, total: checks.length, matched, missing },
     "Proactive selector check complete"
   );
@@ -6651,14 +7514,14 @@ async function checkSelectors(mcpSession, url, code) {
     checks
   };
 }
-var logger21, SELECTOR_PATTERNS;
+var logger22, 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");
+    logger22 = createChildLogger("proactive-checker");
     SELECTOR_PATTERNS = [
       // getByRole('button', { name: 'Login' })
       { regex: /getByRole\(\s*['"](\w+)['"]\s*,\s*\{[^}]*name:\s*['"]([^'"]+)['"]/g, type: "getByRole" },
@@ -6675,14 +7538,14 @@ var init_proactive_checker = __esm({
 });
 
 // src/engine/browser-manager.ts
-var import_playwright, logger22, BrowserManager;
+var import_playwright, logger23, BrowserManager;
 var init_browser_manager = __esm({
   "src/engine/browser-manager.ts"() {
     "use strict";
     init_cjs_shims();
     import_playwright = require("playwright");
     init_logger();
-    logger22 = createChildLogger("browser-manager");
+    logger23 = createChildLogger("browser-manager");
     BrowserManager = class {
       browsers = /* @__PURE__ */ new Map();
       // ─── Launch ───────────────────────────────────────────────────────────────
@@ -6692,14 +7555,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);
-        logger22.info({ browser: browserName, headless: config.headless }, "Browser launched");
+        logger23.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) {
-          logger22.warn({ device: config.device }, "Unknown Playwright device \u2014 falling back to configured viewport");
+          logger23.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
@@ -6812,7 +7675,7 @@ var init_browser_manager = __esm({
           close: async () => {
           }
         };
-        logger22.info("Created API-only request context (zero browser)");
+        logger23.info("Created API-only request context (zero browser)");
         return fakePage;
       }
       /** Closes all API request contexts. */
@@ -6837,11 +7700,11 @@ var init_browser_manager = __esm({
               await context.tracing.stop();
             }
           } catch (err) {
-            logger22.debug({ err }, "Tracing stop failed \u2014 ignoring");
+            logger23.debug({ err }, "Tracing stop failed \u2014 ignoring");
           }
         }
         await context.close().catch((err) => {
-          logger22.debug({ err }, "Context close failed \u2014 ignoring");
+          logger23.debug({ err }, "Context close failed \u2014 ignoring");
         });
       }
       /** Closes all open browsers and API contexts. Called at the end of every run. */
@@ -6850,9 +7713,9 @@ var init_browser_manager = __esm({
         for (const [name, browser] of this.browsers) {
           try {
             await browser.close();
-            logger22.debug({ browser: name }, "Browser closed");
+            logger23.debug({ browser: name }, "Browser closed");
           } catch (err) {
-            logger22.warn({ err, browser: name }, "Error closing browser");
+            logger23.warn({ err, browser: name }, "Error closing browser");
           }
         }
         this.browsers.clear();
@@ -6865,13 +7728,13 @@ var init_browser_manager = __esm({
 });
 
 // src/engine/healing-budget.ts
-var logger23, ENVIRONMENTAL_PATTERNS, HealingBudget;
+var logger24, ENVIRONMENTAL_PATTERNS, HealingBudget;
 var init_healing_budget = __esm({
   "src/engine/healing-budget.ts"() {
     "use strict";
     init_cjs_shims();
     init_logger();
-    logger23 = createChildLogger("healing-budget");
+    logger24 = createChildLogger("healing-budget");
     ENVIRONMENTAL_PATTERNS = [
       /timeout/i,
       /ECONNREFUSED/i,
@@ -6894,7 +7757,7 @@ var init_healing_budget = __esm({
       // ─── Main decision ────────────────────────────────────────────────────────
       shouldHeal(failure) {
         if (this.spent >= this.dailyBudget) {
-          logger23.warn(
+          logger24.warn(
             { spent: this.spent, budget: this.dailyBudget },
             "Daily healing budget exhausted"
           );
@@ -6928,7 +7791,7 @@ var init_healing_budget = __esm({
       /** Call after each AI healing call with the estimated cost. */
       recordSpend(amountUsd) {
         this.spent += amountUsd;
-        logger23.debug({ spend: amountUsd, total: this.spent }, "Healing budget spend recorded");
+        logger24.debug({ spend: amountUsd, total: this.spent }, "Healing budget spend recorded");
       }
       /** Call when a healing attempt itself fails (AI returned bad code, etc.). */
       recordHealFailure(stepId) {
@@ -6950,21 +7813,21 @@ var init_healing_budget = __esm({
 });
 
 // src/engine/healing-report.ts
-var import_crypto4, logger24, HealingReporter;
+var import_crypto8, logger25, HealingReporter;
 var init_healing_report = __esm({
   "src/engine/healing-report.ts"() {
     "use strict";
     init_cjs_shims();
-    import_crypto4 = require("crypto");
+    import_crypto8 = require("crypto");
     init_healing_store();
     init_logger();
-    logger24 = createChildLogger("healing-report");
+    logger25 = createChildLogger("healing-report");
     HealingReporter = class {
       events = [];
       /** Records a successful healing event (called by executor after each healed step). */
       record(input) {
         const event = {
-          id: (0, import_crypto4.randomUUID)(),
+          id: (0, import_crypto8.randomUUID)(),
           runId: input.runId,
           suiteId: input.suiteId,
           caseId: input.caseId,
@@ -6980,7 +7843,7 @@ var init_healing_report = __esm({
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         this.events.push(event);
-        logger24.info(
+        logger25.info(
           { stepId: input.stepId, strategy: input.strategy, level: input.level },
           "Healing event recorded"
         );
@@ -7006,15 +7869,15 @@ var init_healing_report = __esm({
         };
         try {
           await writeHealingReport(rootDir, report);
-          logger24.info({ runId, count: this.events.length }, "Healing report written");
+          logger25.info({ runId, count: this.events.length }, "Healing report written");
         } catch (err) {
-          logger24.error({ err, runId }, "Failed to write healing report");
+          logger25.error({ err, runId }, "Failed to write healing report");
         }
         for (const event of this.events) {
           try {
             await appendPendingEvent(rootDir, event);
           } catch (err) {
-            logger24.warn({ err, eventId: event.id }, "Failed to append pending healing event");
+            logger25.warn({ err, eventId: event.id }, "Failed to append pending healing event");
           }
         }
       }
@@ -7206,40 +8069,40 @@ function buildCategoryHtml(caseName, pageLoads, category) {
 </body>
 </html>`;
 }
-var import_path19, import_crypto5, import_fs_extra14, logger25, AllureReporter;
+var import_path20, import_crypto9, import_fs_extra17, logger26, AllureReporter;
 var init_allure_reporter = __esm({
   "src/engine/allure-reporter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path19 = __toESM(require("path"));
-    import_crypto5 = require("crypto");
-    import_fs_extra14 = __toESM(require("fs-extra"));
+    import_path20 = __toESM(require("path"));
+    import_crypto9 = require("crypto");
+    import_fs_extra17 = __toESM(require("fs-extra"));
     init_logger();
-    logger25 = createChildLogger("allure-reporter");
+    logger26 = createChildLogger("allure-reporter");
     AllureReporter = class {
       resultsDir;
       environment;
       constructor(rootDir, runId, environment = "dev") {
-        this.resultsDir = import_path19.default.join(rootDir, "results", "allure-results", runId);
+        this.resultsDir = import_path20.default.join(rootDir, "results", "allure-results", runId);
         this.environment = environment;
       }
       /** Writes one allure result JSON per test case + environment.properties. */
       async writeResults(runResult) {
-        await import_fs_extra14.default.ensureDir(this.resultsDir);
+        await import_fs_extra17.default.ensureDir(this.resultsDir);
         const envProps = [
           `Environment=${this.environment.toUpperCase()}`,
           `Framework=Assuremind`
         ].join("\n");
-        await import_fs_extra14.default.writeFile(import_path19.default.join(this.resultsDir, "environment.properties"), envProps, "utf-8");
+        await import_fs_extra17.default.writeFile(import_path20.default.join(this.resultsDir, "environment.properties"), envProps, "utf-8");
         let logFileName;
         if (runResult.logFilePath) {
           try {
-            logFileName = import_path19.default.basename(runResult.logFilePath);
+            logFileName = import_path20.default.basename(runResult.logFilePath);
             await this.copyAttachment(runResult.logFilePath).catch(() => {
             });
-            logger25.debug({ logFile: logFileName }, "Log file copied to Allure results");
+            logger26.debug({ logFile: logFileName }, "Log file copied to Allure results");
           } catch {
-            logger25.debug("Failed to copy log file to Allure results");
+            logger26.debug("Failed to copy log file to Allure results");
           }
         }
         let written = 0;
@@ -7249,23 +8112,23 @@ var init_allure_reporter = __esm({
             written++;
           }
         }
-        logger25.info({ dir: this.resultsDir, written }, "Allure results written");
+        logger26.info({ dir: this.resultsDir, written }, "Allure results written");
       }
       // ─── Internal ─────────────────────────────────────────────────────────────
       async writeTestResult(suite, tc, logFileName) {
-        const uuid = (0, import_crypto5.randomUUID)();
+        const uuid = (0, import_crypto9.randomUUID)();
         const start = new Date(tc.startedAt).getTime();
         const stop2 = new Date(tc.finishedAt).getTime();
         const failedStep = tc.steps.find((s) => s.status === "failed");
         const testAttachments = [];
         if (tc.videoPath) {
-          const videoName = import_path19.default.basename(tc.videoPath);
-          const ext = import_path19.default.extname(videoName).toLowerCase();
+          const videoName = import_path20.default.basename(tc.videoPath);
+          const ext = import_path20.default.extname(videoName).toLowerCase();
           const mime = ext === ".mp4" ? "video/mp4" : "video/webm";
           testAttachments.push({ name: "Video Recording", source: videoName, type: mime });
         }
         if (tc.tracePath) {
-          const traceName = import_path19.default.basename(tc.tracePath);
+          const traceName = import_path20.default.basename(tc.tracePath);
           testAttachments.push({ name: "Playwright Trace", source: traceName, type: "application/zip" });
         }
         if (logFileName) {
@@ -7279,19 +8142,19 @@ var init_allure_reporter = __esm({
           if (hasPerf) {
             const html = buildCategoryHtml(tc.caseName, pageLoads, "performance");
             const file = `${uuid}-perf.html`;
-            await import_fs_extra14.default.writeFile(import_path19.default.join(this.resultsDir, file), html, "utf-8");
+            await import_fs_extra17.default.writeFile(import_path20.default.join(this.resultsDir, file), html, "utf-8");
             testAttachments.push({ name: "\u26A1 Performance Report", source: file, type: "text/html" });
           }
           if (hasA11y) {
             const html = buildCategoryHtml(tc.caseName, pageLoads, "accessibility");
             const file = `${uuid}-a11y.html`;
-            await import_fs_extra14.default.writeFile(import_path19.default.join(this.resultsDir, file), html, "utf-8");
+            await import_fs_extra17.default.writeFile(import_path20.default.join(this.resultsDir, file), html, "utf-8");
             testAttachments.push({ name: "\u267F Accessibility Report", source: file, type: "text/html" });
           }
           if (hasSeo) {
             const html = buildCategoryHtml(tc.caseName, pageLoads, "seo");
             const file = `${uuid}-seo.html`;
-            await import_fs_extra14.default.writeFile(import_path19.default.join(this.resultsDir, file), html, "utf-8");
+            await import_fs_extra17.default.writeFile(import_path20.default.join(this.resultsDir, file), html, "utf-8");
             testAttachments.push({ name: "\u{1F50D} SEO Report", source: file, type: "text/html" });
           }
         }
@@ -7319,8 +8182,8 @@ var init_allure_reporter = __esm({
             statusDetails: { message: failedStep.error }
           }
         };
-        const filePath = import_path19.default.join(this.resultsDir, `${uuid}-result.json`);
-        await import_fs_extra14.default.writeJson(filePath, result, { spaces: 2 });
+        const filePath = import_path20.default.join(this.resultsDir, `${uuid}-result.json`);
+        await import_fs_extra17.default.writeJson(filePath, result, { spaces: 2 });
         for (const step of tc.steps) {
           if (step.screenshotPath) {
             await this.copyAttachment(step.screenshotPath).catch(() => {
@@ -7341,7 +8204,7 @@ var init_allure_reporter = __esm({
         const stepStop = caseStart + step.duration;
         const attachments = [];
         if (step.screenshotPath) {
-          const name = import_path19.default.basename(step.screenshotPath);
+          const name = import_path20.default.basename(step.screenshotPath);
           attachments.push({ name: "Screenshot", source: name, type: "image/png" });
         }
         return {
@@ -7356,8 +8219,8 @@ var init_allure_reporter = __esm({
         };
       }
       async copyAttachment(screenshotPath) {
-        const dest = import_path19.default.join(this.resultsDir, import_path19.default.basename(screenshotPath));
-        await import_fs_extra14.default.copy(screenshotPath, dest, { overwrite: true });
+        const dest = import_path20.default.join(this.resultsDir, import_path20.default.basename(screenshotPath));
+        await import_fs_extra17.default.copy(screenshotPath, dest, { overwrite: true });
       }
     };
   }
@@ -7365,15 +8228,15 @@ var init_allure_reporter = __esm({
 
 // src/engine/allure-generator.ts
 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)) {
-    logger26.debug({ resultsDir }, "No allure-results dir for run \u2014 skipping report generation");
+  const resultsDir = import_path21.default.join(rootDir, "results", "allure-results", runId);
+  const reportDir = import_path21.default.join(rootDir, "results", "allure-report", runId);
+  if (!await import_fs_extra18.default.pathExists(resultsDir)) {
+    logger27.debug({ resultsDir }, "No allure-results dir for run \u2014 skipping report generation");
     return false;
   }
-  const files = await import_fs_extra15.default.readdir(resultsDir);
+  const files = await import_fs_extra18.default.readdir(resultsDir);
   if (files.length === 0) {
-    logger26.debug({ runId }, "allure-results is empty \u2014 skipping report generation");
+    logger27.debug({ runId }, "allure-results is empty \u2014 skipping report generation");
     return false;
   }
   try {
@@ -7382,34 +8245,34 @@ async function generateAllureReport(rootDir, runId) {
       ["generate", resultsDir, "--output", reportDir, "--clean", "--single-file"],
       isWindows ? { shell: true } : {}
     );
-    logger26.info({ reportDir, runId }, "Allure HTML report generated");
+    logger27.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")) {
-      logger26.warn(
+      logger27.warn(
         "Allure report generation skipped \u2014 Java is not installed. Install Java (https://adoptium.net) to enable Allure HTML reports."
       );
     } else {
-      logger26.warn({ err: msg, runId }, "Allure report generation failed");
+      logger27.warn({ err: msg, runId }, "Allure report generation failed");
     }
     return false;
   }
 }
-var import_path20, import_fs_extra15, import_child_process2, import_util, execFileAsync, logger26, isWindows, alluireBin;
+var import_path21, import_fs_extra18, import_child_process2, import_util, execFileAsync, logger27, isWindows, alluireBin;
 var init_allure_generator = __esm({
   "src/engine/allure-generator.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path20 = __toESM(require("path"));
-    import_fs_extra15 = __toESM(require("fs-extra"));
+    import_path21 = __toESM(require("path"));
+    import_fs_extra18 = __toESM(require("fs-extra"));
     import_child_process2 = require("child_process");
     import_util = require("util");
     init_logger();
     execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
-    logger26 = createChildLogger("allure-generator");
+    logger27 = createChildLogger("allure-generator");
     isWindows = process.platform === "win32";
-    alluireBin = import_path20.default.resolve(
+    alluireBin = import_path21.default.resolve(
       __dirname,
       isWindows ? "../../node_modules/allure-commandline/dist/bin/allure.bat" : "../../node_modules/.bin/allure"
     );
@@ -7954,7 +8817,7 @@ function parseMultiStrategies(raw) {
   }
   return stripped.split("\n").map((s) => s.trim()).filter((s) => s.length > 0 && s.startsWith("await"));
 }
-var logger27, SelfHealer;
+var logger28, SelfHealer;
 var init_self_healing = __esm({
   "src/engine/self-healing.ts"() {
     "use strict";
@@ -7966,11 +8829,12 @@ var init_self_healing = __esm({
     init_logger();
     init_code_runner();
     init_step_type_detector();
-    logger27 = createChildLogger("self-healing");
+    logger28 = createChildLogger("self-healing");
     SelfHealer = class {
-      constructor(provider, maxLevel) {
+      constructor(provider, maxLevel, ragManager) {
         this.provider = provider;
         this.maxLevel = maxLevel;
+        this.ragManager = ragManager;
       }
       /**
        * Attempts to heal a failed step by cycling through levels 1–maxLevel.
@@ -7981,7 +8845,7 @@ var init_self_healing = __esm({
        */
       async heal(step, failure, previousSteps, page, variables, baseUrl) {
         if (failure.failureKind === "assertion") {
-          logger27.info(
+          logger28.info(
             { stepId: step.id },
             "Assertion failure \u2014 skipping all healing levels (possible application bug)"
           );
@@ -7990,10 +8854,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)) {
-            logger27.debug({ stepId: step.id, level }, `Skipping DOM-specific level ${level} for API step`);
+            logger28.debug({ stepId: step.id, level }, `Skipping DOM-specific level ${level} for API step`);
             continue;
           }
-          logger27.debug({ stepId: step.id, level, isApi }, `Attempting heal level ${level}`);
+          logger28.debug({ stepId: step.id, level, isApi }, `Attempting heal level ${level}`);
           try {
             const result = await this.tryLevel(
               level,
@@ -8006,14 +8870,14 @@ var init_self_healing = __esm({
               isApi
             );
             if (result !== null) {
-              logger27.info({ stepId: step.id, level, strategy: result.strategy }, "Healing succeeded");
+              logger28.info({ stepId: step.id, level, strategy: result.strategy }, "Healing succeeded");
               return result;
             }
           } catch (err) {
-            logger27.debug({ err, level, stepId: step.id }, `Level ${level} healing attempt threw`);
+            logger28.debug({ err, level, stepId: step.id }, `Level ${level} healing attempt threw`);
           }
         }
-        logger27.warn({ stepId: step.id, maxLevel: this.maxLevel }, "All healing levels exhausted");
+        logger28.warn({ stepId: step.id, maxLevel: this.maxLevel }, "All healing levels exhausted");
         return null;
       }
       // ─── Level dispatcher ─────────────────────────────────────────────────────
@@ -8048,7 +8912,7 @@ var init_self_healing = __esm({
         if (this.provider.supportsVision) {
           try {
             const som = await captureSetOfMarks(page);
-            logger27.debug({ stepId: step.id }, "Level 2: using SoM vision healing");
+            logger28.debug({ stepId: step.id }, "Level 2: using SoM vision healing");
             const code2 = await this.provider.analyzeWithSoM(
               som.screenshot,
               som.elementMap,
@@ -8058,13 +8922,27 @@ var init_self_healing = __esm({
             await executeCode(sanitized2, page);
             return { code: sanitized2, level: 2, strategy: "regenerate" };
           } catch (visionErr) {
-            logger27.debug({ stepId: step.id, err: visionErr }, "SoM vision failed, falling back to text regeneration");
+            logger28.debug({ stepId: step.id, err: visionErr }, "SoM vision failed, falling back to text regeneration");
             await cleanupSoMOverlay(page);
           }
         }
         const context = await extractPageContext(page, previousSteps, variables);
+        let healingHint = "";
+        if (this.ragManager) {
+          try {
+            const matches = this.ragManager.healingCorpus.retrieve(step.instruction, failure.error, 2);
+            if (matches.length > 0) {
+              healingHint = "\n\nSimilar past fixes that worked:\n" + matches.map(
+                (m, i) => `  ${i + 1}. Error: ${m.error}
+     Fix: ${m.healedCode}`
+              ).join("\n");
+              logger28.debug({ stepId: step.id, matches: matches.length }, "RAG healing corpus matches found");
+            }
+          } catch {
+          }
+        }
         const code = await this.provider.healSelector(
-          step.instruction,
+          step.instruction + healingHint,
           failure.failedCode,
           failure.error,
           context
@@ -8114,12 +8992,12 @@ var init_self_healing = __esm({
       // Produces inspectable Playwright code (not pixel coordinates).
       async level4Visual(step, page, variables, baseUrl) {
         if (!this.provider.supportsVision) {
-          logger27.debug({ stepId: step.id }, "Skipping SoM visual healing \u2014 provider lacks vision");
+          logger28.debug({ stepId: step.id }, "Skipping SoM visual healing \u2014 provider lacks vision");
           return null;
         }
         try {
           const som = await captureSetOfMarks(page);
-          logger27.debug(
+          logger28.debug(
             { stepId: step.id, elementCount: som.elements.length },
             "Level 4: SoM screenshot captured"
           );
@@ -8133,7 +9011,7 @@ var init_self_healing = __esm({
           return { code: sanitized, level: 4, strategy: "visual" };
         } catch (err) {
           await cleanupSoMOverlay(page);
-          logger27.debug({ stepId: step.id, err }, "Level 4 SoM failed");
+          logger28.debug({ stepId: step.id, err }, "Level 4 SoM failed");
           return null;
         }
       }
@@ -8158,7 +9036,7 @@ var init_self_healing = __esm({
       }
       // ─── Level 6: Manual (human in the loop) ─────────────────────────────────
       level6Manual(step, failure) {
-        logger27.warn(
+        logger28.warn(
           { stepId: step.id, instruction: step.instruction, error: failure.error },
           "Level 6: manual intervention required \u2014 marking step for human review"
         );
@@ -8183,17 +9061,17 @@ async function executeStep(step, page, ctx) {
   const mergedVars = { ...ctx.variables, ...Object.fromEntries(ctx.sharedVariables) };
   const hasTokens = step.generatedCode.includes("{{");
   if (hasTokens) {
-    logger28.warn(
+    logger29.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) {
-    logger28.warn({ stepId: step.id, before: step.generatedCode, after: code }, "Variable interpolation result");
+    logger29.warn({ stepId: step.id, before: step.generatedCode, after: code }, "Variable interpolation result");
   }
   if (!code.trim() && step.stepType !== "mock") {
-    logger28.warn({ stepId: step.id }, "Step has no generated code \u2014 skipping");
+    logger29.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) {
@@ -8218,7 +9096,7 @@ async function executeStep(step, page, ctx) {
   const runtimeCtx = {
     setVariable: (key, value) => {
       ctx.sharedVariables.set(key, value);
-      logger28.info({ stepId: step.id, key, value: value.slice(0, 50) }, "Runtime variable set");
+      logger29.info({ stepId: step.id, key, value: value.slice(0, 50) }, "Runtime variable set");
     },
     getVariable: (key) => ctx.sharedVariables.get(key)
   };
@@ -8250,7 +9128,13 @@ async function executeStep(step, page, ctx) {
         } catch {
         }
       }
-      if (ctx.config.screenshot === "on") {
+      if (ctx.ragManager && code.trim()) {
+        try {
+          ctx.ragManager.codeCorpus.ingest(step.instruction, code, page.url());
+        } catch {
+        }
+      }
+      if (ctx.config.screenshot === "on") {
         const screenshotPath = await captureScreenshot(page, ctx, step.id, "pass");
         return { ...buildResult(step, "passed", code, Date.now() - start, void 0, screenshotPath), navigatedToUrl, auditUrl };
       }
@@ -8258,7 +9142,7 @@ async function executeStep(step, page, ctx) {
     } catch (err) {
       lastErr = err;
       if (attempt < stepRetries) {
-        logger28.debug({ stepId: step.id, attempt, stepRetries }, "Step failed \u2014 retrying");
+        logger29.debug({ stepId: step.id, attempt, stepRetries }, "Step failed \u2014 retrying");
         continue;
       }
     }
@@ -8266,7 +9150,7 @@ async function executeStep(step, page, ctx) {
   const firstErr = lastErr;
   {
     const errorMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
-    logger28.debug({ stepId: step.id, error: errorMsg }, "Step failed on first attempt");
+    logger29.debug({ stepId: step.id, error: errorMsg }, "Step failed on first attempt");
     const failAuditUrl = step.runAudit && step.stepType !== "api" ? (() => {
       try {
         return page.url() || void 0;
@@ -8280,7 +9164,7 @@ async function executeStep(step, page, ctx) {
     }
     const failureKind = classifyError(errorMsg);
     if (failureKind === "assertion") {
-      logger28.info(
+      logger29.info(
         { stepId: step.id, error: errorMsg },
         "Assertion failure detected \u2014 NOT healing (possible application bug)"
       );
@@ -8289,7 +9173,13 @@ async function executeStep(step, page, ctx) {
     if (!ctx.config.healing.enabled) {
       return { ...buildResult(step, "failed", code, Date.now() - start, errorMsg, screenshotPath), ...failAuditUrl ? { auditUrl: failAuditUrl } : {} };
     }
-    logger28.debug({ stepId: step.id, failureKind }, "Infrastructure failure \u2014 attempting to heal");
+    if (ctx.ragManager) {
+      try {
+        ctx.ragManager.errorCatalog.record(errorMsg, page.url());
+      } catch {
+      }
+    }
+    logger29.debug({ stepId: step.id, failureKind }, "Infrastructure failure \u2014 attempting to heal");
     const failure = {
       stepId: step.id,
       instruction: step.instruction,
@@ -8300,10 +9190,10 @@ async function executeStep(step, page, ctx) {
     };
     const decision = ctx.budget.shouldHeal(failure);
     if (!decision.heal) {
-      logger28.info({ stepId: step.id, reason: decision.reason }, "Healing skipped");
+      logger29.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);
+    const healer = new SelfHealer(ctx.provider, ctx.config.healing.maxLevel, ctx.ragManager);
     try {
       const healResult = await healer.heal(
         step,
@@ -8317,6 +9207,21 @@ async function executeStep(step, page, ctx) {
         const codeChanged = healResult.code.trim() !== code.trim();
         if (codeChanged) {
           ctx.budget.recordSpend(5e-3);
+          if (ctx.ragManager) {
+            try {
+              ctx.ragManager.healingCorpus.ingest({
+                instruction: step.instruction,
+                error: errorMsg,
+                failedCode: code,
+                healedCode: healResult.code,
+                strategy: healResult.strategy,
+                level: healResult.level,
+                url: page.url()
+              });
+              ctx.ragManager.errorCatalog.record(errorMsg, page.url(), healResult.code);
+            } catch {
+            }
+          }
           ctx.healingReporter.record({
             runId: ctx.runId,
             suiteId: ctx.suiteId,
@@ -8331,7 +9236,7 @@ async function executeStep(step, page, ctx) {
             pageUrl: page.url()
           });
         }
-        logger28.info(
+        logger29.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)"
         );
@@ -8347,7 +9252,7 @@ async function executeStep(step, page, ctx) {
       }
     } catch (healErr) {
       const healErrMsg = healErr instanceof Error ? healErr.message : String(healErr);
-      logger28.warn({ stepId: step.id, error: healErrMsg }, "Healing threw an error");
+      logger29.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 } : {} };
@@ -8371,13 +9276,13 @@ async function captureScreenshot(page, ctx, stepId, suffix) {
   try {
     await page.waitForLoadState("load", { timeout: 5e3 }).catch(() => {
     });
-    const screenshotsDir = import_path21.default.join(ctx.rootDir, "results", "screenshots");
+    const screenshotsDir = import_path22.default.join(ctx.rootDir, "results", "screenshots");
     const filename = `${ctx.runId}_${ctx.caseId}_${stepId}_${suffix}.png`;
-    const screenshotPath = import_path21.default.join(screenshotsDir, filename);
+    const screenshotPath = import_path22.default.join(screenshotsDir, filename);
     await page.screenshot({ path: screenshotPath, fullPage: true });
     return screenshotPath;
   } catch (err) {
-    logger28.debug({ err }, "Screenshot capture failed");
+    logger29.debug({ err }, "Screenshot capture failed");
     return void 0;
   }
 }
@@ -8389,19 +9294,19 @@ function withTimeout(promise, ms) {
     )
   ]);
 }
-var import_path21, logger28, ASSERTION_PATTERNS, INFRA_PATTERNS;
+var import_path22, logger29, ASSERTION_PATTERNS, INFRA_PATTERNS;
 var init_executor = __esm({
   "src/engine/executor.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path21 = __toESM(require("path"));
+    import_path22 = __toESM(require("path"));
     init_variable_interpolator();
     init_code_runner();
     init_self_healing();
     init_step_type_detector();
     init_logger();
     init_code_runner();
-    logger28 = createChildLogger("executor");
+    logger29 = 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,
@@ -8618,24 +9523,24 @@ async function loadDataRows(rootDir, dataSource) {
       return dataSource.data ?? [];
     case "json-file": {
       if (!dataSource.path) throw new Error("JSON data source requires a path");
-      const filePath = import_path22.default.resolve(rootDir, dataSource.path);
-      if (!await import_fs_extra16.default.pathExists(filePath)) {
+      const filePath = import_path23.default.resolve(rootDir, dataSource.path);
+      if (!await import_fs_extra19.default.pathExists(filePath)) {
         throw new Error(`Data file not found: ${filePath}`);
       }
-      const raw = await import_fs_extra16.default.readJson(filePath);
+      const raw = await import_fs_extra19.default.readJson(filePath);
       if (!Array.isArray(raw)) throw new Error("JSON data file must contain an array of objects");
-      logger29.info({ path: filePath, rows: raw.length }, "Loaded JSON data rows");
+      logger30.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)]))
       );
     }
     case "csv-file": {
       if (!dataSource.path) throw new Error("CSV data source requires a path");
-      const filePath = import_path22.default.resolve(rootDir, dataSource.path);
-      if (!await import_fs_extra16.default.pathExists(filePath)) {
+      const filePath = import_path23.default.resolve(rootDir, dataSource.path);
+      if (!await import_fs_extra19.default.pathExists(filePath)) {
         throw new Error(`Data file not found: ${filePath}`);
       }
-      const content = await import_fs_extra16.default.readFile(filePath, "utf8");
+      const content = await import_fs_extra19.default.readFile(filePath, "utf8");
       const lines = content.trim().split("\n").map((l) => l.trim()).filter(Boolean);
       if (lines.length < 2) return [];
       const headers = lines[0].split(",").map((h) => h.trim());
@@ -8647,22 +9552,22 @@ async function loadDataRows(rootDir, dataSource) {
         });
         return row;
       });
-      logger29.info({ path: filePath, rows: rows.length }, "Loaded CSV data rows");
+      logger30.info({ path: filePath, rows: rows.length }, "Loaded CSV data rows");
       return rows;
     }
     default:
       return [];
   }
 }
-var import_path22, import_fs_extra16, logger29;
+var import_path23, import_fs_extra19, logger30;
 var init_data_loader = __esm({
   "src/engine/data-loader.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path22 = __toESM(require("path"));
-    import_fs_extra16 = __toESM(require("fs-extra"));
+    import_path23 = __toESM(require("path"));
+    import_fs_extra19 = __toESM(require("fs-extra"));
     init_logger();
-    logger29 = createChildLogger("data-loader");
+    logger30 = createChildLogger("data-loader");
   }
 });
 
@@ -9922,16 +10827,16 @@ function makeUnixTmpDir() {
 function makeWin32TmpDir() {
   const winTmpPath = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
   const randomNumber = Math.floor(Math.random() * 9e7 + 1e7);
-  const tmpdir = (0, import_path23.join)(winTmpPath, "lighthouse." + randomNumber);
+  const tmpdir = (0, import_path24.join)(winTmpPath, "lighthouse." + randomNumber);
   (0, import_fs.mkdirSync)(tmpdir, { recursive: true });
   return tmpdir;
 }
-var import_path23, import_child_process3, import_fs, import_is_wsl, LauncherError, ChromePathNotSetError, InvalidUserDataDirectoryError, UnsupportedPlatformError, ChromeNotInstalledError;
+var import_path24, import_child_process3, import_fs, import_is_wsl, LauncherError, ChromePathNotSetError, InvalidUserDataDirectoryError, UnsupportedPlatformError, ChromeNotInstalledError;
 var init_utils3 = __esm({
   "node_modules/chrome-launcher/dist/utils.js"() {
     "use strict";
     init_cjs_shims();
-    import_path23 = require("path");
+    import_path24 = require("path");
     import_child_process3 = __toESM(require("child_process"), 1);
     import_fs = require("fs");
     import_is_wsl = __toESM(require_is_wsl(), 1);
@@ -10007,7 +10912,7 @@ function darwin() {
   }
   (0, import_child_process4.execSync)(`${LSREGISTER} -dump | grep -i 'google chrome\\( canary\\)\\?\\.app' | awk '{$1=""; print $0}'`).toString().split(newLineRegex).forEach((inst) => {
     suffixes.forEach((suffix) => {
-      const execPath = import_path24.default.join(inst.substring(0, inst.indexOf(".app") + 4).trim(), suffix);
+      const execPath = import_path25.default.join(inst.substring(0, inst.indexOf(".app") + 4).trim(), suffix);
       if (canAccess(execPath) && installations.indexOf(execPath) === -1) {
         installations.push(execPath);
       }
@@ -10047,7 +10952,7 @@ function linux() {
     installations.push(customChromePath);
   }
   const desktopInstallationFolders = [
-    import_path24.default.join((0, import_os.homedir)(), ".local/share/applications/"),
+    import_path25.default.join((0, import_os.homedir)(), ".local/share/applications/"),
     "/usr/share/applications/"
   ];
   desktopInstallationFolders.forEach((folder) => {
@@ -10095,8 +11000,8 @@ function wsl() {
 function win32() {
   const installations = [];
   const suffixes = [
-    `${import_path24.default.sep}Google${import_path24.default.sep}Chrome SxS${import_path24.default.sep}Application${import_path24.default.sep}chrome.exe`,
-    `${import_path24.default.sep}Google${import_path24.default.sep}Chrome${import_path24.default.sep}Application${import_path24.default.sep}chrome.exe`
+    `${import_path25.default.sep}Google${import_path25.default.sep}Chrome SxS${import_path25.default.sep}Application${import_path25.default.sep}chrome.exe`,
+    `${import_path25.default.sep}Google${import_path25.default.sep}Chrome${import_path25.default.sep}Application${import_path25.default.sep}chrome.exe`
   ];
   const prefixes = [
     process.env.LOCALAPPDATA,
@@ -10108,7 +11013,7 @@ function win32() {
     installations.push(customChromePath);
   }
   prefixes.forEach((prefix) => suffixes.forEach((suffix) => {
-    const chromePath = import_path24.default.join(prefix, suffix);
+    const chromePath = import_path25.default.join(prefix, suffix);
     if (canAccess(chromePath)) {
       installations.push(chromePath);
     }
@@ -10156,13 +11061,13 @@ function findChromeExecutables(folder) {
   }
   return installations;
 }
-var import_fs2, import_path24, import_os, import_child_process4, import_escape_string_regexp, newLineRegex;
+var import_fs2, import_path25, import_os, import_child_process4, import_escape_string_regexp, newLineRegex;
 var init_chrome_finder = __esm({
   "node_modules/chrome-launcher/dist/chrome-finder.js"() {
     "use strict";
     init_cjs_shims();
     import_fs2 = __toESM(require("fs"), 1);
-    import_path24 = __toESM(require("path"), 1);
+    import_path25 = __toESM(require("path"), 1);
     import_os = require("os");
     import_child_process4 = require("child_process");
     import_escape_string_regexp = __toESM(require_escape_string_regexp(), 1);
@@ -10633,15 +11538,15 @@ function isSuiteAudit(suite) {
   return suite.type === "audit" || suite.type === "performance";
 }
 async function runTests(rootDir, runConfig, autotestConfig, ws) {
-  const runId = (0, import_crypto6.randomUUID)();
+  const runId = (0, import_crypto10.randomUUID)();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const testsDir = import_path25.default.join(rootDir, "tests");
+  const testsDir = import_path26.default.join(rootDir, "tests");
   const activeEnv = autotestConfig.environment ?? "dev";
   const envUrl = autotestConfig.environmentUrls?.[activeEnv];
   if (envUrl) {
     autotestConfig = { ...autotestConfig, baseUrl: envUrl };
   }
-  logger30.info({ runId, runConfig, environment: activeEnv, baseUrl: autotestConfig.baseUrl }, "Run started");
+  logger31.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();
@@ -10655,7 +11560,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
   try {
     const pairs = await collectWork(testsDir, runConfig);
     if (pairs.length === 0) {
-      logger30.warn({ runConfig }, "No tests matched the run config");
+      logger31.warn({ runConfig }, "No tests matched the run config");
     }
     const variables = await loadVariables(rootDir, runConfig.env);
     const sharedVariables = /* @__PURE__ */ new Map();
@@ -10666,18 +11571,18 @@ 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 }));
-            logger30.info({ caseId: pair.testCase.id, rows: rows.length }, "Expanded data-driven case");
+            logger31.info({ caseId: pair.testCase.id, rows: rows.length }, "Expanded data-driven case");
             continue;
           }
         } catch (err) {
-          logger30.warn({ err, caseId: pair.testCase.id }, "Failed to load data rows \u2014 running case once");
+          logger31.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");
+      logger31.info("Proactive healing enabled \u2014 validating selectors before run");
       let mcpChecker = null;
       try {
         mcpChecker = new McpSession({
@@ -10700,7 +11605,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
                   suggestion: c.suggestion
                 }))
               });
-              logger30.warn(
+              logger31.warn(
                 { stepId: step.id, missing: result.missing },
                 `Proactive check: ${result.missing} selector(s) may be broken`
               );
@@ -10708,12 +11613,22 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
           }
         }
       } catch (err) {
-        logger30.warn({ err }, "Proactive healing check failed \u2014 continuing with run");
+        logger31.warn({ err }, "Proactive healing check failed \u2014 continuing with run");
       } finally {
         await mcpChecker?.disconnect();
       }
     }
-    const smartRouter = createSmartRouter(rootDir);
+    let ragManager;
+    if (autotestConfig.rag?.enabled) {
+      try {
+        ragManager = await RagManager.create(rootDir, autotestConfig.rag);
+        logger31.info(ragManager.getStats(), "RAG memory loaded");
+        logToFile("info", "RAG memory loaded", ragManager.getStats());
+      } catch (err) {
+        logger31.warn({ err }, "RAG initialization failed \u2014 continuing without memory");
+      }
+    }
+    const smartRouter = createSmartRouter(rootDir, void 0, void 0, ragManager);
     const provider = smartRouter.getPrimaryProvider();
     const budget = new HealingBudget(autotestConfig.healing.dailyBudget);
     const browsers = autotestConfig.browsers;
@@ -10722,7 +11637,7 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
       ({ suite, testCase }) => (isSuiteApiOnly(suite) || isCaseApiOnly(testCase)) && !isSuiteAudit(suite)
     );
     if (allApiOnly) {
-      logger30.info("All test cases are API-only \u2014 no browser will be launched");
+      logger31.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();
@@ -10776,7 +11691,8 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
           browserManager,
           ws,
           logToFile,
-          compositeCaseId
+          compositeCaseId,
+          ragManager
         );
         result.suiteType = suite.type;
         if (dataRow !== void 0) {
@@ -10826,13 +11742,21 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
       generateAllureReport(rootDir, runId).catch(() => void 0);
     }
     if (autotestConfig.reporting.json) {
-      const jsonPath = import_path25.default.join(rootDir, "results", `run-${runId}.json`);
-      await import_fs_extra17.default.ensureDir(import_path25.default.dirname(jsonPath));
-      await import_fs_extra17.default.writeJson(jsonPath, runResult, { spaces: 2 });
+      const jsonPath = import_path26.default.join(rootDir, "results", `run-${runId}.json`);
+      await import_fs_extra20.default.ensureDir(import_path26.default.dirname(jsonPath));
+      await import_fs_extra20.default.writeJson(jsonPath, runResult, { spaces: 2 });
     }
     await healingReporter.flush(rootDir, runId);
     await smartRouter.getCache().persist();
-    logger30.info(
+    if (ragManager) {
+      try {
+        await ragManager.persist();
+        logger31.info(ragManager.getStats(), "RAG memory persisted");
+      } catch (err) {
+        logger31.warn({ err }, "RAG persistence failed");
+      }
+    }
+    logger31.info(
       {
         runId,
         passed: runResult.passed,
@@ -10847,22 +11771,22 @@ async function runTests(rootDir, runConfig, autotestConfig, ws) {
     await browserManager.closeAll();
   }
 }
-async function runCase(rootDir, runId, suite, testCase, browserName, browser, config, variables, sharedVariables, provider, budget, healingReporter, browserManager, ws, logToFile, wsCaseId) {
+async function runCase(rootDir, runId, suite, testCase, browserName, browser, config, variables, sharedVariables, provider, budget, healingReporter, browserManager, ws, logToFile, wsCaseId, ragManager) {
   const broadcastCaseId = wsCaseId ?? testCase.id;
   const caseStart = (/* @__PURE__ */ new Date()).toISOString();
   const stepResults = [];
   const previousSteps = [];
   const apiOnly = isSuiteApiOnly(suite) || isCaseApiOnly(testCase);
   const caseConfig = isSuiteAudit(suite) ? { ...config, screenshot: "off", video: "off", trace: "off" } : config;
-  const tracePath = !apiOnly && caseConfig.trace !== "off" ? import_path25.default.join(rootDir, "results", "traces", `${runId}_${testCase.id}_${browserName}.zip`) : void 0;
+  const tracePath = !apiOnly && caseConfig.trace !== "off" ? import_path26.default.join(rootDir, "results", "traces", `${runId}_${testCase.id}_${browserName}.zip`) : void 0;
   let context = null;
   let page;
   if (apiOnly) {
     page = await browserManager.createApiOnlyPage(config.baseUrl);
-    logger30.debug({ caseName: testCase.name }, "API-only case \u2014 zero browser, using standalone HTTP client");
+    logger31.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"));
+    context = await browserManager.newContext(browser, caseConfig, import_path26.default.join(rootDir, "results", "videos"));
     page = await browserManager.newPage(context);
     await installHighlighter(page);
   }
@@ -10932,7 +11856,8 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
         config: effectiveConfig,
         provider,
         budget,
-        healingReporter
+        healingReporter,
+        ragManager
       });
       ws?.broadcast("run:step", {
         runId,
@@ -10996,16 +11921,16 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
           const launch2 = chromeLauncher.launch ?? chromeLauncher.default?.launch;
           const { chromium: pwChromium } = await import("playwright");
           const chromePath = pwChromium.executablePath();
-          const lhBaseDir = import_path25.default.join(rootDir, "results", ".lh-profiles");
-          await import_fs_extra17.default.ensureDir(lhBaseDir);
+          const lhBaseDir = import_path26.default.join(rootDir, "results", ".lh-profiles");
+          await import_fs_extra20.default.ensureDir(lhBaseDir);
           for (let auditIdx = 0; auditIdx < navigatedSteps.length; auditIdx++) {
             const { s, idx } = navigatedSteps[auditIdx];
             const url = s.auditUrl ?? s.navigatedToUrl;
             logToFile?.("info", `  Auditing: ${url}`);
             let chromeInstance = null;
-            const userDataDir = import_path25.default.join(lhBaseDir, `audit-${Date.now()}-${auditIdx}`);
+            const userDataDir = import_path26.default.join(lhBaseDir, `audit-${Date.now()}-${auditIdx}`);
             try {
-              await import_fs_extra17.default.ensureDir(userDataDir);
+              await import_fs_extra20.default.ensureDir(userDataDir);
               chromeInstance = await launch2({
                 chromePath,
                 chromeFlags: ["--headless", "--no-sandbox", "--disable-gpu"],
@@ -11081,7 +12006,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);
-              logger30.warn({ url, err: errMsg }, "Lighthouse audit failed for URL");
+              logger31.warn({ url, err: errMsg }, "Lighthouse audit failed for URL");
               logToFile?.("warn", `  Lighthouse failed for ${url}: ${errMsg}`);
               pageLoads.push({
                 url,
@@ -11095,14 +12020,14 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
               } catch {
               }
               try {
-                await import_fs_extra17.default.remove(userDataDir);
+                await import_fs_extra20.default.remove(userDataDir);
               } catch {
               }
             }
           }
         } catch (lhErr) {
           const errMsg = lhErr instanceof Error ? lhErr.message : String(lhErr);
-          logger30.warn({ err: errMsg }, "Lighthouse import/init failed");
+          logger31.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) {
@@ -11148,11 +12073,11 @@ async function runCase(rootDir, runId, suite, testCase, browserName, browser, co
       await browserManager.closeContext(context, caseConfig, tracePath);
       const videoDeleteOnPass = caseConfig.video === "retain-on-failure" || caseConfig.video === "on-first-retry";
       if (videoDeleteOnPass && caseStatus === "passed" && pendingVideoPath) {
-        await import_fs_extra17.default.remove(pendingVideoPath).catch(() => void 0);
+        await import_fs_extra20.default.remove(pendingVideoPath).catch(() => void 0);
       }
       const traceDeleteOnPass = caseConfig.trace === "retain-on-failure" || caseConfig.trace === "on-first-retry";
       if (traceDeleteOnPass && caseStatus === "passed" && tracePath) {
-        await import_fs_extra17.default.remove(tracePath).catch(() => void 0);
+        await import_fs_extra20.default.remove(tracePath).catch(() => void 0);
       }
     }
   }
@@ -11198,7 +12123,7 @@ async function collectWork(testsDir, runConfig) {
     }
     const suiteDir = await findSuiteDirById(testsDir, suite.id);
     if (!suiteDir) {
-      logger30.warn({ suiteId: suite.id }, "Suite directory not found \u2014 skipping");
+      logger31.warn({ suiteId: suite.id }, "Suite directory not found \u2014 skipping");
       continue;
     }
     const cases = await listCases(suiteDir);
@@ -11220,10 +12145,10 @@ async function loadVariables(rootDir, env) {
   try {
     const resolved = await resolveVariables(rootDir, env ?? "dev");
     const count = Object.keys(resolved).length;
-    logger30.info({ count, env: env ?? "dev", rootDir }, "Variables loaded");
+    logger31.info({ count, env: env ?? "dev", rootDir }, "Variables loaded");
     return resolved;
   } catch (err) {
-    logger30.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to load variables \u2014 running without variable substitution");
+    logger31.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to load variables \u2014 running without variable substitution");
     return {};
   }
 }
@@ -11294,20 +12219,21 @@ function buildRunResult(runId, startedAt, finishedAt, suites, environment) {
     skipped
   };
 }
-var import_path25, import_crypto6, import_fs_extra17, logger30;
+var import_path26, import_crypto10, import_fs_extra20, logger31;
 var init_runner = __esm({
   "src/engine/runner.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path25 = __toESM(require("path"));
-    import_crypto6 = require("crypto");
-    import_fs_extra17 = __toESM(require("fs-extra"));
+    import_path26 = __toESM(require("path"));
+    import_crypto10 = require("crypto");
+    import_fs_extra20 = __toESM(require("fs-extra"));
     init_suite_store();
     init_case_store();
     init_variable_store();
     init_result_store();
     init_router();
     init_mcp_session();
+    init_rag_manager();
     init_proactive_checker();
     init_browser_manager();
     init_healing_budget();
@@ -11319,7 +12245,7 @@ var init_runner = __esm({
     init_data_loader();
     init_step_type_detector();
     init_logger();
-    logger30 = createChildLogger("runner");
+    logger31 = createChildLogger("runner");
   }
 });
 
@@ -11353,7 +12279,7 @@ async function runRoutes(fastify) {
       };
       const wsManager = fastify.wsManager;
       const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      logger31.info({ runConfig }, "Run requested via API");
+      logger32.info({ runConfig }, "Run requested via API");
       runTests(rootDir, runConfig, autotestConfig, wsManager).then((result) => {
         wsManager.broadcast("run:complete", {
           runId: result.runId,
@@ -11362,9 +12288,9 @@ async function runRoutes(fastify) {
           skipped: result.skipped,
           duration: result.duration
         });
-        logger31.info({ runId: result.runId, status: result.status }, "API-triggered run complete");
+        logger32.info({ runId: result.runId, status: result.status }, "API-triggered run complete");
       }).catch((err) => {
-        logger31.error({ err }, "API-triggered run failed");
+        logger32.error({ err }, "API-triggered run failed");
         wsManager.broadcast("run:error", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -11395,7 +12321,7 @@ async function runRoutes(fastify) {
     }
   });
 }
-var import_zod14, logger31, ScreenshotMode, VideoMode, TraceMode, StartRunBody, ListRunsQuery;
+var import_zod14, logger32, ScreenshotMode, VideoMode, TraceMode, StartRunBody, ListRunsQuery;
 var init_run2 = __esm({
   "src/server/routes/run.ts"() {
     "use strict";
@@ -11406,7 +12332,7 @@ var init_run2 = __esm({
     init_result_store();
     init_utils2();
     init_logger();
-    logger31 = createChildLogger("routes/run");
+    logger32 = 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"]);
@@ -11496,7 +12422,7 @@ async function parseSwaggerSpec(urlOrJson) {
                 specUrl = new URL(specUrl, url).href;
               }
               urls.unshift(specUrl);
-              logger32.info({ specUrl, pattern: pattern.source }, "Extracted spec URL from HTML page");
+              logger33.info({ specUrl, pattern: pattern.source }, "Extracted spec URL from HTML page");
             }
           }
         }
@@ -11508,7 +12434,7 @@ async function parseSwaggerSpec(urlOrJson) {
     const errors = [];
     for (const tryUrl of uniqueUrls) {
       try {
-        logger32.debug({ tryUrl }, "Trying to fetch OpenAPI spec");
+        logger33.debug({ tryUrl }, "Trying to fetch OpenAPI spec");
         const res = await fetch(tryUrl, {
           headers: { Accept: "application/json, application/yaml, */*" },
           signal: AbortSignal.timeout(15e3)
@@ -11523,7 +12449,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;
-                logger32.info({ tryUrl, format: isYaml ? "YAML" : "JSON" }, "Successfully fetched OpenAPI spec");
+                logger33.info({ tryUrl, format: isYaml ? "YAML" : "JSON" }, "Successfully fetched OpenAPI spec");
                 break;
               }
               errors.push(`${tryUrl}: Parsed but not a valid OpenAPI spec`);
@@ -11537,7 +12463,7 @@ async function parseSwaggerSpec(urlOrJson) {
                 if (parsed && typeof parsed === "object" && (parsed.openapi || parsed.swagger || parsed.paths)) {
                   spec = parsed;
                   fetched = true;
-                  logger32.info({ tryUrl, format: "YAML (text/plain)" }, "Successfully fetched OpenAPI spec");
+                  logger33.info({ tryUrl, format: "YAML (text/plain)" }, "Successfully fetched OpenAPI spec");
                   break;
                 }
               } catch {
@@ -11626,17 +12552,17 @@ function parseSpec(spec) {
       });
     }
   }
-  logger32.info({ title, endpointCount: endpoints.length }, "Parsed OpenAPI spec");
+  logger33.info({ title, endpointCount: endpoints.length }, "Parsed OpenAPI spec");
   return { title, baseUrl, endpoints };
 }
-var import_js_yaml, logger32;
+var import_js_yaml, logger33;
 var init_swagger_parser = __esm({
   "src/ai/swagger-parser.ts"() {
     "use strict";
     init_cjs_shims();
     import_js_yaml = __toESM(require("js-yaml"));
     init_logger();
-    logger32 = createChildLogger("swagger-parser");
+    logger33 = createChildLogger("swagger-parser");
   }
 });
 
@@ -11692,7 +12618,7 @@ async function fetchJiraIssue(issueKey) {
   }
   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`;
-  logger33.info({ issueKey, url: url.replace(/\/rest.*/, "/...") }, "Fetching Jira issue");
+  logger34.info({ issueKey, url: url.replace(/\/rest.*/, "/...") }, "Fetching Jira issue");
   const res = await fetch(url, {
     method: "GET",
     headers: {
@@ -11813,7 +12739,7 @@ async function storyRoutes(fastify) {
       return reply.status(400).send({ error: "Invalid request", details: parsed.error.issues });
     }
     try {
-      const testsDir = import_path26.default.join(rootDir, "tests");
+      const testsDir = import_path27.default.join(rootDir, "tests");
       let storyText = parsed.data.story;
       if (parsed.data.jiraUrl) {
         const issueKey = extractIssueKey(parsed.data.jiraUrl);
@@ -11821,19 +12747,19 @@ async function storyRoutes(fastify) {
           try {
             const jiraContent = await fetchJiraIssue(issueKey);
             storyText = buildEnrichedStory(jiraContent, parsed.data.story || void 0);
-            logger33.info({ issueKey }, "Enriched story with Jira content");
+            logger34.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);
             }
-            logger33.warn({ err: jiraErr }, "Failed to fetch Jira issue \u2014 proceeding with user story only");
+            logger34.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." });
       }
-      logger33.info({ suiteName: parsed.data.suiteName }, "Story generation requested");
+      logger34.info({ suiteName: parsed.data.suiteName }, "Story generation requested");
       const { suiteId, suiteName } = await generateSuiteFromStory(storyText, {
         rootDir,
         outputDir: testsDir,
@@ -11859,9 +12785,9 @@ async function storyRoutes(fastify) {
       return reply.status(400).send({ error: "Invalid request", details: parsed.error.issues });
     }
     const { stories, concurrency } = parsed.data;
-    const testsDir = import_path26.default.join(rootDir, "tests");
+    const testsDir = import_path27.default.join(rootDir, "tests");
     const wsManager = fastify.wsManager;
-    logger33.info({ total: stories.length, concurrency }, "Bulk story generation requested");
+    logger34.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 };
@@ -11874,7 +12800,7 @@ async function storyRoutes(fastify) {
             suiteName: item.suiteName ?? jiraContent.summary
           };
         } catch {
-          logger33.warn({ issueKey }, "Failed to fetch Jira issue for bulk item \u2014 using raw story");
+          logger34.warn({ issueKey }, "Failed to fetch Jira issue for bulk item \u2014 using raw story");
           return { story: item.story, suiteName: item.suiteName };
         }
       })
@@ -11885,7 +12811,7 @@ async function storyRoutes(fastify) {
       wsManager,
       concurrency
     ).catch((err) => {
-      logger33.error({ err }, "Bulk story generation error");
+      logger34.error({ err }, "Bulk story generation error");
     });
     return reply.status(202).send({
       message: `Processing ${stories.length} stories in the background`,
@@ -11927,7 +12853,7 @@ async function storyRoutes(fastify) {
     }
     try {
       const spec = await parseSwaggerSpec(parsed.data.specUrl);
-      logger33.info({ title: spec.title, endpoints: spec.endpoints.length }, "Parsed OpenAPI spec");
+      logger34.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()));
@@ -11939,7 +12865,7 @@ async function storyRoutes(fastify) {
       const MAX_ENDPOINTS = 20;
       const totalEndpoints = endpoints.length;
       if (endpoints.length > MAX_ENDPOINTS) {
-        logger33.warn({ total: endpoints.length, max: MAX_ENDPOINTS }, "Capping endpoints to max");
+        logger34.warn({ total: endpoints.length, max: MAX_ENDPOINTS }, "Capping endpoints to max");
         endpoints = endpoints.slice(0, MAX_ENDPOINTS);
       }
       const storyLines = [
@@ -11971,7 +12897,7 @@ async function storyRoutes(fastify) {
       }
       const storyText = storyLines.join("\n");
       const suiteName = parsed.data.suiteName ?? `${spec.title} API Tests`;
-      const testsDir = import_path26.default.join(rootDir, "tests");
+      const testsDir = import_path27.default.join(rootDir, "tests");
       const { suiteId } = await generateSuiteFromStory(storyText, {
         rootDir,
         outputDir: testsDir,
@@ -11991,18 +12917,18 @@ async function storyRoutes(fastify) {
     }
   });
 }
-var import_path26, import_zod15, logger33, GenerateStoryBody, FetchJiraBody;
+var import_path27, import_zod15, logger34, GenerateStoryBody, FetchJiraBody;
 var init_story = __esm({
   "src/server/routes/story.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path26 = __toESM(require("path"));
+    import_path27 = __toESM(require("path"));
     import_zod15 = require("zod");
     init_router();
     init_swagger_parser();
     init_utils2();
     init_logger();
-    logger33 = createChildLogger("routes/story");
+    logger34 = createChildLogger("routes/story");
     GenerateStoryBody = import_zod15.z.object({
       story: import_zod15.z.string().default(""),
       suiteName: import_zod15.z.string().min(1).optional(),
@@ -12043,14 +12969,14 @@ async function reportRoutes(fastify) {
   fastify.delete("/report/:runId", async (req, reply) => {
     try {
       await deleteResult(rootDir, req.params.runId);
-      logger34.info({ runId: req.params.runId }, "Run result deleted");
+      logger35.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, logger34, ListReportsQuery;
+var import_zod16, logger35, ListReportsQuery;
 var init_report = __esm({
   "src/server/routes/report.ts"() {
     "use strict";
@@ -12059,7 +12985,7 @@ var init_report = __esm({
     init_result_store();
     init_utils2();
     init_logger();
-    logger34 = createChildLogger("routes/report");
+    logger35 = createChildLogger("routes/report");
     ListReportsQuery = import_zod16.z.object({
       limit: import_zod16.z.coerce.number().int().positive().max(100).default(20)
     });
@@ -12068,26 +12994,26 @@ var init_report = __esm({
 
 // src/storage/baseline-store.ts
 function baselinesDir(rootDir) {
-  return import_path27.default.join(rootDir, "results", "baselines");
+  return import_path28.default.join(rootDir, "results", "baselines");
 }
 function baselinePath(rootDir, stepId) {
-  return import_path27.default.join(baselinesDir(rootDir), `${stepId}.png`);
+  return import_path28.default.join(baselinesDir(rootDir), `${stepId}.png`);
 }
 async function saveBaseline(rootDir, stepId, sourcePath) {
   const dir = baselinesDir(rootDir);
-  await import_fs_extra18.default.ensureDir(dir);
-  await import_fs_extra18.default.copy(sourcePath, baselinePath(rootDir, stepId), { overwrite: true });
+  await import_fs_extra21.default.ensureDir(dir);
+  await import_fs_extra21.default.copy(sourcePath, baselinePath(rootDir, stepId), { overwrite: true });
 }
 async function hasBaseline(rootDir, stepId) {
-  return import_fs_extra18.default.pathExists(baselinePath(rootDir, stepId));
+  return import_fs_extra21.default.pathExists(baselinePath(rootDir, stepId));
 }
-var import_path27, import_fs_extra18;
+var import_path28, import_fs_extra21;
 var init_baseline_store = __esm({
   "src/storage/baseline-store.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path27 = __toESM(require("path"));
-    import_fs_extra18 = __toESM(require("fs-extra"));
+    import_path28 = __toESM(require("path"));
+    import_fs_extra21 = __toESM(require("fs-extra"));
   }
 });
 
@@ -12098,26 +13024,26 @@ async function mediaRoutes(fastify) {
     if (!["screenshots", "videos", "traces", "logs", "baselines"].includes(category)) {
       return reply.status(404).send({ error: "Unknown media category" });
     }
-    const safeName = import_path28.default.basename(filename);
-    const filePath = import_path28.default.join(fastify.rootDir, "results", category, safeName);
-    if (!await import_fs_extra19.default.pathExists(filePath)) {
+    const safeName = import_path29.default.basename(filename);
+    const filePath = import_path29.default.join(fastify.rootDir, "results", category, safeName);
+    if (!await import_fs_extra22.default.pathExists(filePath)) {
       return reply.status(404).send({ error: `File not found: ${safeName}` });
     }
-    const ext = import_path28.default.extname(safeName).toLowerCase();
+    const ext = import_path29.default.extname(safeName).toLowerCase();
     const mimeType = MIME[ext] ?? "application/octet-stream";
     if (ext === ".zip") {
       void reply.header("Content-Disposition", `attachment; filename="${safeName}"`);
     }
-    const stat = await import_fs_extra19.default.stat(filePath);
+    const stat = await import_fs_extra22.default.stat(filePath);
     void reply.header("Content-Length", stat.size);
-    return reply.type(mimeType).send(import_fs_extra19.default.createReadStream(filePath));
+    return reply.type(mimeType).send(import_fs_extra22.default.createReadStream(filePath));
   });
   fastify.post("/baselines/:stepId/capture", async (req, reply) => {
     try {
       const body = req.body;
       if (!body?.screenshotPath) return reply.status(400).send({ error: "screenshotPath required" });
-      const fullPath = import_path28.default.isAbsolute(body.screenshotPath) ? body.screenshotPath : import_path28.default.join(fastify.rootDir, body.screenshotPath);
-      if (!await import_fs_extra19.default.pathExists(fullPath)) return reply.status(404).send({ error: "Screenshot not found" });
+      const fullPath = import_path29.default.isAbsolute(body.screenshotPath) ? body.screenshotPath : import_path29.default.join(fastify.rootDir, body.screenshotPath);
+      if (!await import_fs_extra22.default.pathExists(fullPath)) return reply.status(404).send({ error: "Screenshot not found" });
       await saveBaseline(fastify.rootDir, req.params.stepId, fullPath);
       return reply.send({ saved: true });
     } catch (err) {
@@ -12128,21 +13054,21 @@ async function mediaRoutes(fastify) {
     try {
       const exists = await hasBaseline(fastify.rootDir, req.params.stepId);
       if (!exists) return reply.send({ hasBaseline: false });
-      const filePath = import_path28.default.join(fastify.rootDir, "results", "baselines", `${req.params.stepId}.png`);
-      const stat = await import_fs_extra19.default.stat(filePath).catch(() => null);
+      const filePath = import_path29.default.join(fastify.rootDir, "results", "baselines", `${req.params.stepId}.png`);
+      const stat = await import_fs_extra22.default.stat(filePath).catch(() => null);
       return reply.send({ hasBaseline: true, capturedAt: stat?.mtimeMs ?? Date.now() });
     } catch (err) {
       return sendError(reply, 500, "Failed to check baseline", err);
     }
   });
 }
-var import_path28, import_fs_extra19, MIME;
+var import_path29, import_fs_extra22, MIME;
 var init_media = __esm({
   "src/server/routes/media.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path28 = __toESM(require("path"));
-    import_fs_extra19 = __toESM(require("fs-extra"));
+    import_path29 = __toESM(require("path"));
+    import_fs_extra22 = __toESM(require("fs-extra"));
     init_baseline_store();
     init_utils2();
     MIME = {
@@ -12166,13 +13092,13 @@ function toAdf(text) {
   }));
   return { type: "doc", version: 1, content: paragraphs };
 }
-var logger35, XrayClient;
+var logger36, XrayClient;
 var init_client = __esm({
   "src/xray/client.ts"() {
     "use strict";
     init_cjs_shims();
     init_logger();
-    logger35 = createChildLogger("xray-client");
+    logger36 = createChildLogger("xray-client");
     XrayClient = class {
       config;
       authHeader;
@@ -12188,7 +13114,7 @@ var init_client = __esm({
       // ─── Jira REST API helpers ──────────────────────────────────────────────────
       async jiraRequest(method, path37, body) {
         const url = `${this.config.jiraBaseUrl}/rest/api/3${path37}`;
-        logger35.debug({ method, url }, "Jira API request");
+        logger36.debug({ method, url }, "Jira API request");
         const headers = {
           "Authorization": this.authHeader,
           "Accept": "application/json"
@@ -12203,7 +13129,7 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger35.error({ status: res.status, url, body: text }, "Jira API error");
+          logger36.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;
@@ -12235,7 +13161,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}`;
-        logger35.debug({ method, url }, "Xray API request");
+        logger36.debug({ method, url }, "Xray API request");
         const headers = {
           "Accept": "application/json"
         };
@@ -12254,7 +13180,7 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger35.error({ status: res.status, url, body: text }, "Xray API error");
+          logger36.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;
@@ -12323,7 +13249,7 @@ var init_client = __esm({
         warnings
       }
     }`;
-        logger35.info({ caseName: testCase.name, projectKey: this.config.projectKey, folderPath }, "Creating Test via Xray Cloud GraphQL");
+        logger36.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");
@@ -12332,9 +13258,9 @@ var init_client = __esm({
         const jiraKey = test.jira?.key ?? "";
         const warnings = result.createTest.warnings;
         if (warnings && warnings.length > 0) {
-          logger35.warn({ warnings, jiraKey }, "Xray createTest warnings");
+          logger36.warn({ warnings, jiraKey }, "Xray createTest warnings");
         }
-        logger35.info({ issueId: test.issueId, jiraKey, stepCount: testCase.steps.length, folderPath }, "Xray Test created via GraphQL");
+        logger36.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 */
@@ -12347,7 +13273,7 @@ var init_client = __esm({
           issuetype: { name: issueType },
           labels: ["assuremind", ...testCase.tags]
         };
-        logger35.info({ caseName: testCase.name, projectKey: this.config.projectKey }, "Creating Xray Test via Jira REST");
+        logger36.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);
@@ -12363,7 +13289,7 @@ var init_client = __esm({
           description: toAdf(testCase.description || `Automated test case: ${testCase.name}`),
           labels: ["assuremind", ...testCase.tags]
         };
-        logger35.info({ issueKey: testIssue.key, caseName: testCase.name }, "Updating Xray Test");
+        logger36.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);
@@ -12402,7 +13328,7 @@ var init_client = __esm({
         warnings
       }
     }`;
-        logger35.info({ suiteName: suite.name, projectKey: this.config.projectKey, testCount: testIssueIds?.length }, "Creating Test Set via Xray Cloud GraphQL");
+        logger36.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");
@@ -12411,9 +13337,9 @@ var init_client = __esm({
         const jiraKey = testSet.jira?.key ?? "";
         const warnings = result.createTestSet.warnings;
         if (warnings && warnings.length > 0) {
-          logger35.warn({ warnings, jiraKey }, "Xray createTestSet warnings");
+          logger36.warn({ warnings, jiraKey }, "Xray createTestSet warnings");
         }
-        logger35.info({ issueId: testSet.issueId, jiraKey }, "Xray Test Set created via GraphQL");
+        logger36.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 */
@@ -12426,7 +13352,7 @@ var init_client = __esm({
           issuetype: { name: issueType },
           labels: ["assuremind", ...suite.tags]
         };
-        logger35.info({ suiteName: suite.name, projectKey: this.config.projectKey }, "Creating Xray Test Set via Jira REST");
+        logger36.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 };
       }
@@ -12439,7 +13365,7 @@ var init_client = __esm({
           description: toAdf(suite.description || `Automated test suite: ${suite.name}`),
           labels: ["assuremind", ...suite.tags]
         };
-        logger35.info({ issueKey, suiteName: suite.name }, "Updating Xray Test Set");
+        logger36.info({ issueKey, suiteName: suite.name }, "Updating Xray Test Set");
         await this.jiraRequest("PUT", `/issue/${issueKey}`, { fields });
       }
       // ─── Test Steps ────────────────────────────────────────────────────────────
@@ -12456,7 +13382,7 @@ var init_client = __esm({
         if (this.isXrayCloud) {
           const xrayId = await this.resolveXrayIssueId(testIssue.key, "Test");
           if (!xrayId) {
-            logger35.warn({ testKey: testIssue.key }, "Cannot add steps \u2014 Test not found in Xray yet");
+            logger36.warn({ testKey: testIssue.key }, "Cannot add steps \u2014 Test not found in Xray yet");
             return;
           }
           await this.addTestStepsCloud(xrayId, steps);
@@ -12491,16 +13417,16 @@ var init_client = __esm({
           } catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
             if (errMsg.includes("not found")) {
-              logger35.warn({ xrayIssueId }, "Xray issue not found during step add \u2014 aborting");
+              logger36.warn({ xrayIssueId }, "Xray issue not found during step add \u2014 aborting");
               break;
             }
-            logger35.warn({ xrayIssueId, step: action, err: errMsg }, "Failed to add test step");
+            logger36.warn({ xrayIssueId, step: action, err: errMsg }, "Failed to add test step");
           }
         }
         if (added > 0) {
-          logger35.info({ xrayIssueId, added, total: steps.length }, "Test steps added via Xray Cloud GraphQL");
+          logger36.info({ xrayIssueId, added, total: steps.length }, "Test steps added via Xray Cloud GraphQL");
         } else if (steps.length > 0) {
-          logger35.warn({ xrayIssueId }, "Failed to add any steps");
+          logger36.warn({ xrayIssueId }, "Failed to add any steps");
         }
       }
       /** Xray Server/DC — use REST API /test/{key}/step */
@@ -12513,14 +13439,14 @@ var init_client = __esm({
         }));
         try {
           await this.xrayRequest("PUT", `/test/${testIssueKey}/step`, xraySteps);
-          logger35.debug({ testIssueKey, stepCount: steps.length }, "Test steps added");
+          logger36.debug({ testIssueKey, stepCount: steps.length }, "Test steps added");
         } catch (err) {
-          logger35.warn({ testIssueKey, err }, "Bulk step add failed, trying one-by-one");
+          logger36.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) {
-              logger35.warn({ testIssueKey, step: step.index, err: stepErr }, "Individual step add failed");
+              logger36.warn({ testIssueKey, step: step.index, err: stepErr }, "Individual step add failed");
             }
           }
         }
@@ -12532,7 +13458,7 @@ var init_client = __esm({
         if (this.isXrayCloud) {
           const xrayId = await this.resolveXrayIssueId(testIssue.key, "Test");
           if (!xrayId) {
-            logger35.warn({ testKey: testIssue.key }, "Cannot replace steps \u2014 Test not found in Xray");
+            logger36.warn({ testKey: testIssue.key }, "Cannot replace steps \u2014 Test not found in Xray");
             return;
           }
           await this.addTestStepsCloud(xrayId, steps);
@@ -12544,7 +13470,7 @@ var init_client = __esm({
             await this.xrayRequest("DELETE", `/test/${testIssue.key}/step/${step.id}`);
           }
         } catch {
-          logger35.debug({ testIssueKey: testIssue.key }, "No existing steps to delete (or endpoint unavailable)");
+          logger36.debug({ testIssueKey: testIssue.key }, "No existing steps to delete (or endpoint unavailable)");
         }
         await this.addTestStepsServerDC(testIssue.key, steps);
       }
@@ -12563,9 +13489,9 @@ var init_client = __esm({
             await this.xrayRequest("POST", `/testset/${testSet.key}/test`, {
               add: tests.map((t) => t.key)
             });
-            logger35.info({ testSetKey: testSet.key, count: tests.length }, "Tests linked to Test Set");
+            logger36.info({ testSetKey: testSet.key, count: tests.length }, "Tests linked to Test Set");
           } catch (err) {
-            logger35.warn({ testSetKey: testSet.key, err }, "Xray link API failed, trying Jira issue links");
+            logger36.warn({ testSetKey: testSet.key, err }, "Xray link API failed, trying Jira issue links");
             await this.linkViaJiraIssueLinks(testSet.key, tests.map((t) => t.key));
           }
         }
@@ -12575,10 +13501,10 @@ var init_client = __esm({
        * Resolves Xray internal IDs first (they differ from Jira numeric IDs).
        */
       async linkTestsCloud(testSet, tests) {
-        logger35.info({ testSetKey: testSet.key, testKeys: tests.map((t) => t.key) }, "Resolving Xray IDs for linking");
+        logger36.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) {
-          logger35.error({ testSetKey: testSet.key }, "Cannot link \u2014 Test Set not found in Xray");
+          logger36.error({ testSetKey: testSet.key }, "Cannot link \u2014 Test Set not found in Xray");
           return;
         }
         const xrayTestIds = [];
@@ -12587,11 +13513,11 @@ var init_client = __esm({
           if (xrayTestId) {
             xrayTestIds.push(xrayTestId);
           } else {
-            logger35.warn({ testKey: test.key }, "Could not resolve Xray ID for test \u2014 skipping");
+            logger36.warn({ testKey: test.key }, "Could not resolve Xray ID for test \u2014 skipping");
           }
         }
         if (xrayTestIds.length === 0) {
-          logger35.warn({ testSetKey: testSet.key }, "No test IDs resolved \u2014 skipping link");
+          logger36.warn({ testSetKey: testSet.key }, "No test IDs resolved \u2014 skipping link");
           return;
         }
         try {
@@ -12607,7 +13533,7 @@ var init_client = __esm({
         }`
           );
           if (result) {
-            logger35.info({
+            logger36.info({
               testSetKey: testSet.key,
               xrayTestSetId,
               count: xrayTestIds.length,
@@ -12616,7 +13542,7 @@ var init_client = __esm({
             }, "Tests linked to Test Set via Xray Cloud");
           }
         } catch (err) {
-          logger35.error({ testSetKey: testSet.key, xrayTestSetId, err: err instanceof Error ? err.message : String(err) }, "linkTestsCloud failed");
+          logger36.error({ testSetKey: testSet.key, xrayTestSetId, err: err instanceof Error ? err.message : String(err) }, "linkTestsCloud failed");
         }
       }
       sleep(ms) {
@@ -12632,7 +13558,7 @@ var init_client = __esm({
               outwardIssue: { key: testKey }
             });
           } catch (linkErr) {
-            logger35.error({ testSetKey, testKey, err: linkErr }, "Failed to link test to test set");
+            logger36.error({ testSetKey, testKey, err: linkErr }, "Failed to link test to test set");
           }
         }
       }
@@ -12645,7 +13571,7 @@ var init_client = __esm({
        */
       async createFolderAndAddTests(folderName, tests) {
         if (!this.isXrayCloud) {
-          logger35.debug("Folder creation skipped \u2014 only supported on Xray Cloud");
+          logger36.debug("Folder creation skipped \u2014 only supported on Xray Cloud");
           return;
         }
         if (tests.length === 0) return;
@@ -12667,11 +13593,11 @@ var init_client = __esm({
             }
           }`
             );
-            logger35.info({ folderPath, projectId }, "Test Repository folder created");
+            logger36.info({ folderPath, projectId }, "Test Repository folder created");
           } catch (folderErr) {
             const errMsg = folderErr instanceof Error ? folderErr.message : String(folderErr);
             if (errMsg.includes("already exists")) {
-              logger35.info({ folderPath }, "Test Repository folder already exists \u2014 reusing");
+              logger36.info({ folderPath }, "Test Repository folder already exists \u2014 reusing");
             } else {
               throw folderErr;
             }
@@ -12682,14 +13608,14 @@ var init_client = __esm({
             if (xrayId) {
               xrayTestIds.push(xrayId);
             } else {
-              logger35.warn({ testKey: test.key }, "Could not resolve Xray ID for folder \u2014 skipping");
+              logger36.warn({ testKey: test.key }, "Could not resolve Xray ID for folder \u2014 skipping");
             }
           }
           if (xrayTestIds.length === 0) {
-            logger35.warn({ folderPath }, "No Xray IDs resolved \u2014 cannot add tests to folder");
+            logger36.warn({ folderPath }, "No Xray IDs resolved \u2014 cannot add tests to folder");
             return;
           }
-          logger35.info({ folderPath, xrayTestIds }, "Adding tests to folder with resolved Xray IDs");
+          logger36.info({ folderPath, xrayTestIds }, "Adding tests to folder with resolved Xray IDs");
           try {
             await this.xrayGraphQL(
               `mutation {
@@ -12703,12 +13629,12 @@ var init_client = __esm({
             }
           }`
             );
-            logger35.info({ folderPath, count: xrayTestIds.length }, "Tests added to folder");
+            logger36.info({ folderPath, count: xrayTestIds.length }, "Tests added to folder");
           } catch (addErr) {
-            logger35.warn({ folderPath, err: addErr instanceof Error ? addErr.message : String(addErr) }, "Failed to add tests to folder");
+            logger36.warn({ folderPath, err: addErr instanceof Error ? addErr.message : String(addErr) }, "Failed to add tests to folder");
           }
         } catch (err) {
-          logger35.error({ folderName, err: err instanceof Error ? err.message : String(err) }, "FAILED to create folder or add tests \u2014 tests exist but are unorganized");
+          logger36.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 ────────────────────────────────────────────
@@ -12726,12 +13652,12 @@ var init_client = __esm({
         });
         if (!res.ok) {
           const text = await res.text();
-          logger35.warn({ status: res.status, body: text }, "Xray Cloud GraphQL request failed");
+          logger36.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) {
-          logger35.warn({ errors: result.errors }, "Xray Cloud GraphQL returned errors");
+          logger36.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;
@@ -12749,7 +13675,7 @@ var init_client = __esm({
         const delays = [0, 5e3, 1e4, 2e4];
         for (let attempt = 0; attempt < delays.length; attempt++) {
           if (delays[attempt] > 0) {
-            logger35.info({ jiraKey, attempt, delay: delays[attempt] }, `Waiting ${delays[attempt] / 1e3}s before retry`);
+            logger36.info({ jiraKey, attempt, delay: delays[attempt] }, `Waiting ${delays[attempt] / 1e3}s before retry`);
             await this.sleep(delays[attempt]);
           }
           try {
@@ -12762,21 +13688,21 @@ var init_client = __esm({
               }
             }
           }`;
-            logger35.info({ jiraKey, attempt, query: queryName }, `Querying Xray for ${type} issueId`);
+            logger36.info({ jiraKey, attempt, query: queryName }, `Querying Xray for ${type} issueId`);
             const result = await this.xrayGraphQL(gql);
             const queryResult = result?.[resultField];
-            logger35.info({ jiraKey, attempt, total: queryResult?.total, resultCount: queryResult?.results?.length, raw: JSON.stringify(queryResult) }, `Xray ${queryName} response`);
+            logger36.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) {
-              logger35.info({ jiraKey, xrayIssueId: items[0].issueId, attempt }, `Resolved Xray issueId for ${type}`);
+              logger36.info({ jiraKey, xrayIssueId: items[0].issueId, attempt }, `Resolved Xray issueId for ${type}`);
               return items[0].issueId;
             }
-            logger35.warn({ jiraKey, attempt, total: queryResult?.total }, `Xray has not indexed ${type} yet \u2014 no results`);
+            logger36.warn({ jiraKey, attempt, total: queryResult?.total }, `Xray has not indexed ${type} yet \u2014 no results`);
           } catch (err) {
-            logger35.warn({ jiraKey, attempt, err: err instanceof Error ? err.message : String(err) }, `resolveXrayIssueId attempt ${attempt} failed`);
+            logger36.warn({ jiraKey, attempt, err: err instanceof Error ? err.message : String(err) }, `resolveXrayIssueId attempt ${attempt} failed`);
           }
         }
-        logger35.error({ jiraKey }, `Could not resolve Xray issueId for ${type} after ${delays.length} attempts`);
+        logger36.error({ jiraKey }, `Could not resolve Xray issueId for ${type} after ${delays.length} attempts`);
         return null;
       }
       // ─── Validation ────────────────────────────────────────────────────────────
@@ -12842,11 +13768,11 @@ var init_xray = __esm({
 
 // src/storage/xray-store.ts
 function mappingPath(rootDir) {
-  return import_path29.default.join(rootDir, "assuremind-data", MAPPING_FILE);
+  return import_path30.default.join(rootDir, "assuremind-data", MAPPING_FILE);
 }
 async function readXrayMapping(rootDir) {
   const filePath = mappingPath(rootDir);
-  if (!await import_fs_extra20.default.pathExists(filePath)) {
+  if (!await import_fs_extra23.default.pathExists(filePath)) {
     return {
       projectKey: "",
       suites: [],
@@ -12856,17 +13782,17 @@ async function readXrayMapping(rootDir) {
   const raw = await readJson(filePath);
   const result = XrayMappingFileSchema.safeParse(raw);
   if (!result.success) {
-    logger36.warn({ path: filePath, errors: result.error.issues }, "Invalid xray-mapping.json \u2014 returning empty");
+    logger37.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;
 }
 async function writeXrayMapping(rootDir, mapping) {
   const filePath = mappingPath(rootDir);
-  await import_fs_extra20.default.ensureDir(import_path29.default.dirname(filePath));
+  await import_fs_extra23.default.ensureDir(import_path30.default.dirname(filePath));
   const data = { ...mapping, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await atomicWriteJson(filePath, data);
-  logger36.debug({ path: filePath }, "Xray mapping written");
+  logger37.debug({ path: filePath }, "Xray mapping written");
 }
 function findSuiteMapping(mapping, suiteId) {
   return mapping.suites.find((s) => s.suiteId === suiteId);
@@ -12898,24 +13824,24 @@ function upsertCaseMapping(suiteMapping, caseMapping) {
   }
   return { ...suiteMapping, cases };
 }
-var import_path29, import_fs_extra20, logger36, MAPPING_FILE;
+var import_path30, import_fs_extra23, logger37, MAPPING_FILE;
 var init_xray_store = __esm({
   "src/storage/xray-store.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path29 = __toESM(require("path"));
-    import_fs_extra20 = __toESM(require("fs-extra"));
+    import_path30 = __toESM(require("path"));
+    import_fs_extra23 = __toESM(require("fs-extra"));
     init_xray();
     init_utils();
     init_logger();
-    logger36 = createChildLogger("xray-store");
+    logger37 = createChildLogger("xray-store");
     MAPPING_FILE = "xray-mapping.json";
   }
 });
 
 // src/xray/service.ts
 function contentHash(obj) {
-  return import_crypto7.default.createHash("sha256").update(JSON.stringify(obj)).digest("hex").slice(0, 16);
+  return import_crypto11.default.createHash("sha256").update(JSON.stringify(obj)).digest("hex").slice(0, 16);
 }
 function suiteHash(suite) {
   return contentHash({ name: suite.name, description: suite.description, tags: suite.tags });
@@ -12929,18 +13855,18 @@ function caseHash(tc) {
     steps: tc.steps.map((s) => ({ instruction: s.instruction, code: s.generatedCode }))
   });
 }
-var import_crypto7, logger37, XrayService;
+var import_crypto11, logger38, XrayService;
 var init_service = __esm({
   "src/xray/service.ts"() {
     "use strict";
     init_cjs_shims();
-    import_crypto7 = __toESM(require("crypto"));
+    import_crypto11 = __toESM(require("crypto"));
     init_client();
     init_xray_store();
     init_suite_store();
     init_case_store();
     init_logger();
-    logger37 = createChildLogger("xray-service");
+    logger38 = createChildLogger("xray-service");
     XrayService = class {
       client;
       rootDir;
@@ -13048,7 +13974,7 @@ var init_service = __esm({
         const results = [];
         let sm = findSuiteMapping(mapping, suiteId);
         if (sm) {
-          logger37.info({ suiteId }, "Suite already mapped in Xray \u2014 delegating to sync");
+          logger38.info({ suiteId }, "Suite already mapped in Xray \u2014 delegating to sync");
           return this.syncSuite(suiteId);
         }
         const folderPath = `/${suite.name}`;
@@ -13077,7 +14003,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" });
-            logger37.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
+            logger38.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
           } catch (err) {
             results.push({
               success: false,
@@ -13097,9 +14023,9 @@ var init_service = __esm({
         if (allTestPairs.length > 0) {
           try {
             await this.client.createFolderAndAddTests(suite.name, allTestPairs);
-            logger37.info({ folderPath, testCount: allTestPairs.length }, "Tests organized into folder");
+            logger38.info({ folderPath, testCount: allTestPairs.length }, "Tests organized into folder");
           } catch (err) {
-            logger37.warn({ folderPath, err: err instanceof Error ? err.message : String(err) }, "Folder organization failed (non-fatal)");
+            logger38.warn({ folderPath, err: err instanceof Error ? err.message : String(err) }, "Folder organization failed (non-fatal)");
           }
         }
         if (!findSuiteMapping(mapping, suiteId)?.xrayTestSetId) {
@@ -13116,7 +14042,7 @@ var init_service = __esm({
             mapping = upsertSuiteMapping(mapping, sm);
             await writeXrayMapping(this.rootDir, mapping);
             results.push({ success: true, suiteId, xrayKey: testSet.key, action: "created" });
-            logger37.info({ suiteId, xrayKey: testSet.key, testCount: createdTestIssueIds.length }, "Test Set created with linked tests");
+            logger38.info({ suiteId, xrayKey: testSet.key, testCount: createdTestIssueIds.length }, "Test Set created with linked tests");
           } catch (err) {
             results.push({
               success: false,
@@ -13185,7 +14111,7 @@ var init_service = __esm({
               { key: caseResult.result.xrayKey, id: caseResult.result.xrayId }
             ]);
           } catch (err) {
-            logger37.warn({ err: err instanceof Error ? err.message : String(err) }, "Folder organization failed for single case (non-fatal)");
+            logger38.warn({ err: err instanceof Error ? err.message : String(err) }, "Folder organization failed for single case (non-fatal)");
           }
         }
         if (caseResult.result.xrayId && sm.xrayTestSetIssueId) {
@@ -13195,7 +14121,7 @@ var init_service = __esm({
               [{ key: caseResult.result.xrayKey ?? "", id: caseResult.result.xrayId }]
             );
           } catch (err) {
-            logger37.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to link test to test set");
+            logger38.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to link test to test set");
           }
         }
         return this.summarizeResults([caseResult.result]);
@@ -13226,7 +14152,7 @@ var init_service = __esm({
           const updatedSm = upsertCaseMapping(sm, cm);
           const updatedMapping = upsertSuiteMapping(mapping, updatedSm);
           await writeXrayMapping(this.rootDir, updatedMapping);
-          logger37.info({ caseId: tc.id, xrayKey: test.key, xrayId: test.id }, "Test created");
+          logger38.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
@@ -13292,7 +14218,7 @@ var init_service = __esm({
             mapping = upsertSuiteMapping(mapping, sm);
             await writeXrayMapping(this.rootDir, mapping);
             results.push({ success: true, suiteId, xrayKey: testSet.key, action: "created" });
-            logger37.info({ suiteId, xrayKey: testSet.key }, "Test Set created during sync (was missing)");
+            logger38.info({ suiteId, xrayKey: testSet.key }, "Test Set created during sync (was missing)");
           } catch (err) {
             results.push({
               success: false,
@@ -13388,11 +14314,11 @@ var init_service = __esm({
                 try {
                   await this.client.createFolderAndAddTests(suite.name, newTests);
                 } catch (folderErr) {
-                  logger37.warn({ err: folderErr instanceof Error ? folderErr.message : String(folderErr) }, "Folder organization failed for synced tests (non-fatal)");
+                  logger38.warn({ err: folderErr instanceof Error ? folderErr.message : String(folderErr) }, "Folder organization failed for synced tests (non-fatal)");
                 }
               }
             } catch (err) {
-              logger37.warn({ err }, "Failed to link new tests to test set");
+              logger38.warn({ err }, "Failed to link new tests to test set");
             }
           }
         }
@@ -13549,7 +14475,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger38.info("Creating all suites and cases in Xray");
+      logger39.info("Creating all suites and cases in Xray");
       const result = await service.createAll();
       return reply.send(result);
     } catch (err) {
@@ -13560,7 +14486,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger38.info({ suiteId: req.params.suiteId }, "Creating suite in Xray");
+      logger39.info({ suiteId: req.params.suiteId }, "Creating suite in Xray");
       const result = await service.createSuite(req.params.suiteId);
       return reply.send(result);
     } catch (err) {
@@ -13584,7 +14510,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger38.info("Syncing all suites and cases with Xray");
+      logger39.info("Syncing all suites and cases with Xray");
       const result = await service.syncAll();
       return reply.send(result);
     } catch (err) {
@@ -13595,7 +14521,7 @@ async function xrayRoutes(fastify) {
     const service = requireService(reply);
     if (!service) return;
     try {
-      logger38.info({ suiteId: req.params.suiteId }, "Syncing suite with Xray");
+      logger39.info({ suiteId: req.params.suiteId }, "Syncing suite with Xray");
       const result = await service.syncSuite(req.params.suiteId);
       return reply.send(result);
     } catch (err) {
@@ -13626,7 +14552,7 @@ async function xrayRoutes(fastify) {
     }
   });
 }
-var logger38;
+var logger39;
 var init_xray2 = __esm({
   "src/server/routes/xray.ts"() {
     "use strict";
@@ -13634,21 +14560,21 @@ var init_xray2 = __esm({
     init_service();
     init_utils2();
     init_logger();
-    logger38 = createChildLogger("xray-routes");
+    logger39 = createChildLogger("xray-routes");
   }
 });
 
 // src/git/service.ts
-var import_simple_git, import_fs_extra21, import_path30, logger39, GitService;
+var import_simple_git, import_fs_extra24, import_path31, logger40, GitService;
 var init_service2 = __esm({
   "src/git/service.ts"() {
     "use strict";
     init_cjs_shims();
     import_simple_git = __toESM(require("simple-git"));
-    import_fs_extra21 = __toESM(require("fs-extra"));
-    import_path30 = __toESM(require("path"));
+    import_fs_extra24 = __toESM(require("fs-extra"));
+    import_path31 = __toESM(require("path"));
     init_logger();
-    logger39 = createChildLogger("git-service");
+    logger40 = createChildLogger("git-service");
     GitService = class {
       git;
       rootDir;
@@ -13710,7 +14636,7 @@ var init_service2 = __esm({
         try {
           await this.git.checkout(branch);
           this.broadcastLog("Checkout branch", "done", branch);
-          logger39.info({ branch }, "Switched branch");
+          logger40.info({ branch }, "Switched branch");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           this.broadcastLog("Checkout branch", "error", msg);
@@ -13728,7 +14654,7 @@ var init_service2 = __esm({
           const hash = result.commit || "unknown";
           this.broadcastLog("Create commit", "done", hash);
           this.broadcastDone("commit");
-          logger39.info({ hash, message }, "Commit created");
+          logger40.info({ hash, message }, "Commit created");
           return hash;
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -13745,7 +14671,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");
-          logger39.info({ rebase }, "Pull completed");
+          logger40.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")) {
@@ -13767,7 +14693,7 @@ var init_service2 = __esm({
           await this.git.push();
           this.broadcastLog("Push to origin", "done");
           this.broadcastDone("push");
-          logger39.info("Push completed");
+          logger40.info("Push completed");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           this.broadcastLog("Push to origin", "error", msg);
@@ -13814,7 +14740,7 @@ var init_service2 = __esm({
             throw pushErr;
           }
           this.broadcastDone("full-sync");
-          logger39.info("Full sync completed");
+          logger40.info("Full sync completed");
         } catch (err) {
           this.broadcastDone("full-sync");
           throw err;
@@ -13846,8 +14772,8 @@ var init_service2 = __esm({
         return status.conflicted;
       }
       async getFileConflictContent(filePath) {
-        const fullPath = import_path30.default.join(this.rootDir, filePath);
-        const content = await import_fs_extra21.default.readFile(fullPath, "utf-8");
+        const fullPath = import_path31.default.join(this.rootDir, filePath);
+        const content = await import_fs_extra24.default.readFile(fullPath, "utf-8");
         let ours = "";
         let theirs = "";
         let section = "none";
@@ -13873,10 +14799,10 @@ var init_service2 = __esm({
         return { ours: ours.trimEnd(), theirs: theirs.trimEnd() };
       }
       async resolveConflict(filePath, resolvedContent) {
-        const fullPath = import_path30.default.join(this.rootDir, filePath);
-        await import_fs_extra21.default.writeFile(fullPath, resolvedContent, "utf-8");
+        const fullPath = import_path31.default.join(this.rootDir, filePath);
+        await import_fs_extra24.default.writeFile(fullPath, resolvedContent, "utf-8");
         await this.git.add(filePath);
-        logger39.info({ filePath }, "Conflict resolved");
+        logger40.info({ filePath }, "Conflict resolved");
       }
       async continueRebase() {
         this.broadcastLog("Continuing rebase...", "running");
@@ -13951,10 +14877,10 @@ async function generateCommitMessage(diff) {
     cleaned = cleaned.replace(/^["'`]+|["'`]+$/g, "");
     cleaned = cleaned.replace(/^(commit message:?\s*)/i, "");
     cleaned = cleaned.split("\n")[0].trim();
-    logger40.info({ messageLength: cleaned.length }, "AI commit message generated");
+    logger41.info({ messageLength: cleaned.length }, "AI commit message generated");
     return cleaned || "chore: update files";
   } catch (err) {
-    logger40.warn({ err: err instanceof Error ? err.message : String(err) }, "AI commit message generation failed");
+    logger41.warn({ err: err instanceof Error ? err.message : String(err) }, "AI commit message generation failed");
     return "chore: update files";
   }
 }
@@ -13981,21 +14907,21 @@ ${theirs}`);
     const provider = createProvider(void 0, { temperature: 0.4 });
     let result = await provider.generateCode(instruction, context);
     result = result.replace(/^```[\w]*\n?/, "").replace(/\n?```$/, "");
-    logger40.info({ filePath, resultLength: result.length }, "AI conflict resolution generated");
+    logger41.info({ filePath, resultLength: result.length }, "AI conflict resolution generated");
     return result;
   } catch (err) {
-    logger40.warn({ filePath, err: err instanceof Error ? err.message : String(err) }, "AI conflict resolution failed");
+    logger41.warn({ filePath, err: err instanceof Error ? err.message : String(err) }, "AI conflict resolution failed");
     throw err;
   }
 }
-var logger40;
+var logger41;
 var init_ai = __esm({
   "src/git/ai.ts"() {
     "use strict";
     init_cjs_shims();
     init_router();
     init_logger();
-    logger40 = createChildLogger("git-ai");
+    logger41 = createChildLogger("git-ai");
   }
 });
 
@@ -14012,7 +14938,7 @@ async function gitRoutes(fastify) {
       _isGitRepo = true;
     } catch {
       _isGitRepo = false;
-      logger41.info("Project directory is not a git repository \u2014 git features disabled");
+      logger42.info("Project directory is not a git repository \u2014 git features disabled");
     }
     return _isGitRepo;
   };
@@ -14188,7 +15114,7 @@ async function gitRoutes(fastify) {
       const changedFiles = stdout.split("\n").filter(Boolean);
       const { listSuiteDirs: listSuiteDirs2, readSuite: readSuite2 } = await Promise.resolve().then(() => (init_suite_store(), suite_store_exports));
       const { listCases: listCases2 } = await Promise.resolve().then(() => (init_case_store(), case_store_exports));
-      const testsDir = import_path31.default.join(rootDir, "tests");
+      const testsDir = import_path32.default.join(rootDir, "tests");
       const suiteDirs = await listSuiteDirs2(testsDir);
       const impacted = [];
       for (const suiteDir of suiteDirs) {
@@ -14198,8 +15124,8 @@ async function gitRoutes(fastify) {
           for (const tc of cases) {
             const allText = [tc.name, tc.description ?? "", ...tc.steps.map((s) => s.instruction)].join(" ").toLowerCase();
             for (const file of changedFiles) {
-              const basename = import_path31.default.basename(file).toLowerCase();
-              const dirname = import_path31.default.dirname(file).toLowerCase();
+              const basename = import_path32.default.basename(file).toLowerCase();
+              const dirname = import_path32.default.dirname(file).toLowerCase();
               if (allText.includes(basename) || allText.includes(dirname)) {
                 impacted.push({ caseId: tc.id, caseName: tc.name, suiteId: suite.id, suiteName: suite.name, reason: `Mentions "${file}"` });
                 break;
@@ -14215,18 +15141,18 @@ async function gitRoutes(fastify) {
     }
   });
 }
-var import_path31, import_zod18, logger41, CheckoutBody, CommitBody, PullBody, FullSyncBody, ResolveConflictBody, ResolveConflictAIBody;
+var import_path32, import_zod18, logger42, CheckoutBody, CommitBody, PullBody, FullSyncBody, ResolveConflictBody, ResolveConflictAIBody;
 var init_git = __esm({
   "src/server/routes/git.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path31 = __toESM(require("path"));
+    import_path32 = __toESM(require("path"));
     import_zod18 = require("zod");
     init_service2();
     init_ai();
     init_utils2();
     init_logger();
-    logger41 = createChildLogger("git-routes");
+    logger42 = 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() });
@@ -14271,12 +15197,12 @@ function parseCSV(content) {
 }
 async function dataFileRoutes(fastify) {
   const rootDir = fastify.rootDir;
-  const dataDir = import_path32.default.join(rootDir, "tests", "data");
-  await import_fs_extra22.default.ensureDir(dataDir);
+  const dataDir = import_path33.default.join(rootDir, "tests", "data");
+  await import_fs_extra25.default.ensureDir(dataDir);
   fastify.get("/data-files", async (_req, reply) => {
     try {
-      await import_fs_extra22.default.ensureDir(dataDir);
-      const entries = await import_fs_extra22.default.readdir(dataDir, { withFileTypes: true });
+      await import_fs_extra25.default.ensureDir(dataDir);
+      const entries = await import_fs_extra25.default.readdir(dataDir, { withFileTypes: true });
       const files = entries.filter((e) => e.isFile() && ALLOWED_EXTENSIONS.some((ext) => e.name.endsWith(ext))).map((e) => ({
         name: e.name,
         type: e.name.endsWith(".csv") ? "csv" : "json",
@@ -14289,12 +15215,12 @@ async function dataFileRoutes(fastify) {
   });
   fastify.get("/data-files/:filename", async (req, reply) => {
     try {
-      const filename = import_path32.default.basename(req.params.filename);
-      const filePath = import_path32.default.join(dataDir, filename);
-      if (!await import_fs_extra22.default.pathExists(filePath)) {
+      const filename = import_path33.default.basename(req.params.filename);
+      const filePath = import_path33.default.join(dataDir, filename);
+      if (!await import_fs_extra25.default.pathExists(filePath)) {
         return reply.status(404).send({ error: `Data file "${filename}" not found` });
       }
-      const raw = await import_fs_extra22.default.readFile(filePath, "utf8");
+      const raw = await import_fs_extra25.default.readFile(filePath, "utf8");
       let rows;
       if (filename.endsWith(".csv")) {
         rows = parseCSV(raw);
@@ -14315,14 +15241,14 @@ async function dataFileRoutes(fastify) {
       if (!filename) {
         return reply.status(400).send({ error: "filename is required" });
       }
-      const ext = import_path32.default.extname(filename).toLowerCase();
+      const ext = import_path33.default.extname(filename).toLowerCase();
       if (!ALLOWED_EXTENSIONS.includes(ext)) {
         return reply.status(400).send({ error: `Only ${ALLOWED_EXTENSIONS.join(", ")} files are allowed` });
       }
-      const safeName = import_path32.default.basename(filename);
-      const filePath = import_path32.default.join(dataDir, safeName);
-      await import_fs_extra22.default.ensureDir(dataDir);
-      await import_fs_extra22.default.writeFile(filePath, content, "utf8");
+      const safeName = import_path33.default.basename(filename);
+      const filePath = import_path33.default.join(dataDir, safeName);
+      await import_fs_extra25.default.ensureDir(dataDir);
+      await import_fs_extra25.default.writeFile(filePath, content, "utf8");
       let rowCount = 0;
       try {
         if (ext === ".csv") {
@@ -14333,7 +15259,7 @@ async function dataFileRoutes(fastify) {
         }
       } catch {
       }
-      logger42.info({ filename: safeName, rowCount }, "Data file uploaded");
+      logger43.info({ filename: safeName, rowCount }, "Data file uploaded");
       return reply.status(201).send({
         filename: safeName,
         path: `data/${safeName}`,
@@ -14345,13 +15271,13 @@ async function dataFileRoutes(fastify) {
   });
   fastify.put("/data-files/:filename", async (req, reply) => {
     try {
-      const filename = import_path32.default.basename(req.params.filename);
-      const filePath = import_path32.default.join(dataDir, filename);
+      const filename = import_path33.default.basename(req.params.filename);
+      const filePath = import_path33.default.join(dataDir, filename);
       const body = req.body;
       const content = String(body.content ?? "");
-      await import_fs_extra22.default.ensureDir(dataDir);
-      await import_fs_extra22.default.writeFile(filePath, content, "utf8");
-      logger42.info({ filename }, "Data file updated");
+      await import_fs_extra25.default.ensureDir(dataDir);
+      await import_fs_extra25.default.writeFile(filePath, content, "utf8");
+      logger43.info({ filename }, "Data file updated");
       return reply.send({ filename, path: `data/${filename}` });
     } catch (err) {
       return sendError(reply, 500, "Failed to update data file", err);
@@ -14359,29 +15285,29 @@ async function dataFileRoutes(fastify) {
   });
   fastify.delete("/data-files/:filename", async (req, reply) => {
     try {
-      const filename = import_path32.default.basename(req.params.filename);
-      const filePath = import_path32.default.join(dataDir, filename);
-      if (!await import_fs_extra22.default.pathExists(filePath)) {
+      const filename = import_path33.default.basename(req.params.filename);
+      const filePath = import_path33.default.join(dataDir, filename);
+      if (!await import_fs_extra25.default.pathExists(filePath)) {
         return reply.status(404).send({ error: `Data file "${filename}" not found` });
       }
-      await import_fs_extra22.default.remove(filePath);
-      logger42.info({ filename }, "Data file deleted");
+      await import_fs_extra25.default.remove(filePath);
+      logger43.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, logger42, ALLOWED_EXTENSIONS;
+var import_path33, import_fs_extra25, logger43, ALLOWED_EXTENSIONS;
 var init_data_files = __esm({
   "src/server/routes/data-files.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path32 = __toESM(require("path"));
-    import_fs_extra22 = __toESM(require("fs-extra"));
+    import_path33 = __toESM(require("path"));
+    import_fs_extra25 = __toESM(require("fs-extra"));
     init_utils2();
     init_logger();
-    logger42 = createChildLogger("routes/data-files");
+    logger43 = createChildLogger("routes/data-files");
     ALLOWED_EXTENSIONS = [".json", ".csv"];
   }
 });
@@ -14400,7 +15326,7 @@ function matchWeight(matchedOn) {
   }
 }
 async function searchRoutes(fastify) {
-  const testsDir = import_path33.default.join(fastify.rootDir, "tests");
+  const testsDir = import_path34.default.join(fastify.rootDir, "tests");
   fastify.get("/search", async (req, reply) => {
     const q = (req.query.q ?? "").trim();
     if (q.length < 2) {
@@ -14462,12 +15388,12 @@ async function searchRoutes(fastify) {
     }
   });
 }
-var import_path33;
+var import_path34;
 var init_search = __esm({
   "src/server/routes/search.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path33 = __toESM(require("path"));
+    import_path34 = __toESM(require("path"));
     init_suite_store();
     init_case_store();
     init_utils2();
@@ -14748,13 +15674,13 @@ var init_flakiness = __esm({
 
 // src/storage/step-library-store.ts
 function libraryPath(rootDir) {
-  return import_path34.default.join(rootDir, "tests", ".step-library.json");
+  return import_path35.default.join(rootDir, "tests", ".step-library.json");
 }
 async function readLibrary(rootDir) {
   const filePath = libraryPath(rootDir);
-  if (!await import_fs_extra23.default.pathExists(filePath)) return [];
+  if (!await import_fs_extra26.default.pathExists(filePath)) return [];
   try {
-    const raw = await import_fs_extra23.default.readJson(filePath);
+    const raw = await import_fs_extra26.default.readJson(filePath);
     if (!Array.isArray(raw)) return [];
     return raw.map((item) => LibraryStepSchema.parse(item));
   } catch {
@@ -14763,7 +15689,7 @@ async function readLibrary(rootDir) {
 }
 async function writeLibrary(rootDir, steps) {
   const filePath = libraryPath(rootDir);
-  await import_fs_extra23.default.ensureDir(import_path34.default.dirname(filePath));
+  await import_fs_extra26.default.ensureDir(import_path35.default.dirname(filePath));
   await atomicWriteJson(filePath, steps);
 }
 async function addStep(rootDir, data) {
@@ -14773,6 +15699,7 @@ async function addStep(rootDir, data) {
     id: (0, import_uuid3.v4)(),
     name: data.name,
     instruction: data.instruction,
+    generatedCode: data.generatedCode ?? "",
     tags: data.tags ?? [],
     createdAt: now2,
     updatedAt: now2
@@ -14794,13 +15721,13 @@ async function deleteStep(rootDir, id) {
   const filtered = steps.filter((s) => s.id !== id);
   await writeLibrary(rootDir, filtered);
 }
-var import_path34, import_fs_extra23, import_uuid3, import_zod20, LibraryStepSchema;
+var import_path35, import_fs_extra26, import_uuid3, import_zod20, LibraryStepSchema;
 var init_step_library_store = __esm({
   "src/storage/step-library-store.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path34 = __toESM(require("path"));
-    import_fs_extra23 = __toESM(require("fs-extra"));
+    import_path35 = __toESM(require("path"));
+    import_fs_extra26 = __toESM(require("fs-extra"));
     import_uuid3 = require("uuid");
     import_zod20 = require("zod");
     init_utils();
@@ -14808,6 +15735,7 @@ var init_step_library_store = __esm({
       id: import_zod20.z.string(),
       name: import_zod20.z.string().min(1),
       instruction: import_zod20.z.string().min(1),
+      generatedCode: import_zod20.z.string().optional().default(""),
       tags: import_zod20.z.array(import_zod20.z.string()).default([]),
       createdAt: import_zod20.z.string(),
       updatedAt: import_zod20.z.string()
@@ -14854,6 +15782,40 @@ async function stepLibraryRoutes(fastify) {
       return sendError(reply, 500, "Failed to delete library step", err);
     }
   });
+  fastify.post("/step-library/:id/generate", async (req, reply) => {
+    let mcpSession;
+    try {
+      const steps = await readLibrary(rootDir);
+      const step = steps.find((s) => s.id === req.params.id);
+      if (!step) return reply.status(404).send({ error: `Library step "${req.params.id}" not found` });
+      const config = await readConfig(rootDir);
+      const variables = await resolveVariables(rootDir).catch(() => ({}));
+      const 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: "",
+        interactiveElements: "",
+        htmlSnapshot: "",
+        previousSteps: [],
+        variables
+      });
+      await router.getCache().persist();
+      const updated = await updateStep(rootDir, step.id, { generatedCode: result.code });
+      return reply.send({ step: updated, strategy: result.strategy, cost: result.cost });
+    } catch (err) {
+      return sendError(reply, 500, "Failed to generate code for library step", err);
+    } finally {
+      mcpSession?.release();
+    }
+  });
 }
 var import_zod21, CreateBody, UpdateBody;
 var init_step_library = __esm({
@@ -14862,20 +15824,701 @@ var init_step_library = __esm({
     init_cjs_shims();
     import_zod21 = require("zod");
     init_step_library_store();
+    init_config_store();
+    init_variable_store();
+    init_router();
+    init_mcp_session();
     init_utils2();
     CreateBody = import_zod21.z.object({
       name: import_zod21.z.string().min(1),
       instruction: import_zod21.z.string().min(1),
+      generatedCode: import_zod21.z.string().optional(),
       tags: import_zod21.z.array(import_zod21.z.string()).optional()
     });
     UpdateBody = import_zod21.z.object({
       name: import_zod21.z.string().min(1).optional(),
       instruction: import_zod21.z.string().min(1).optional(),
+      generatedCode: import_zod21.z.string().optional(),
       tags: import_zod21.z.array(import_zod21.z.string()).optional()
     });
   }
 });
 
+// src/engine/recorder.ts
+function buildCaptureScript() {
+  return `
+(function() {
+  if (window.__amListenersAttached) return;
+  window.__amListenersAttached = true;
+
+  // Safety wrapper \u2014 queue if binding not ready
+  var sendQueue = [];
+  function safeSend(json) {
+    if (typeof window.__amSend === 'function') {
+      while (sendQueue.length > 0) { try { window.__amSend(sendQueue.shift()); } catch(e) {} }
+      try { window.__amSend(json); } catch(e) { sendQueue.push(json); }
+    } else { sendQueue.push(json); }
+  }
+  var retryInterval = setInterval(function() {
+    if (typeof window.__amSend === 'function' && sendQueue.length > 0) {
+      while (sendQueue.length > 0) { try { window.__amSend(sendQueue.shift()); } catch(e) { break; } }
+    }
+    if (typeof window.__amSend === 'function') clearInterval(retryInterval);
+  }, 200);
+
+  // \u2500\u2500 Detect iframe context \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // When running inside an iframe, compute a selector for the iframe element
+  // as seen from the parent frame. This lets Node.js use page.frameLocator().
+  var _frameSelector = '';
+  try {
+    if (window !== window.top && window.frameElement) {
+      var iframe = window.frameElement;
+      if (iframe.id) { _frameSelector = '#' + iframe.id; }
+      else if (iframe.getAttribute('name')) { _frameSelector = 'iframe[name="' + iframe.getAttribute('name') + '"]'; }
+      else if (iframe.getAttribute('data-testid')) { _frameSelector = 'iframe[data-testid="' + iframe.getAttribute('data-testid') + '"]'; }
+      else if (iframe.getAttribute('src')) {
+        // Use src but strip query params for stability
+        var src = iframe.getAttribute('src').split('?')[0];
+        _frameSelector = 'iframe[src*="' + src + '"]';
+      }
+      else { _frameSelector = 'iframe'; }
+    }
+  } catch(e) {
+    // Cross-origin iframe \u2014 frameElement is null, try parent postMessage approach
+    // For same-origin iframes this works; cross-origin will use fallback
+    _frameSelector = '';
+  }
+
+  // \u2500\u2500 Collect element metadata \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  function getMeta(el) {
+    var tag = el.tagName.toLowerCase();
+    var type = (el.getAttribute('type') || '').toLowerCase();
+    var meta = {
+      tag: tag,
+      type: type,
+      id: el.id || '',
+      testId: el.getAttribute('data-testid') || el.getAttribute('data-test-id') || el.getAttribute('data-cy') || '',
+      ariaLabel: el.getAttribute('aria-label') || '',
+      ariaRole: el.getAttribute('role') || '',
+      placeholder: el.getAttribute('placeholder') || '',
+      labelText: getLabel(el) || '',
+      innerText: visText(el),
+      title: el.getAttribute('title') || '',
+      name: el.getAttribute('name') || '',
+      value: (el.value !== undefined ? el.value : '') || '',
+      checked: !!el.checked,
+      cssPath: cssPath(el),
+      classes: Array.from(el.classList || []).join(' '),
+    };
+    if (_frameSelector) { meta.frameSelector = _frameSelector; }
+    return meta;
+  }
+
+  function getLabel(el) {
+    if (!el.id) {
+      var wrap = el.closest('label');
+      if (wrap) {
+        var clone = wrap.cloneNode(true);
+        clone.querySelectorAll('input,select,textarea').forEach(function(i) { i.remove(); });
+        var t = clone.textContent.trim();
+        if (t) return t;
+      }
+      return null;
+    }
+    var lbl = document.querySelector('label[for="' + CSS.escape(el.id) + '"]');
+    return lbl ? lbl.textContent.trim() : null;
+  }
+
+  function visText(el) {
+    var t = el.innerText || el.textContent || '';
+    return t.trim().replace(/\\s+/g, ' ').slice(0, 80);
+  }
+
+  function cssPath(el) {
+    if (el.id) return '#' + CSS.escape(el.id);
+    var parts = [], cur = el;
+    for (var i = 0; i < 4 && cur && cur !== document.body; i++) {
+      var sel = cur.tagName.toLowerCase();
+      if (cur.id) { parts.unshift('#' + CSS.escape(cur.id)); break; }
+      var cls = Array.from(cur.classList).filter(function(c) { return !/^(ng-|_|css-|sc-|jsx-|emotion)/.test(c); }).slice(0, 2);
+      if (cls.length) sel += '.' + cls.map(function(c) { return CSS.escape(c); }).join('.');
+      var p = cur.parentElement;
+      if (p) {
+        var sibs = Array.from(p.children).filter(function(s) { return s.tagName === cur.tagName; });
+        if (sibs.length > 1) sel += ':nth-child(' + (sibs.indexOf(cur) + 1) + ')';
+      }
+      parts.unshift(sel);
+      cur = cur.parentElement;
+    }
+    return parts.join(' > ');
+  }
+
+  // Human-readable element description for instructions
+  function descEl(meta) {
+    var t = meta.tag, ty = meta.type;
+    var nm = meta.ariaLabel || meta.labelText || meta.innerText || meta.placeholder || meta.title || meta.testId;
+    if (t === 'a') return 'the "' + (nm || 'link') + '" link';
+    if (t === 'button' || (t === 'input' && ty === 'submit')) return 'the "' + (nm || 'button') + '" button';
+    if (t === 'input') {
+      if (ty === 'checkbox') return 'the "' + (nm || 'checkbox') + '" checkbox';
+      if (ty === 'radio') return 'the "' + (nm || 'radio button') + '" radio button';
+      var lb = meta.labelText || meta.placeholder || nm;
+      return 'the "' + (lb || 'input') + '" field';
+    }
+    if (t === 'textarea') return 'the "' + (meta.labelText || meta.placeholder || nm || 'text area') + '" field';
+    if (t === 'select') return 'the "' + (meta.labelText || nm || 'dropdown') + '" dropdown';
+    if (t === 'img') return 'the "' + (nm || 'image') + '" image';
+    if (['h1','h2','h3','h4','h5','h6'].indexOf(t) >= 0) return 'the "' + (nm || 'heading') + '" heading';
+    return 'the "' + (nm || t) + '" element';
+  }
+
+  // Track the currently active input \u2014 only record its value when the user LEAVES the field
+  var activeInput = null;   // the DOM element being typed into
+  var pendingInput = null;  // the action payload to send
+  function flushInput() {
+    if (pendingInput && activeInput) {
+      // Grab the FINAL value at flush time, not the value when input event fired
+      var meta = getMeta(activeInput);
+      var desc = descEl(meta);
+      pendingInput.instruction = 'Enter "' + activeInput.value + '" in ' + desc;
+      pendingInput.meta = meta;
+      pendingInput.value = activeInput.value;
+      safeSend(JSON.stringify(pendingInput));
+    }
+    pendingInput = null;
+    activeInput = null;
+  }
+
+  // Banner + styles (only in main frame \u2014 iframes don't need the banner)
+  function ensureBanner() {
+    if (window !== window.top) return;
+    if (document.getElementById('__am-banner')) return;
+    var s = document.createElement('style');
+    s.textContent = '@keyframes __amp{0%,100%{opacity:1}50%{opacity:0.3}}.__am-ah{outline:3px solid #22c55e!important;outline-offset:2px;background:rgba(34,197,94,0.08)!important;}.__am-hh{outline:2px dashed #a78bfa!important;outline-offset:1px;}';
+    document.head.appendChild(s);
+    var b = document.createElement('div');
+    b.id = '__am-banner';
+    b.style.cssText = 'position:fixed;top:0;left:0;right:0;z-index:2147483647;background:linear-gradient(90deg,#1e1e2e,#2d1b3d);color:#fff;font:13px system-ui,sans-serif;padding:6px 16px;display:flex;align-items:center;box-shadow:0 2px 8px rgba(0,0,0,0.3);gap:12px;';
+    b.innerHTML = '<span style="display:inline-flex;align-items:center;gap:6px"><span style="width:8px;height:8px;border-radius:50%;background:#ef4444;animation:__amp 1.5s infinite"></span><b>Recording</b></span><span style="opacity:.65;font-size:12px">Shift+Click = assert &nbsp;|&nbsp; Ctrl+Shift+Click = soft assert &nbsp;|&nbsp; Ctrl+Shift+U = URL &nbsp;|&nbsp; Ctrl+Shift+T = title</span>';
+    document.body.appendChild(b);
+  }
+  if (document.body) ensureBanner();
+  else document.addEventListener('DOMContentLoaded', ensureBanner);
+
+  // Hover highlight
+  var lastH = null;
+  document.addEventListener('mouseover', function(e) {
+    var el = e.target;
+    if (!el || !el.tagName || !el.classList) return;
+    if (el.id === '__am-banner' || el.closest('#__am-banner')) return;
+    if (lastH && lastH !== el && lastH.classList) lastH.classList.remove('__am-hh');
+    el.classList.add('__am-hh');
+    lastH = el;
+  }, true);
+  document.addEventListener('mouseout', function(e) {
+    if (e.target && e.target.classList) e.target.classList.remove('__am-hh');
+  }, true);
+
+  // \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+  //  EVENT LISTENERS \u2014 send raw metadata, Node.js resolves locators
+  // \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+  // Click (normal = action, Shift = assert)
+  document.addEventListener('click', function(e) {
+    flushInput();
+    var el = e.target;
+    if (!el || !el.tagName) return;
+    if (el.id === '__am-banner' || el.closest('#__am-banner')) return;
+
+    var meta = getMeta(el);
+    var desc = descEl(meta);
+
+    // Shift+Click = ASSERTION (Ctrl+Shift+Click = SOFT assertion)
+    if (e.shiftKey) {
+      e.preventDefault(); e.stopPropagation(); e.stopImmediatePropagation();
+      var isSoft = e.ctrlKey || e.metaKey;
+      var prefix = isSoft ? 'Soft verify ' : 'Verify ';
+      if (el.classList) { el.classList.add('__am-ah'); setTimeout(function() { el.classList.remove('__am-ah'); }, 1200); }
+
+      var inst = '';
+      if (meta.tag === 'input' || meta.tag === 'textarea') {
+        inst = meta.value ? prefix + desc + ' has value "' + meta.value + '"' : prefix + desc + ' is visible';
+      } else if (meta.type === 'checkbox' || meta.type === 'radio') {
+        inst = prefix + desc + ' is ' + (meta.checked ? 'checked' : 'unchecked');
+      } else {
+        inst = (meta.innerText && meta.innerText.length <= 60) ? prefix + '"' + meta.innerText + '" text is visible' : prefix + desc + ' is visible';
+      }
+      safeSend(JSON.stringify({ action: 'assert', instruction: inst, meta: meta, url: location.href, soft: isSoft }));
+      return;
+    }
+
+    // Normal click
+    if (meta.tag === 'input' && ['submit','button','checkbox','radio','file'].indexOf(meta.type) < 0) return;
+    if (meta.tag === 'textarea' || meta.tag === 'option') return;
+
+    var action = 'click', instruction = 'Click ' + desc;
+    if (meta.type === 'checkbox') { action = meta.checked ? 'check' : 'uncheck'; instruction = (meta.checked ? 'Check' : 'Uncheck') + ' ' + desc; }
+    else if (meta.type === 'radio') { action = 'check'; instruction = 'Select ' + desc; }
+    safeSend(JSON.stringify({ action: action, instruction: instruction, meta: meta, url: location.href }));
+  }, true);
+
+  // Input \u2014 just mark this element as actively being typed into (NO timer, NO intermediate captures)
+  document.addEventListener('input', function(e) {
+    var el = e.target; if (!el || !el.tagName) return;
+    if (el.tagName.toLowerCase() !== 'input' && el.tagName.toLowerCase() !== 'textarea') return;
+    var ty = (el.getAttribute('type') || '').toLowerCase();
+    if (['checkbox','radio','submit','button','file'].indexOf(ty) >= 0) return;
+    // Just mark as active \u2014 we'll capture the FINAL value on blur/click/Enter
+    activeInput = el;
+    pendingInput = { action: 'fill', instruction: '', meta: null, value: '', url: location.href };
+  }, true);
+
+  // Blur \u2014 user left the field \u2192 capture the FINAL value
+  document.addEventListener('blur', function(e) {
+    var el = e.target;
+    if (el && el === activeInput && pendingInput) {
+      flushInput();
+    }
+  }, true);
+
+  // Select change
+  document.addEventListener('change', function(e) {
+    var el = e.target; if (!el || el.tagName.toLowerCase() !== 'select') return;
+    flushInput();
+    var meta = getMeta(el), desc = descEl(meta);
+    var selText = el.options[el.selectedIndex] ? el.options[el.selectedIndex].text : el.value;
+    safeSend(JSON.stringify({ action: 'select', instruction: 'Select "' + selText + '" from ' + desc, meta: meta, value: el.value, url: location.href }));
+  }, true);
+
+  // Keyboard
+  document.addEventListener('keydown', function(e) {
+    if (e.ctrlKey && e.shiftKey && e.key.toLowerCase() === 'u') {
+      e.preventDefault(); e.stopPropagation(); flushInput();
+      var b = document.getElementById('__am-banner');
+      if (b) { b.style.background = 'linear-gradient(90deg,#064e3b,#065f46)'; setTimeout(function() { b.style.background = 'linear-gradient(90deg,#1e1e2e,#2d1b3d)'; }, 800); }
+      var path = location.pathname + location.search + location.hash;
+      safeSend(JSON.stringify({ action: 'assert', instruction: 'Verify the current URL contains "' + (path || '/') + '"', meta: null, value: location.href, url: location.href }));
+      return;
+    }
+    if (e.ctrlKey && e.shiftKey && e.key.toLowerCase() === 't') {
+      e.preventDefault(); e.stopPropagation(); flushInput();
+      var b2 = document.getElementById('__am-banner');
+      if (b2) { b2.style.background = 'linear-gradient(90deg,#064e3b,#065f46)'; setTimeout(function() { b2.style.background = 'linear-gradient(90deg,#1e1e2e,#2d1b3d)'; }, 800); }
+      safeSend(JSON.stringify({ action: 'assert', instruction: 'Verify the page title is "' + document.title + '"', meta: null, value: document.title, url: location.href }));
+      return;
+    }
+    if (e.key === 'Enter') {
+      flushInput();
+      var el = e.target;
+      if (el && el.tagName) {
+        var t = el.tagName.toLowerCase();
+        if (t === 'input' || t === 'textarea') {
+          var meta = getMeta(el), desc = descEl(meta);
+          safeSend(JSON.stringify({ action: 'press', instruction: 'Press Enter on ' + desc, meta: meta, value: 'Enter', url: location.href }));
+        }
+      }
+    } else if (e.key === 'Escape') {
+      flushInput();
+      safeSend(JSON.stringify({ action: 'press', instruction: 'Press Escape', meta: null, value: 'Escape', url: location.href }));
+    } else if (e.key === 'Tab') {
+      flushInput();
+    }
+  }, true);
+})();
+`;
+}
+async function resolveLocator(page, meta) {
+  const candidates = [];
+  const inIframe = !!meta.frameSelector;
+  const framePrefix = inIframe ? `frameLocator('${esc(meta.frameSelector)}').` : "";
+  const base = inIframe ? page.frameLocator(meta.frameSelector) : page;
+  try {
+    const role = meta.ariaRole || getImplicitRole(meta.tag, meta.type);
+    const bestName = meta.ariaLabel || meta.labelText || meta.innerText || meta.title || "";
+    const headingLevel = getHeadingLevel(meta.tag);
+    if (meta.testId) {
+      candidates.push({
+        name: "testid",
+        locator: base.getByTestId(meta.testId),
+        pw: `${framePrefix}getByTestId('${esc(meta.testId)}')`
+      });
+    }
+    if (role && bestName && bestName.length <= 60) {
+      if (headingLevel) {
+        candidates.push({
+          name: "role+name+level",
+          locator: base.getByRole(role, { name: bestName, exact: true, level: headingLevel }),
+          pw: `${framePrefix}getByRole('${role}', { name: '${esc(bestName)}', level: ${headingLevel} })`
+        });
+      }
+      candidates.push({
+        name: "role+name-exact",
+        locator: base.getByRole(role, { name: bestName, exact: true }),
+        pw: `${framePrefix}getByRole('${role}', { name: '${esc(bestName)}' })`
+      });
+      candidates.push({
+        name: "role+name-fuzzy",
+        locator: base.getByRole(role, { name: bestName, exact: false }),
+        pw: `${framePrefix}getByRole('${role}', { name: '${esc(bestName)}' })`
+      });
+    }
+    if (meta.labelText) {
+      candidates.push({
+        name: "label",
+        locator: base.getByLabel(meta.labelText, { exact: true }),
+        pw: `${framePrefix}getByLabel('${esc(meta.labelText)}')`
+      });
+      candidates.push({
+        name: "label-fuzzy",
+        locator: base.getByLabel(meta.labelText, { exact: false }),
+        pw: `${framePrefix}getByLabel('${esc(meta.labelText)}')`
+      });
+    }
+    if (meta.placeholder) {
+      candidates.push({
+        name: "placeholder",
+        locator: base.getByPlaceholder(meta.placeholder, { exact: true }),
+        pw: `${framePrefix}getByPlaceholder('${esc(meta.placeholder)}')`
+      });
+    }
+    if (meta.innerText && meta.innerText.length <= 60) {
+      candidates.push({
+        name: "text-exact",
+        locator: base.getByText(meta.innerText, { exact: true }),
+        pw: `${framePrefix}getByText('${esc(meta.innerText)}')`
+      });
+      candidates.push({
+        name: "text-fuzzy",
+        locator: base.getByText(meta.innerText, { exact: false }),
+        pw: `${framePrefix}getByText('${esc(meta.innerText)}')`
+      });
+    }
+    if (meta.cssPath) {
+      candidates.push({
+        name: "css",
+        locator: base.locator(meta.cssPath),
+        pw: `${framePrefix}locator('${esc(meta.cssPath)}')`
+      });
+    }
+    for (const c of candidates) {
+      try {
+        const count = await c.locator.count();
+        if (count === 1) {
+          logger44.debug({ strategy: c.name, pw: c.pw, inIframe }, "Locator resolved");
+          return c.pw;
+        }
+      } catch {
+      }
+    }
+    if (meta.cssPath) return `${framePrefix}locator('${esc(meta.cssPath)}')`;
+    if (meta.id) return `${framePrefix}locator('#${esc(meta.id)}')`;
+    return `${framePrefix}locator('${esc(meta.tag)}')`;
+  } catch (err) {
+    logger44.warn({ err, meta: meta.cssPath }, "Locator resolution failed \u2014 using CSS fallback");
+    return meta.cssPath ? `${framePrefix}locator('${esc(meta.cssPath)}')` : `${framePrefix}locator('${esc(meta.tag)}')`;
+  }
+}
+function getImplicitRole(tag, type) {
+  if (tag === "button" || tag === "input" && type === "submit") return "button";
+  if (tag === "a") return "link";
+  if (tag === "input") {
+    if (type === "checkbox") return "checkbox";
+    if (type === "radio") return "radio";
+    if (["text", "email", "password", "search", "tel", "url", "number", ""].includes(type)) return "textbox";
+  }
+  if (tag === "textarea") return "textbox";
+  if (tag === "select") return "combobox";
+  if (tag === "img") return "img";
+  if (["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag)) return "heading";
+  return null;
+}
+function getHeadingLevel(tag) {
+  const match = tag.match(/^h([1-6])$/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+var import_playwright2, logger44, TestRecorder;
+var init_recorder = __esm({
+  "src/engine/recorder.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_playwright2 = require("playwright");
+    init_logger();
+    logger44 = createChildLogger("recorder");
+    TestRecorder = class {
+      browser = null;
+      context = null;
+      page = null;
+      actions = [];
+      actionCounter = 0;
+      running = false;
+      options;
+      _setLastUserActionTime = null;
+      constructor(options) {
+        this.options = options;
+      }
+      get isRunning() {
+        return this.running;
+      }
+      get recordedActions() {
+        return [...this.actions];
+      }
+      async start() {
+        if (this.running) throw new Error("Recorder is already running");
+        logger44.info({ url: this.options.startUrl }, "Starting recorder");
+        this.actions = [];
+        this.actionCounter = 0;
+        this.running = true;
+        try {
+          this.browser = await import_playwright2.chromium.launch({
+            headless: false,
+            args: ["--start-maximized"]
+          });
+          this.context = await this.browser.newContext({
+            viewport: this.options.viewport || { width: 1280, height: 720 },
+            ignoreHTTPSErrors: true
+          });
+          await this.context.exposeBinding("__amSend", (_source, raw) => {
+            void this.handleRawAction(raw);
+          });
+          this.page = await this.context.newPage();
+          this.page.on("pageerror", (err) => {
+            logger44.warn({ error: err.message }, "Page error during recording");
+          });
+          const captureCode = buildCaptureScript();
+          const injectIntoFrame = async (frame) => {
+            try {
+              await frame.evaluate(captureCode);
+              logger44.debug({ url: frame.url(), name: frame.name() }, "Capture script injected into frame");
+            } catch (err) {
+              logger44.debug({ err, url: frame.url() }, "Could not inject into frame (likely cross-origin)");
+            }
+          };
+          const injectAllFrames = async (p) => {
+            await injectIntoFrame(p.mainFrame());
+            for (const frame of p.frames()) {
+              if (frame !== p.mainFrame()) {
+                await injectIntoFrame(frame);
+              }
+            }
+          };
+          this.page.on("load", () => {
+            if (!this.running || !this.page) return;
+            setTimeout(() => injectAllFrames(this.page), 150);
+          });
+          this.page.on("frameattached", (frame) => {
+            if (!this.running) return;
+            frame.waitForLoadState("load").then(() => {
+              injectIntoFrame(frame);
+            }).catch(() => {
+            });
+          });
+          this.page.on("framenavigated", (frame) => {
+            if (!this.running || !this.page) return;
+            if (frame === this.page.mainFrame()) return;
+            setTimeout(() => injectIntoFrame(frame), 150);
+          });
+          let lastUrl = "";
+          let lastUserActionTime = 0;
+          const REDIRECT_WINDOW_MS = 3e3;
+          this.page.on("framenavigated", (frame) => {
+            if (!this.running || !this.page) return;
+            if (frame !== this.page.mainFrame()) return;
+            const url = frame.url();
+            if (url === lastUrl || url === "about:blank") return;
+            lastUrl = url;
+            const isInitialNav = this.actionCounter === 0;
+            if (!isInitialNav && lastUserActionTime > 0) {
+              const elapsed = Date.now() - lastUserActionTime;
+              if (elapsed < REDIRECT_WINDOW_MS) {
+                logger44.debug({ url, elapsed }, "Skipping redirect navigation after user action");
+                return;
+              }
+            }
+            const action = {
+              id: `rec-${++this.actionCounter}`,
+              order: this.actionCounter,
+              action: "navigate",
+              instruction: isInitialNav ? `Go to ${url}` : `Navigate to ${url}`,
+              locator: "",
+              url,
+              timestamp: Date.now()
+            };
+            this.actions.push(action);
+            this.options.onAction(action);
+            logger44.debug({ action: action.instruction }, "Recorded navigation");
+          });
+          this._setLastUserActionTime = (t) => {
+            lastUserActionTime = t;
+          };
+          this.page.on("close", () => {
+            if (this.running) {
+              logger44.info("Browser closed by user \u2014 stopping recorder");
+              this.running = false;
+              this.options.onStop?.(this.actions);
+            }
+          });
+          await this.page.goto(this.options.startUrl, { waitUntil: "load", timeout: 3e4 });
+          await injectAllFrames(this.page);
+          logger44.info("Recorder started \u2014 browser is open for interaction");
+        } catch (err) {
+          logger44.error({ err }, "Failed to start recorder");
+          await this.cleanup();
+          throw err;
+        }
+      }
+      async stop() {
+        if (!this.running) return this.actions;
+        logger44.info({ actionCount: this.actions.length }, "Stopping recorder");
+        this.running = false;
+        const result = [...this.actions];
+        await this.cleanup();
+        this.options.onStop?.(result);
+        return result;
+      }
+      /**
+       * Handle a raw action from the browser capture script.
+       * Resolves the best Playwright locator using the live page's DOM + Accessibility tree.
+       */
+      async handleRawAction(raw) {
+        if (!this.running || !this.page) return;
+        try {
+          const parsed = JSON.parse(raw);
+          const meta = parsed.meta;
+          let locator = "";
+          if (meta && this.page) {
+            try {
+              locator = await resolveLocator(this.page, meta);
+            } catch (err) {
+              logger44.warn({ err }, "Locator resolution failed \u2014 using CSS fallback");
+              locator = meta.cssPath ? `locator('${esc(meta.cssPath)}')` : "";
+            }
+          }
+          const userActions = ["click", "fill", "check", "uncheck", "select", "press"];
+          if (userActions.includes(parsed.action) && this._setLastUserActionTime) {
+            this._setLastUserActionTime(Date.now());
+          }
+          const action = {
+            id: `rec-${++this.actionCounter}`,
+            order: this.actionCounter,
+            action: parsed.action,
+            instruction: parsed.instruction,
+            locator,
+            value: parsed.value,
+            url: parsed.url,
+            timestamp: Date.now(),
+            ...parsed.soft ? { soft: true } : {},
+            ...meta?.frameSelector ? { frameSelector: meta.frameSelector } : {}
+          };
+          this.actions.push(action);
+          this.options.onAction(action);
+          logger44.debug({ action: action.instruction, locator, strategy: "resolved" }, "Recorded action");
+        } catch (err) {
+          logger44.warn({ err, raw }, "Failed to parse recorded action");
+        }
+      }
+      async cleanup() {
+        try {
+          if (this.context) await this.context.close().catch(() => {
+          });
+          if (this.browser) await this.browser.close().catch(() => {
+          });
+        } catch {
+        }
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+      }
+    };
+  }
+});
+
+// src/server/routes/recorder.ts
+async function recorderRoutes(fastify) {
+  const rootDir = fastify.rootDir;
+  const wsManager = fastify.wsManager;
+  fastify.post("/recorder/start", async (req, reply) => {
+    try {
+      if (activeRecorder?.isRunning) {
+        return reply.status(409).send({ error: "A recording session is already active. Stop it first." });
+      }
+      const body = StartBody.parse(req.body || {});
+      const config = await readConfig(rootDir);
+      const startUrl = body.url || config.baseUrl || "https://www.google.com";
+      activeRecorder = new TestRecorder({
+        startUrl,
+        viewport: body.viewport,
+        onAction: (action) => {
+          wsManager.broadcast("recorder:action", action);
+        },
+        onStop: (actions) => {
+          wsManager.broadcast("recorder:stopped", { actionCount: actions.length });
+          logger45.info({ actionCount: actions.length }, "Recording stopped (browser closed)");
+        }
+      });
+      await activeRecorder.start();
+      return reply.send({
+        status: "recording",
+        url: startUrl,
+        message: "Browser launched \u2014 interact with your app. Actions are streamed in real time."
+      });
+    } catch (err) {
+      activeRecorder = null;
+      return sendError(reply, 500, "Failed to start recorder", err);
+    }
+  });
+  fastify.post("/recorder/stop", async (_req, reply) => {
+    try {
+      if (!activeRecorder?.isRunning) {
+        return reply.status(404).send({ error: "No active recording session." });
+      }
+      const actions = await activeRecorder.stop();
+      activeRecorder = null;
+      wsManager.broadcast("recorder:stopped", { actionCount: actions.length });
+      return reply.send({
+        status: "stopped",
+        actions,
+        actionCount: actions.length
+      });
+    } catch (err) {
+      activeRecorder = null;
+      return sendError(reply, 500, "Failed to stop recorder", err);
+    }
+  });
+  fastify.get("/recorder/status", async (_req, reply) => {
+    const isRecording = activeRecorder?.isRunning ?? false;
+    const actionCount = activeRecorder?.recordedActions.length ?? 0;
+    return reply.send({
+      recording: isRecording,
+      actionCount,
+      actions: isRecording ? activeRecorder.recordedActions : []
+    });
+  });
+}
+var import_zod22, logger45, StartBody, activeRecorder;
+var init_recorder2 = __esm({
+  "src/server/routes/recorder.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod22 = require("zod");
+    init_recorder();
+    init_config_store();
+    init_utils2();
+    init_logger();
+    logger45 = createChildLogger("recorder-routes");
+    StartBody = import_zod22.z.object({
+      url: import_zod22.z.string().url().optional(),
+      viewport: import_zod22.z.object({
+        width: import_zod22.z.number().int().positive(),
+        height: import_zod22.z.number().int().positive()
+      }).optional()
+    });
+    activeRecorder = null;
+  }
+});
+
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
@@ -14917,17 +16560,18 @@ async function startServer(options) {
   await fastify.register(templatesRoutes, { prefix: "/api" });
   await fastify.register(flakinessRoutes, { prefix: "/api" });
   await fastify.register(stepLibraryRoutes, { prefix: "/api" });
+  await fastify.register(recorderRoutes, { prefix: "/api" });
   await registerStatic(fastify, rootDir);
   await fastify.listen({ port, host: "127.0.0.1" });
-  logger43.info({ port, rootDir }, `Assuremind Studio listening on http://127.0.0.1:${port}`);
+  logger46.info({ port, rootDir }, `Assuremind Studio listening on http://127.0.0.1:${port}`);
   return {
     async close() {
       await fastify.close();
-      logger43.info("Server closed");
+      logger46.info("Server closed");
     }
   };
 }
-var import_fastify, import_cors, import_websocket, logger43;
+var import_fastify, import_cors, import_websocket, logger46;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
@@ -14957,8 +16601,9 @@ var init_server = __esm({
     init_templates();
     init_flakiness();
     init_step_library();
+    init_recorder2();
     init_logger();
-    logger43 = createChildLogger("server");
+    logger46 = createChildLogger("server");
   }
 });
 
@@ -15261,14 +16906,14 @@ async function loadStoryText(options) {
     return options.story;
   }
   if (options.storyFile) {
-    const filePath = import_path35.default.resolve(options.storyFile);
-    if (!await import_fs_extra24.default.pathExists(filePath)) {
+    const filePath = import_path36.default.resolve(options.storyFile);
+    if (!await import_fs_extra27.default.pathExists(filePath)) {
       throw new ConfigError(
         `Story file not found: "${filePath}"`,
         "STORY_FILE_NOT_FOUND"
       );
     }
-    return import_fs_extra24.default.readFile(filePath, "utf8");
+    return import_fs_extra27.default.readFile(filePath, "utf8");
   }
   throw new ConfigError(
     'Provide a story with --story "<text>" or --story-file <path>',
@@ -15291,7 +16936,7 @@ async function runGenerate(options) {
     process.exit(1);
   }
   const rootDir = process.cwd();
-  const outputDir = options.output ? import_path35.default.resolve(options.output) : import_path35.default.join(rootDir, "tests");
+  const outputDir = options.output ? import_path36.default.resolve(options.output) : import_path36.default.join(rootDir, "tests");
   printInfo(`Story: ${colors.dim(`${storyText.slice(0, 80)}${storyText.length > 80 ? "\u2026" : ""}`)}`);
   if (options.suite) {
     printInfo(`Suite name: ${options.suite}`);
@@ -15323,8 +16968,8 @@ async function runGenerate(options) {
       suiteName: options.suite
     });
     genSpinner.succeed("Suite generated");
-    const suiteOutputDir = options.output ?? import_path35.default.join(rootDir, "tests");
-    printSuccess(`Test suite created in: ${import_path35.default.relative(rootDir, suiteOutputDir)}`);
+    const suiteOutputDir = options.output ?? import_path36.default.join(rootDir, "tests");
+    printSuccess(`Test suite created in: ${import_path36.default.relative(rootDir, suiteOutputDir)}`);
     printInfo("Open Studio or use the Test Editor to review and generate Playwright code:");
     process.stdout.write(`  ${colors.accent("npx assuremind studio")}
 
@@ -15335,13 +16980,13 @@ async function runGenerate(options) {
     process.exit(1);
   }
 }
-var import_path35, import_fs_extra24;
+var import_path36, import_fs_extra27;
 var init_generate = __esm({
   "src/cli/generate.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path35 = __toESM(require("path"));
-    import_fs_extra24 = __toESM(require("fs-extra"));
+    import_path36 = __toESM(require("path"));
+    import_fs_extra27 = __toESM(require("fs-extra"));
     init_ui();
     init_env();
     init_errors();
@@ -15355,7 +17000,7 @@ __export(validate_exports, {
 });
 async function checkConfig(rootDir, result) {
   printInfo("Checking configuration\u2026");
-  if (!await import_fs_extra25.default.pathExists(import_path36.default.join(rootDir, "autotest.config.json")) && !await import_fs_extra25.default.pathExists(import_path36.default.join(rootDir, "autotest.config.ts"))) {
+  if (!await import_fs_extra28.default.pathExists(import_path37.default.join(rootDir, "autotest.config.json")) && !await import_fs_extra28.default.pathExists(import_path37.default.join(rootDir, "autotest.config.ts"))) {
     printError('  autotest.config.ts not found \u2014 run "npx assuremind init" to create it');
     result.errors++;
     return;
@@ -15371,7 +17016,7 @@ async function checkConfig(rootDir, result) {
 }
 async function checkEnv(result) {
   printInfo("Checking environment\u2026");
-  if (!await import_fs_extra25.default.pathExists(".env")) {
+  if (!await import_fs_extra28.default.pathExists(".env")) {
     printWarn("  .env file not found \u2014 copy .env.example to .env and fill in your API key");
     result.warnings++;
     return;
@@ -15387,8 +17032,8 @@ async function checkEnv(result) {
 }
 async function checkTests(rootDir, result) {
   printInfo("Scanning test files\u2026");
-  const testsDir = import_path36.default.join(rootDir, "tests");
-  if (!await import_fs_extra25.default.pathExists(testsDir)) {
+  const testsDir = import_path37.default.join(rootDir, "tests");
+  if (!await import_fs_extra28.default.pathExists(testsDir)) {
     printWarn("  tests/ directory not found \u2014 no tests to validate");
     result.warnings++;
     return;
@@ -15408,7 +17053,7 @@ async function checkTests(rootDir, result) {
       try {
         await readCase(casePath);
       } catch {
-        printError(`  Invalid: ${import_path36.default.relative(rootDir, casePath)}`);
+        printError(`  Invalid: ${import_path37.default.relative(rootDir, casePath)}`);
         invalidCases++;
         result.errors++;
       }
@@ -15436,7 +17081,7 @@ async function checkVariables(rootDir, result) {
     try {
       await readVariables(file);
     } catch {
-      printError(`  Invalid: ${import_path36.default.relative(rootDir, file)}`);
+      printError(`  Invalid: ${import_path37.default.relative(rootDir, file)}`);
       invalid++;
       result.errors++;
     }
@@ -15473,13 +17118,13 @@ async function runValidate() {
     process.exit(1);
   }
 }
-var import_path36, import_fs_extra25;
+var import_path37, import_fs_extra28;
 var init_validate = __esm({
   "src/cli/validate.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path36 = __toESM(require("path"));
-    import_fs_extra25 = __toESM(require("fs-extra"));
+    import_path37 = __toESM(require("path"));
+    import_fs_extra28 = __toESM(require("fs-extra"));
     init_ui();
     init_config_store();
     init_suite_store();
@@ -15544,7 +17189,7 @@ async function checkPlaywright() {
   }
 }
 async function checkEnvFile() {
-  if (!await import_fs_extra26.default.pathExists(".env")) {
+  if (!await import_fs_extra29.default.pathExists(".env")) {
     return check(
       ".env file",
       false,
@@ -15582,7 +17227,7 @@ async function checkConfig2() {
   }
 }
 async function checkPackageJson() {
-  if (!await import_fs_extra26.default.pathExists("package.json")) {
+  if (!await import_fs_extra29.default.pathExists("package.json")) {
     return check(
       "package.json",
       false,
@@ -15590,7 +17235,7 @@ async function checkPackageJson() {
     );
   }
   try {
-    const pkg2 = await import_fs_extra26.default.readJson("package.json");
+    const pkg2 = await import_fs_extra29.default.readJson("package.json");
     return check("package.json", true, `${pkg2.name ?? "unnamed"} v${pkg2.version ?? "?"}`);
   } catch {
     return check("package.json", false, "Exists but is not valid JSON");
@@ -15670,13 +17315,13 @@ async function runDoctor() {
     process.exit(1);
   }
 }
-var import_child_process6, import_fs_extra26;
+var import_child_process6, import_fs_extra29;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
     init_cjs_shims();
     import_child_process6 = require("child_process");
-    import_fs_extra26 = __toESM(require("fs-extra"));
+    import_fs_extra29 = __toESM(require("fs-extra"));
     init_ui();
     init_env();
     init_config_store();
@@ -15703,7 +17348,7 @@ async function findCaseFilePath(testsDir, caseId) {
   return null;
 }
 async function applyHealToFile(rootDir, event) {
-  const testsDir = import_path37.default.join(rootDir, "tests");
+  const testsDir = import_path38.default.join(rootDir, "tests");
   const casePath = await findCaseFilePath(testsDir, event.caseId);
   if (!casePath) {
     throw new Error(
@@ -15725,7 +17370,7 @@ async function applyHealToFile(rootDir, event) {
   testCase.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeCase(casePath, testCase);
   printSuccess(
-    `  Updated: ${import_path37.default.relative(rootDir, casePath)} \u203A step "${testCase.steps[stepIdx].instruction}"`
+    `  Updated: ${import_path38.default.relative(rootDir, casePath)} \u203A step "${testCase.steps[stepIdx].instruction}"`
   );
 }
 function ask(rl, question) {
@@ -15867,21 +17512,21 @@ Review the changes and merge if the fixes look correct.
 }
 async function runApplyHealing(options) {
   const rootDir = process.cwd();
-  (0, import_dotenv2.config)({ path: import_path37.default.join(rootDir, ".env") });
+  (0, import_dotenv2.config)({ path: import_path38.default.join(rootDir, ".env") });
   process.stdout.write("\n");
   let events;
   if (options.from) {
-    const reportPath = import_path37.default.resolve(options.from);
-    if (!await import_fs_extra27.default.pathExists(reportPath)) {
+    const reportPath = import_path38.default.resolve(options.from);
+    if (!await import_fs_extra30.default.pathExists(reportPath)) {
       printError(`Healing report not found: ${reportPath}`);
       process.exit(1);
     }
     try {
-      const rawRunId = import_path37.default.basename(reportPath, ".json").replace("healing-report-", "");
+      const rawRunId = import_path38.default.basename(reportPath, ".json").replace("healing-report-", "");
       const report = await readHealingReport(rootDir, rawRunId);
       events = report.events.filter((e) => e.status === "pending");
     } catch {
-      const raw = await import_fs_extra27.default.readJson(reportPath);
+      const raw = await import_fs_extra30.default.readJson(reportPath);
       events = Array.isArray(raw) ? raw.filter((e) => e.status === "pending") : (raw.events ?? []).filter((e) => e.status === "pending");
     }
   } else {
@@ -15910,13 +17555,13 @@ async function runApplyHealing(options) {
     }
   }
 }
-var import_path37, import_fs_extra27, import_readline, import_dotenv2;
+var import_path38, import_fs_extra30, import_readline, import_dotenv2;
 var init_apply_healing = __esm({
   "src/cli/apply-healing.ts"() {
     "use strict";
     init_cjs_shims();
-    import_path37 = __toESM(require("path"));
-    import_fs_extra27 = __toESM(require("fs-extra"));
+    import_path38 = __toESM(require("path"));
+    import_fs_extra30 = __toESM(require("fs-extra"));
     import_readline = __toESM(require("readline"));
     import_dotenv2 = require("dotenv");
     init_healing_store();