mcp-lab-agent 2.1.4 → 2.1.10

package/dist/index.js

@@ -6,8 +6,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { spawn as spawn2 } from "child_process";
-import path5 from "path";
-import fs5 from "fs";
+import path6 from "path";
+import fs6 from "fs";
 import { fileURLToPath, pathToFileURL } from "url";
 
 // src/core/llm-router.js
@@ -42,6 +42,44 @@ function resolveLLMProvider(taskType = "simple") {
 // src/core/memory.js
 import path from "path";
 import fs from "fs";
+
+// src/core/hub-client.js
+var hubUrl = null;
+function getHubUrl() {
+  if (hubUrl) return hubUrl;
+  const env = process.env.LEARNING_HUB_URL || process.env.QA_LAB_LEARNING_HUB_URL;
+  if (env) {
+    hubUrl = env.replace(/\/$/, "");
+    return hubUrl;
+  }
+  return null;
+}
+async function syncLearningsToHub(learnings) {
+  const baseUrl = getHubUrl();
+  if (!baseUrl) return;
+  const entries = Array.isArray(learnings) ? learnings : [learnings];
+  if (entries.length === 0) return;
+  const projectId = process.env.LEARNING_HUB_PROJECT_ID || process.cwd().split("/").pop() || "default";
+  const payload = entries.map((e) => ({
+    ...e,
+    projectId
+  }));
+  try {
+    const res = await fetch(`${baseUrl}/learning`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ learnings: payload })
+    });
+    if (!res.ok) {
+      const txt = await res.text();
+      console.warn(`[learning-hub] POST /learning failed ${res.status}: ${txt}`);
+    }
+  } catch (err) {
+    console.warn("[learning-hub] sync failed:", err.message);
+  }
+}
+
+// src/core/memory.js
 var PROJECT_ROOT = process.cwd();
 var MEMORY_FILE = path.join(PROJECT_ROOT, ".qa-lab-memory.json");
 var FLOWS_CONFIG_FILE2 = path.join(PROJECT_ROOT, "qa-lab-flows.json");
@@ -74,6 +112,8 @@ function saveProjectMemory(updates) {
       data.learnings = data.learnings || [];
       data.learnings.push(...updates.learnings);
       if (data.learnings.length > 200) data.learnings = data.learnings.slice(-150);
+      syncLearningsToHub(updates.learnings).catch(() => {
+      });
     }
     if (updates.execution) {
       data.executions = data.executions || [];
@@ -85,12 +125,17 @@ function saveProjectMemory(updates) {
   } catch {
   }
 }
+var LEARNING_TYPES = ["selector_fix", "timing_fix", "element_not_rendered", "element_not_visible", "element_stale", "mobile_mapping_invisible"];
 function getMemoryStats() {
   const memory = loadProjectMemory();
   const learnings = memory.learnings || [];
   const successfulFixes = learnings.filter((l) => l.success);
   const selectorFixes = learnings.filter((l) => l.type === "selector_fix");
   const timingFixes = learnings.filter((l) => l.type === "timing_fix");
+  const byLearningType = {};
+  for (const t of LEARNING_TYPES) {
+    byLearningType[t] = learnings.filter((l) => l.type === t).length;
+  }
   const totalTests = learnings.filter((l) => l.type === "test_generated").length;
   const firstAttemptSuccess = learnings.filter((l) => l.type === "test_generated" && l.passedFirstTime).length;
   return {
@@ -98,6 +143,7 @@ function getMemoryStats() {
     successfulFixes: successfulFixes.length,
     selectorFixes: selectorFixes.length,
     timingFixes: timingFixes.length,
+    byLearningType,
     testsGenerated: totalTests,
     firstAttemptSuccessRate: totalTests > 0 ? Math.round(firstAttemptSuccess / totalTests * 100) : 0
   };
@@ -141,6 +187,110 @@ var FLAKY_PATTERNS = [
   { name: "network", regex: /ECONNREFUSED|network|fetch|axios|request failed|404|500/i, suggestion: "Mocke APIs ou garanta que o backend esteja rodando. Use retry ou intercept." },
   { name: "shared_state", regex: /state|cleanup|beforeEach|afterEach|isolation/i, suggestion: "Garanta beforeEach/afterEach para resetar estado. Evite vari\xE1veis globais compartilhadas." }
 ];
+var FAILURE_ANALYSIS_PATTERNS = [
+  {
+    name: "element_not_rendered",
+    regex: /timeout|not found|element not found|no such element|element.*not.*in.*dom|waiting for/i,
+    oQueAconteceu: "O elemento ainda n\xE3o foi renderizado no DOM quando o teste tentou interagir. Pode ser carregamento ass\xEDncrono, lazy load ou anima\xE7\xE3o.",
+    lesson: `Espere o elemento estar dispon\xEDvel ANTES de interagir:
+- Playwright: await element.waitFor({ state: 'attached' }) ou waitForSelector
+- Cypress: cy.get(sel).should('exist') antes de clicar
+- WDIO/Appium: $(sel).waitForDisplayed() ou waitForExist({ timeout: 10000 })
+- Use waits inteligentes: waitForDisplayed, waitForClickable, waitForExist`,
+    learningType: "element_not_rendered"
+  },
+  {
+    name: "element_not_visible",
+    regex: /element.*not.*visible|not visible|is not visible|element is not displayed|hidden|display.*none|off.?screen/i,
+    oQueAconteceu: "O elemento existe no DOM mas n\xE3o est\xE1 vis\xEDvel (display:none, off-screen, opacity:0 ou ainda carregando).",
+    lesson: `Verifique visibilidade antes de interagir:
+- Playwright: waitFor({ state: 'visible' })
+- Cypress: .should('be.visible') antes de click
+- Appium/WDIO: waitForDisplayed() ou isDisplayed()
+- Adicione wait expl\xEDcito: elemento pode estar em anima\xE7\xE3o ou carregando`,
+    learningType: "element_not_visible"
+  },
+  {
+    name: "element_stale",
+    regex: /stale element|stale element reference|element.*no longer attached/i,
+    oQueAconteceu: "O elemento foi encontrado mas a p\xE1gina/DOM mudou antes da intera\xE7\xE3o (elemento ficou obsoleto).",
+    lesson: `Re-localize o elemento antes de cada a\xE7\xE3o:
+- Evite guardar refer\xEAncia: busque novamente antes de clicar
+- Use waits que revalidam: cy.get().first().click() com retry
+- Em listas din\xE2micas: espere estabiliza\xE7\xE3o antes de interagir`,
+    learningType: "element_stale"
+  },
+  {
+    name: "mobile_mapping_invisible",
+    regex: /element not found|selector|Unable to find|no such element/i,
+    oQueAconteceu: "Em mobile: o mapeamento ficou invis\xEDvel ou os seletores n\xE3o est\xE3o estruturados. Pode ser estrutura do c\xF3digo ou seletor incorreto.",
+    lesson: `Em testes mobile (Appium/Detox), SEMPRE:
+- Mapeamento VIS\xCDVEL: const ELEMENTS = { btn: '~id' }; $(ELEMENTS.btn).click()
+- Antes de clicar: $(sel).waitForDisplayed({ timeout: 10000 })
+- Ao final: expect(await $(sel).isDisplayed()).toBe(true) \u2014 valida\xE7\xE3o expl\xEDcita para o usu\xE1rio entender que houve valida\xE7\xE3o`,
+    learningType: "mobile_mapping_invisible",
+    mobileOnly: true
+  },
+  {
+    name: "selector",
+    regex: /selector|locator|element not found|Unable to find/i,
+    oQueAconteceu: "O seletor n\xE3o encontrou o elemento. Pode ser seletor incorreto, mudan\xE7a de UI ou elemento em outro contexto (iframe, shadow DOM).",
+    lesson: "Use seletores est\xE1veis: data-testid, role+name, accessibility-id. Evite classes CSS din\xE2micas. Priorize: data-testid > role > texto vis\xEDvel.",
+    learningType: "selector_fix"
+  },
+  {
+    name: "timing",
+    regex: /timeout|timed out|exceeded|slow/i,
+    oQueAconteceu: "O teste excedeu o tempo de espera. O elemento pode demorar para aparecer ou h\xE1 race condition.",
+    lesson: "Adicione wait expl\xEDcito antes de interagir. Aumente timeout se necess\xE1rio. Use waitForDisplayed/waitForSelector.",
+    learningType: "timing_fix"
+  }
+];
+function oneLineFailureSummary(runOutput, framework = "", oQueAconteceu = "", sugestaoCorrecao = "") {
+  const p = inferFailurePattern(runOutput, framework);
+  const causa = oQueAconteceu || p?.oQueAconteceu || "erro desconhecido";
+  const solucao = sugestaoCorrecao || (p ? p.lesson.split("\n")[0].replace(/^-\s*/, "") : "");
+  const tipo = p?.name || "geral";
+  if (solucao) {
+    return `Falhou porque ${causa.slice(0, 80)}${causa.length > 80 ? "\u2026" : ""} (${tipo}). Solu\xE7\xE3o: ${solucao.slice(0, 100)}${solucao.length > 100 ? "\u2026" : ""}`;
+  }
+  return `Falhou porque ${causa.slice(0, 120)}${causa.length > 120 ? "\u2026" : ""} (${tipo}).`;
+}
+function inferFailurePattern(runOutput, framework = "") {
+  const output = (runOutput || "").toLowerCase();
+  for (const p of FAILURE_ANALYSIS_PATTERNS) {
+    if (p.mobileOnly && !/appium|detox/i.test(framework)) continue;
+    if (p.regex.test(output)) return p;
+  }
+  return null;
+}
+var MOBILE_SELECTOR_HIERARCHY = `HIERARQUIA DE SELETORES MOBILE (\xFAnica e inovadora):
+1. id: ~accessibility-id, testID \u2014 prioridade m\xE1xima, sem\xE2ntico e est\xE1vel
+2. XPath relacional: \xE2ncora est\xE1vel + eixos + TIPO ESPEC\xCDFICO (android.widget.Button, XCUIElementTypeButton). NUNCA use * \u2014 quebra por timing e m\xFAltiplos matches. Ex: //android.widget.LinearLayout[@resource-id='login_form']/descendant::android.widget.Button[@text='Entrar']. Evite XPath por \xEDndice (//Button[3])
+3. resource-id: id=com.app:id/btn \u2014 fallback`;
+var MOBILE_MAPPING_LESSON = `Em testes mobile (Appium/Detox), SEMPRE inclua o mapeamento de elementos de forma VIS\xCDVEL e estruturada no c\xF3digo:
+- Use constantes ou Page Object no TOPO do spec: const ELEMENTS = { loginBtn: '~btn_login', ... };
+- No teste: $(ELEMENTS.loginBtn).click();
+- Nunca deixe seletores "invis\xEDveis" (hardcoded inline repetidos). Isso dificulta manuten\xE7\xE3o e causa falhas.
+- Hierarquia: id > XPath relacional (\xE2ncora + eixos + tipo espec\xEDfico: android.widget.Button) > resource-id. Evite * e \xEDndice.`;
+var UNIVERSAL_TEST_PRACTICES = `PR\xC1TICAS OBRIGAT\xD3RIAS em todo teste gerado:
+1. Esperas inteligentes: ANTES de interagir, verifique que o elemento est\xE1 dispon\xEDvel (waitForDisplayed, waitForExist, waitForSelector)
+2. Valida\xE7\xE3o no final: SEMPRE adicione um expect/assert ao final para o usu\xE1rio entender que houve valida\xE7\xE3o (ex: expect(element).toBeVisible() ou cy.get(sel).should('be.visible'))
+3. N\xE3o assuma que o elemento est\xE1 pronto: elemento pode n\xE3o estar renderizado, vis\xEDvel ou dispon\xEDvel \u2014 use waits expl\xEDcitos`;
+function formatLearnedMessageForUser({ pattern, fixSummary, runOutput, framework }) {
+  const p = pattern || (runOutput ? inferFailurePattern(runOutput, framework) : null);
+  const oQueAconteceu = p?.oQueAconteceu || "O teste falhou por um problema de elemento ou timing.";
+  const oQueFiz = fixSummary || (p ? `Apliquei a corre\xE7\xE3o para esse tipo de falha: ${p.name}.` : "Ajustei o c\xF3digo.");
+  return `**Entendi o erro e apliquei a corre\xE7\xE3o**
+
+**O que aconteceu:** ${oQueAconteceu}
+
+**O que fiz:** ${oQueFiz}
+
+**O que aprendi:** Salvei esse cen\xE1rio no meu hist\xF3rico. Nas pr\xF3ximas gera\xE7\xF5es, vou aplicar as pr\xE1ticas corretas (waits inteligentes, valida\xE7\xE3o final) desde o in\xEDcio.
+
+Use \`mcp-lab-agent stats\` ou \`get_learning_report\` para ver a evolu\xE7\xE3o dos aprendizados.`;
+}
 function detectFlakyPatterns(runOutput) {
   const detected = [];
   for (const p of FLAKY_PATTERNS) {
@@ -214,6 +364,9 @@ function detectProjectStructure() {
       structure.hasTests = true;
       structure.hasMobile = true;
     }
+    if (deps["react-native"]) {
+      structure.hasMobile = true;
+    }
     if (deps.supertest) {
       structure.testFrameworks.push("supertest");
       structure.hasTests = true;
@@ -370,6 +523,41 @@ function detectProjectStructure() {
       }
     }
   }
+  const hints = [];
+  if (structure.hasMobile) hints.push("mobile");
+  if (structure.testFrameworks.includes("appium")) hints.push("appium");
+  if (structure.testFrameworks.includes("detox")) hints.push("detox");
+  const pkg = structure.packageJson || {};
+  const allDeps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+  if (allDeps["react-native"]) hints.push("react-native");
+  const webFrameworks = ["cypress", "playwright", "webdriverio", "selenium", "puppeteer", "testcafe"];
+  const hasWebFrameworks = structure.testFrameworks.some((f) => webFrameworks.includes(f));
+  if (hasWebFrameworks) hints.push("web");
+  if (structure.testDirs.includes("mobile")) hints.push("mobile-dir");
+  const configPath = path2.join(PROJECT_ROOT2, "qa-lab-agent.config.json");
+  if (fs2.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+      const customDirs = cfg.testDirs || cfg.qa?.testDirs;
+      if (Array.isArray(customDirs)) {
+        for (const dir of customDirs) {
+          const d = String(dir).trim();
+          if (d && !structure.testDirs.includes(d)) {
+            const fullPath = path2.join(PROJECT_ROOT2, d);
+            if (fs2.existsSync(fullPath) && fs2.statSync(fullPath).isDirectory()) {
+              structure.testDirs.push(d);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  let environment = "web";
+  if (structure.hasMobile && !hasWebFrameworks) environment = "mobile";
+  else if (structure.hasMobile && hasWebFrameworks) environment = "both";
+  structure.environment = environment;
+  structure.environmentHints = [...new Set(hints)];
   return structure;
 }
 var UNIVERSAL_TEST_PATTERNS = [
@@ -450,6 +638,61 @@ function matchesFramework(inferred, requested) {
   if (inferred === requested) return true;
   return aliases[inferred]?.includes(requested);
 }
+function detectDeviceConfig(structure) {
+  const result = { device: null, configuration: null, platform: null, envOverrides: {} };
+  if (!structure.hasMobile) return result;
+  const configPath = path2.join(PROJECT_ROOT2, "qa-lab-agent.config.json");
+  if (fs2.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+      const deviceCfg = cfg.device || cfg.mobile || cfg.appium || cfg.detox;
+      if (deviceCfg) {
+        result.device = deviceCfg.deviceName || deviceCfg.device || deviceCfg.udid;
+        result.configuration = deviceCfg.configuration || deviceCfg.config;
+        result.platform = deviceCfg.platformName || deviceCfg.platform;
+        if (deviceCfg.udid) result.envOverrides.APPIUM_UDID = deviceCfg.udid;
+        if (deviceCfg.deviceName) result.envOverrides.APPIUM_DEVICE_NAME = deviceCfg.deviceName;
+      }
+    } catch {
+    }
+  }
+  if (process.env.DETOX_CONFIGURATION) result.configuration = process.env.DETOX_CONFIGURATION;
+  if (process.env.APPIUM_UDID) result.envOverrides.APPIUM_UDID = process.env.APPIUM_UDID;
+  if (process.env.APPIUM_DEVICE_NAME) result.envOverrides.APPIUM_DEVICE_NAME = process.env.APPIUM_DEVICE_NAME;
+  const detoxPath = path2.join(PROJECT_ROOT2, ".detoxrc.js");
+  if (fs2.existsSync(detoxPath) && !result.configuration) {
+    try {
+      const content = fs2.readFileSync(detoxPath, "utf8");
+      const configMatch = content.match(/configurations:\s*\{([^}]+)\}/s);
+      if (configMatch) {
+        const firstConfig = configMatch[1].match(/"([^"]+)":\s*\{/);
+        if (firstConfig) result.configuration = firstConfig[1];
+      }
+    } catch {
+    }
+  }
+  const wdioPaths = ["wdio.conf.js", "wdio.conf.cjs", "wdio.conf.mjs", "wdio.conf.ts"];
+  for (const name of wdioPaths) {
+    const wdioPath = path2.join(PROJECT_ROOT2, name);
+    if (fs2.existsSync(wdioPath) && !result.device) {
+      try {
+        const content = fs2.readFileSync(wdioPath, "utf8");
+        const capMatch = content.match(/capabilities:\s*\[([\s\S]*?)\]/);
+        if (capMatch) {
+          const deviceMatch = capMatch[1].match(/deviceName:\s*['"]([^'"]+)['"]/);
+          const udidMatch = capMatch[1].match(/udid:\s*['"]([^'"]+)['"]/);
+          const platformMatch = capMatch[1].match(/platformName:\s*['"]([^'"]+)['"]/);
+          if (deviceMatch) result.device = deviceMatch[1];
+          if (udidMatch) result.envOverrides.APPIUM_UDID = udidMatch[1];
+          if (platformMatch) result.platform = platformMatch[1];
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  return result;
+}
 function getFrameworkCwd(structure, preferredDirs) {
   for (const dir of preferredDirs) {
     if (structure.testDirs.includes(dir)) {
@@ -488,11 +731,90 @@ function analyzeCodeRisks() {
   });
 }
 
-// src/core/tool-helpers.js
+// src/core/llm-call.js
 import path3 from "path";
 import fs3 from "fs";
 var PROJECT_ROOT3 = process.cwd();
-var METRICS_FILE = path3.join(PROJECT_ROOT3, ".qa-lab-metrics.json");
+async function callLlm(provider, apiKey, baseUrl, model, systemPrompt, userPrompt) {
+  if (provider === "gemini") {
+    const url = `${baseUrl}/models/${model}:generateContent?key=${apiKey}`;
+    const res2 = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: systemPrompt + "\n\n" + userPrompt }] }],
+        generationConfig: { temperature: 0.2, maxOutputTokens: 4096 }
+      })
+    });
+    const data2 = await res2.json();
+    return data2.candidates?.[0]?.content?.parts?.[0]?.text || "";
+  }
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      temperature: 0.2,
+      max_tokens: 4096
+    })
+  });
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || "";
+}
+async function applySelectorFixAndRetry(testFilePath, errorOutput, framework) {
+  const structure = detectProjectStructure();
+  const fw = framework || inferFrameworkFromFile(testFilePath.split("/").pop(), structure);
+  const fullPath = path3.join(PROJECT_ROOT3, testFilePath.replace(/^\//, "").replace(/\\/g, "/"));
+  if (!fs3.existsSync(fullPath)) return { applied: false };
+  let testCode = "";
+  try {
+    testCode = fs3.readFileSync(fullPath, "utf8");
+  } catch {
+    return { applied: false };
+  }
+  const llm = resolveLLMProvider("complex");
+  if (!llm.apiKey) return { applied: false };
+  const { provider, apiKey, baseUrl, model } = llm;
+  const systemPrompt = `Voc\xEA \xE9 um especialista em testes E2E. O teste falhou porque um seletor n\xE3o encontrou o elemento.
+Retorne APENAS em JSON (sem markdown) com a chave:
+- codigoCorrigido: string (o ARQUIVO COMPLETO do teste corrigido, com imports e toda a estrutura. Substitua o seletor quebrado por um mais resiliente: data-testid, role, ~accessibility-id, ou XPath relacional com tipo espec\xEDfico.)
+
+Framework: ${fw}. Priorize seletores est\xE1veis.`;
+  const userPrompt = `Output do erro:
+---
+${(errorOutput || "").slice(0, 8e3)}
+---
+
+C\xF3digo atual:
+---
+${testCode.slice(0, 6e3)}
+---`;
+  try {
+    let raw = await callLlm(provider, apiKey, baseUrl, model, systemPrompt, userPrompt);
+    raw = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+    const data = JSON.parse(raw);
+    const fixed = (data.codigoCorrigido || "").trim();
+    if (fixed.length > 50 && /describe|it\(|test\(|cy\.|page\.|\$\(/.test(fixed)) {
+      fs3.writeFileSync(fullPath, fixed, "utf8");
+      return { applied: true };
+    }
+  } catch {
+  }
+  return { applied: false };
+}
+
+// src/core/tool-helpers.js
+import path4 from "path";
+import fs4 from "fs";
+var PROJECT_ROOT4 = process.cwd();
+var METRICS_FILE = path4.join(PROJECT_ROOT4, ".qa-lab-metrics.json");
 function parseTestRunResult(runOutput, exitCode) {
   let passed = 0;
   let failed = 0;
@@ -506,8 +828,8 @@ function parseTestRunResult(runOutput, exitCode) {
 function recordMetricEvent(event) {
   try {
     let data = {};
-    if (fs3.existsSync(METRICS_FILE)) {
-      const raw = fs3.readFileSync(METRICS_FILE, "utf8");
+    if (fs4.existsSync(METRICS_FILE)) {
+      const raw = fs4.readFileSync(METRICS_FILE, "utf8");
       try {
         data = JSON.parse(raw);
       } catch {
@@ -517,7 +839,7 @@ function recordMetricEvent(event) {
     data.events.push({ ...event, timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString() });
     data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     if (data.events.length > 500) data.events = data.events.slice(-400);
-    fs3.writeFileSync(METRICS_FILE, JSON.stringify(data, null, 2), "utf8");
+    fs4.writeFileSync(METRICS_FILE, JSON.stringify(data, null, 2), "utf8");
   } catch {
   }
 }
@@ -535,36 +857,12 @@ function extractFailuresFromOutput(runOutput) {
   }
   return failures.slice(0, 20);
 }
-function generateFailureExplanation(testCode, runOutput, memory = {}) {
-  const lines = [];
-  lines.push("# An\xE1lise de Falha\n");
-  lines.push("## C\xF3digo do Teste");
-  lines.push("```");
-  lines.push(testCode.slice(0, 2e3));
-  lines.push("```\n");
-  lines.push("## Output da Execu\xE7\xE3o");
-  lines.push("```");
-  lines.push(runOutput.slice(0, 2e3));
-  lines.push("```\n");
-  if (memory.learnings && memory.learnings.length > 0) {
-    lines.push("## Aprendizados Anteriores (\xFAltimos 5)");
-    memory.learnings.slice(-5).forEach((l) => {
-      lines.push(`- **${l.type}**: ${l.description || "N/A"}`);
-    });
-    lines.push("");
-  }
-  lines.push("## Sua Tarefa");
-  lines.push("1. Identifique a causa raiz da falha");
-  lines.push("2. Sugira uma corre\xE7\xE3o espec\xEDfica");
-  lines.push("3. Explique por que essa corre\xE7\xE3o deve funcionar");
-  return lines.join("\n");
-}
 
 // src/cli/commands.js
-import path4 from "path";
-import fs4 from "fs";
+import path5 from "path";
+import fs5 from "fs";
 import { spawn } from "child_process";
-var PROJECT_ROOT4 = process.cwd();
+var PROJECT_ROOT5 = process.cwd();
 var QA_AGENTS = {
   autonomous: { desc: "Modo aut\xF4nomo: gera, testa, corrige e aprende", tools: ["qa_auto"] },
   detection: { desc: "Detecta estrutura, frameworks, testes", tools: ["detect_project", "read_project", "list_test_files"] },
@@ -574,13 +872,13 @@ var QA_AGENTS = {
   browser: { desc: "Browser mode: screenshots, network, console", tools: ["web_eval_browser"] },
   reporting: { desc: "Relat\xF3rios e m\xE9tricas", tools: ["create_bug_report", "get_business_metrics"] },
   intelligence: { desc: "An\xE1lise preditiva e insights", tools: ["qa_full_analysis", "qa_health_check", "qa_suggest_next_test", "qa_predict_flaky", "qa_compare_with_industry", "qa_time_travel"] },
-  learning: { desc: "Sistema de aprendizado", tools: ["qa_learning_stats"] },
+  learning: { desc: "Sistema de aprendizado", tools: ["qa_learning_stats", "get_learning_report"] },
   maintenance: { desc: "Linter, deps, an\xE1lise de c\xF3digo", tools: ["run_linter", "install_dependencies"] }
 };
 function getExtensionAndBaseDir(fw, structure) {
   const extMap = { cypress: ".cy.js", playwright: ".spec.js", jest: ".test.js", vitest: ".test.js", robot: ".robot", pytest: ".py" };
   const ext = extMap[fw] || ".spec.js";
-  const baseDir = structure.testDirs[0] ? path4.join(PROJECT_ROOT4, structure.testDirs[0]) : path4.join(PROJECT_ROOT4, "tests");
+  const baseDir = structure.testDirs[0] ? path5.join(PROJECT_ROOT5, structure.testDirs[0]) : path5.join(PROJECT_ROOT5, "tests");
   return { ext, baseDir };
 }
 async function handleCLI() {
@@ -594,20 +892,29 @@ USO:
   mcp-lab-agent --help     # Mostra esta ajuda
 
 COMANDOS CLI:
-  slack-bot                             Inicia o Slack Bot (QA via @mention) - sem precisar clonar o repo
+  slack-bot                             Inicia o Slack Bot (QA via @mention)
+  learning-hub                          Inicia o Learning Hub (API + Dashboard em http://localhost:3847)
   analyze                               An\xE1lise completa: executa, analisa estabilidade, prev\xEA riscos e recomenda a\xE7\xF5es
   auto <descri\xE7\xE3o> [--max-retries N]    Modo aut\xF4nomo: gera teste, roda, corrige e aprende (default: 3 tentativas)
-  stats                                 Mostra estat\xEDsticas de aprendizado (taxa de sucesso, corre\xE7\xF5es, etc.)
+  stats                                 Estat\xEDsticas de aprendizado (taxa de sucesso, corre\xE7\xF5es, etc.)
+  report [--full]                        Relat\xF3rio de evolu\xE7\xE3o e aprendizado (--full = completo com recomenda\xE7\xF5es)
+  metrics-report [--json] [--output FILE] [path1 path2 ...]  Relat\xF3rio de m\xE9tricas (m\xE9todo, resultado). Sem paths = projeto atual.
+  flaky-report [--runs N] [--spec FILE] [--output FILE]      Detecta testes flaky: roda N vezes (default 3), identifica intermit\xEAncia e causa prov\xE1vel
+  run [spec] [--device NAME] [--no-auto-fix]                 Roda testes: detecta device, executa e aplica auto-fix de seletor se falhar
   detect [--json]                       Detecta frameworks e estrutura
   route <tarefa>                        Sugere qual ferramenta usar
   list                                  Lista ferramentas MCP dispon\xEDveis
 
 EXEMPLOS:
-  mcp-lab-agent slack-bot                       # Slack Bot (configure em ~/.cursor/mcp.json)
+  mcp-lab-agent slack-bot                       # Slack Bot
+  mcp-lab-agent learning-hub                   # Learning Hub (API + Dashboard)
   npx mcp-lab-agent slack-bot                   # Usar sem instalar (sem clonar o projeto)
   mcp-lab-agent analyze                         # An\xE1lise completa + recomenda\xE7\xF5es
   mcp-lab-agent auto "login flow" --max-retries 5
   mcp-lab-agent stats
+  mcp-lab-agent flaky-report --runs 5 --output flaky.md
+  mcp-lab-agent run specs/login.spec.js
+  mcp-lab-agent run specs/login.spec.js --device iPhone_15
   mcp-lab-agent detect --json
 
 INTEGRA\xC7\xC3O MCP (Cursor/Cline/Windsurf):
@@ -675,31 +982,529 @@ AMBIENTES CORPORATIVOS (APIs bloqueadas):
     console.log(JSON.stringify({ suggestedAgent: agent, suggestedTools: a.tools, description: a.desc }, null, 2));
     return true;
   }
-  if (cmd === "auto") {
-    await handleAutoCommand();
-    return true;
+  if (cmd === "auto") {
+    await handleAutoCommand();
+    return true;
+  }
+  if (cmd === "stats") {
+    const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const byTypeLines = Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `  ${t}: ${v}`).join("\n");
+    console.log(`
+\u{1F4CA} Estat\xEDsticas de Aprendizado
+
+Total de aprendizados: ${stats.totalLearnings}
+Corre\xE7\xF5es bem-sucedidas: ${stats.successfulFixes}
+Corre\xE7\xF5es de seletores: ${stats.selectorFixes}
+Corre\xE7\xF5es de timing: ${stats.timingFixes}
+Testes gerados: ${stats.testsGenerated}
+Taxa de sucesso na 1\xAA tentativa: ${stats.firstAttemptSuccessRate}%
+${byTypeLines ? `
+Por tipo:
+${byTypeLines}` : ""}
+
+${stats.totalLearnings === 0 ? "\u26A0\uFE0F Ainda n\xE3o h\xE1 aprendizados. Use 'mcp-lab-agent auto <descri\xE7\xE3o>' para gerar testes e aprender com erros." : ""}
+`);
+    return true;
+  }
+  if (cmd === "report") {
+    const memory = loadProjectMemory();
+    const learnings = memory.learnings || [];
+    const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const format = process.argv.includes("--full") ? "full" : "summary";
+    const recommendations = [];
+    if (byType.element_not_rendered > 0 || byType.element_not_visible > 0) {
+      recommendations.push("Use waits expl\xEDcitos (waitForSelector, waitForDisplayed) ANTES de interagir com elementos.");
+    }
+    if (byType.timing_fix > 0 || byType.element_stale > 0) {
+      recommendations.push("Aumente timeouts e use re-localiza\xE7\xE3o de elementos em listas din\xE2micas.");
+    }
+    if (byType.selector_fix > 0 || byType.mobile_mapping_invisible > 0) {
+      recommendations.push("Priorize data-testid, role e seletores est\xE1veis; em mobile, use mapeamento vis\xEDvel no topo do spec.");
+    }
+    if (stats.firstAttemptSuccessRate < 70 && stats.testsGenerated > 0) {
+      recommendations.push("Aplique waits inteligentes + assert final em cada teste gerado.");
+    }
+    const byTypeStr = Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `  - ${t}: ${v}`).join("\n");
+    console.log(`
+\u{1F4C8} Relat\xF3rio de Evolu\xE7\xE3o e Aprendizado
+
+Resumo por tipo:
+${byTypeStr || "  Nenhum aprendizado por tipo ainda"}
+
+M\xE9tricas gerais:
+  Total de aprendizados: ${stats.totalLearnings}
+  Taxa de sucesso (1\xAA tentativa): ${stats.firstAttemptSuccessRate}%
+  Testes gerados: ${stats.testsGenerated}
+${format === "full" && recommendations.length > 0 ? `
+Recomenda\xE7\xF5es para aprimorar o c\xF3digo:
+${recommendations.map((r) => `  \u2022 ${r}`).join("\n")}` : ""}
+`);
+    return true;
+  }
+  if (cmd === "analyze") {
+    await handleAnalyzeCommand();
+    return true;
+  }
+  if (cmd === "metrics-report") {
+    await handleMetricsReportCommand();
+    return true;
+  }
+  if (cmd === "flaky-report") {
+    await handleFlakyReportCommand();
+    return true;
+  }
+  if (cmd === "run") {
+    await handleRunCommand();
+    return true;
+  }
+  return false;
+}
+async function handleMetricsReportCommand() {
+  const argv = process.argv.slice(2);
+  const jsonOnly = argv.includes("--json");
+  const outputIdx = argv.indexOf("--output");
+  const outputFile = outputIdx !== -1 && argv[outputIdx + 1] ? argv[outputIdx + 1] : null;
+  const paths = argv.filter((a) => {
+    if (a.startsWith("--") || a === "metrics-report") return false;
+    if (outputIdx !== -1 && a === argv[outputIdx + 1]) return false;
+    return true;
+  });
+  const projectDirs = paths.length > 0 ? paths : [PROJECT_ROOT5];
+  const reports = [];
+  for (const dir of projectDirs) {
+    const resolved = path5.resolve(dir);
+    if (!fs5.existsSync(resolved)) {
+      console.warn(`\u26A0\uFE0F Diret\xF3rio n\xE3o encontrado: ${dir}`);
+      continue;
+    }
+    const memoryPath = path5.join(resolved, ".qa-lab-memory.json");
+    const metricsPath = path5.join(resolved, ".qa-lab-metrics.json");
+    let memory = {};
+    let metrics = { events: [] };
+    if (fs5.existsSync(memoryPath)) {
+      try {
+        memory = JSON.parse(fs5.readFileSync(memoryPath, "utf8"));
+      } catch {
+      }
+    }
+    if (fs5.existsSync(metricsPath)) {
+      try {
+        metrics = JSON.parse(fs5.readFileSync(metricsPath, "utf8"));
+      } catch {
+      }
+    }
+    const events = metrics.events || [];
+    const executions = memory.executions || [];
+    const learnings = memory.learnings || [];
+    const byEventType = {};
+    events.forEach((e) => {
+      const t = e.type || "unknown";
+      byEventType[t] = (byEventType[t] || 0) + 1;
+    });
+    const testRuns = events.filter((e) => e.type === "test_run");
+    const testRunPassed = testRuns.filter((e) => e.exitCode === 0).length;
+    const testRunFailed = testRuns.filter((e) => e.exitCode !== 0).length;
+    const byFramework = {};
+    testRuns.forEach((e) => {
+      const f = e.framework || "unknown";
+      byFramework[f] = byFramework[f] || { total: 0, passed: 0, failed: 0 };
+      byFramework[f].total++;
+      if (e.exitCode === 0) byFramework[f].passed++;
+      else byFramework[f].failed++;
+    });
+    const byLearningType = {};
+    learnings.forEach((l) => {
+      const t = l.type || "unknown";
+      byLearningType[t] = byLearningType[t] || { total: 0, success: 0 };
+      byLearningType[t].total++;
+      if (l.success) byLearningType[t].success++;
+    });
+    const execByFramework = {};
+    executions.forEach((e) => {
+      const f = e.framework || "unknown";
+      execByFramework[f] = execByFramework[f] || { total: 0, passed: 0 };
+      execByFramework[f].total++;
+      if (e.passed) execByFramework[f].passed++;
+    });
+    const projectName = path5.basename(resolved);
+    reports.push({
+      project: projectName,
+      path: resolved,
+      summary: {
+        eventsTotal: events.length,
+        eventTypes: byEventType,
+        testRuns: { total: testRuns.length, passed: testRunPassed, failed: testRunFailed },
+        byFramework,
+        executions: { total: executions.length, byFramework: execByFramework },
+        learnings: { total: learnings.length, byType: byLearningType },
+        lastUpdated: metrics.lastUpdated || memory.updatedAt
+      },
+      recentEvents: events.slice(-20).map((e) => ({
+        type: e.type,
+        timestamp: e.timestamp,
+        framework: e.framework,
+        spec: e.spec,
+        passed: e.passed,
+        failed: e.failed,
+        exitCode: e.exitCode,
+        durationSeconds: e.durationSeconds
+      }))
+    });
+  }
+  if (jsonOnly) {
+    const out = JSON.stringify({ projects: reports, generatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2);
+    if (outputFile) fs5.writeFileSync(outputFile, out, "utf8");
+    else console.log(out);
+    return;
+  }
+  let report = `# Relat\xF3rio de M\xE9tricas \u2014 mcp-lab-agent
+
+`;
+  report += `Gerado em: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  report += `Projetos: ${reports.length}
+
+`;
+  report += `---
+
+`;
+  for (const r of reports) {
+    report += `## ${r.project}
+
+`;
+    report += `**Caminho:** \`${r.path}\`
+
+`;
+    const s = r.summary;
+    report += `### Eventos (.qa-lab-metrics.json)
+
+`;
+    report += `| M\xE9todo/Tipo | Total | Descri\xE7\xE3o |
+`;
+    report += `|-------------|-------|
+`;
+    for (const [t, count] of Object.entries(s.eventTypes || {})) {
+      let desc = "";
+      if (t === "test_run") desc = `Execu\xE7\xE3o de testes (passed/failed por framework abaixo)`;
+      else if (t === "bug_reported") desc = "Bug report gerado";
+      else desc = t;
+      report += `| ${t} | ${count} | ${desc} |
+`;
+    }
+    if (Object.keys(s.eventTypes || {}).length === 0) {
+      report += `| \u2014 | 0 | Nenhum evento registrado |
+`;
+    }
+    report += `
+`;
+    if (s.testRuns?.total > 0) {
+      report += `### Resultado de Execu\xE7\xF5es (run_tests)
+
+`;
+      report += `| Framework | Total | Passed | Failed | Taxa sucesso |
+`;
+      report += `|-----------|-------|--------|--------|---------------|
+`;
+      for (const [fw, data] of Object.entries(s.byFramework || {})) {
+        const rate = data.total > 0 ? Math.round(data.passed / data.total * 100) : 0;
+        report += `| ${fw} | ${data.total} | ${data.passed} | ${data.failed} | ${rate}% |
+`;
+      }
+      report += `
+`;
+      report += `**Resumo:** ${s.testRuns.passed} passed, ${s.testRuns.failed} failed (total: ${s.testRuns.total})
+
+`;
+    }
+    if (s.executions?.total > 0) {
+      report += `### Hist\xF3rico de Execu\xE7\xF5es (memory)
+
+`;
+      report += `| Framework | Total | Passed | Taxa |
+`;
+      report += `|-----------|-------|--------|------|
+`;
+      for (const [fw, data] of Object.entries(s.executions.byFramework || {})) {
+        const rate = data.total > 0 ? Math.round(data.passed / data.total * 100) : 0;
+        report += `| ${fw} | ${data.total} | ${data.passed} | ${rate}% |
+`;
+      }
+      report += `
+`;
+    }
+    if (s.learnings?.total > 0) {
+      report += `### Aprendizados (.qa-lab-memory.json)
+
+`;
+      report += `| Tipo | Total | Sucesso | Taxa |
+`;
+      report += `|------|-------|---------|------|
+`;
+      for (const [t, data] of Object.entries(s.learnings.byType || {})) {
+        const rate = data.total > 0 ? Math.round(data.success / data.total * 100) : 0;
+        report += `| ${t} | ${data.total} | ${data.success} | ${rate}% |
+`;
+      }
+      report += `
+`;
+    }
+    if (r.recentEvents?.length > 0) {
+      report += `### \xDAltimos 20 eventos
+
+`;
+      report += `| Data | Tipo | Framework | Spec | Passed | Failed | Exit | Dura\xE7\xE3o(s) |
+`;
+      report += `|------|------|-----------|------|--------|--------|------|------------|
+`;
+      for (const e of r.recentEvents.slice(-10)) {
+        const ts = e.timestamp ? new Date(e.timestamp).toLocaleString() : "\u2014";
+        report += `| ${ts} | ${e.type || "\u2014"} | ${e.framework || "\u2014"} | ${(e.spec || "\u2014").slice(0, 20)} | ${e.passed ?? "\u2014"} | ${e.failed ?? "\u2014"} | ${e.exitCode ?? "\u2014"} | ${e.durationSeconds ?? "\u2014"} |
+`;
+      }
+      report += `
+`;
+    }
+    if (s.lastUpdated) {
+      report += `*\xDAltima atualiza\xE7\xE3o: ${s.lastUpdated}*
+
+`;
+    }
+    report += `---
+
+`;
+  }
+  if (outputFile) {
+    fs5.writeFileSync(outputFile, report, "utf8");
+    console.log(`
+\u{1F4C4} Relat\xF3rio salvo em: ${outputFile}
+`);
+  } else {
+    console.log(report);
+  }
+}
+async function handleFlakyReportCommand() {
+  const argv = process.argv.slice(2);
+  const runsIdx = argv.indexOf("--runs");
+  const runs = runsIdx !== -1 && argv[runsIdx + 1] ? parseInt(argv[runsIdx + 1], 10) : 3;
+  const specIdx = argv.indexOf("--spec");
+  const spec = specIdx !== -1 && argv[specIdx + 1] ? argv[specIdx + 1] : null;
+  const outputIdx = argv.indexOf("--output");
+  const outputFile = outputIdx !== -1 && argv[outputIdx + 1] ? argv[outputIdx + 1] : null;
+  const structure = detectProjectStructure();
+  if (!structure.hasTests) {
+    console.error("\u274C Nenhum framework de teste detectado.");
+    process.exit(1);
+  }
+  const fw = structure.testFrameworks[0];
+  const { cmd, args, cwd } = getRunCommand(structure, fw, spec);
+  console.log(`
+\u{1F52C} Relat\xF3rio de testes flaky
+`);
+  console.log(`Framework: ${fw}`);
+  console.log(`Execu\xE7\xF5es: ${runs}`);
+  if (spec) console.log(`Spec: ${spec}`);
+  console.log(`
+Rodando testes ${runs}x...
+`);
+  const results = [];
+  for (let i = 0; i < runs; i++) {
+    process.stdout.write(`  [${i + 1}/${runs}] `);
+    const result = await runTestsOnce(cmd, args, cwd);
+    results.push(result);
+    process.stdout.write(result.passed ? "\u2705 passou\n" : "\u274C falhou\n");
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  const isFlaky = passed > 0 && failed > 0;
+  const failureOutput = results.find((r) => !r.passed)?.output || "";
+  const flakyAnalysis = failureOutput ? detectFlakyPatterns(failureOutput) : null;
+  const probableCause = flakyAnalysis?.isLikelyFlaky ? flakyAnalysis.patterns.map((p) => `${p.pattern}: ${p.suggestion}`).join("; ") : "N\xE3o foi poss\xEDvel inferir (rode com explainOnFailure para an\xE1lise detalhada)";
+  let report = `# Relat\xF3rio de testes flaky \u2014 mcp-lab-agent
+
+`;
+  report += `Gerado em: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  report += `Framework: ${fw}
+`;
+  report += `Execu\xE7\xF5es: ${runs}
+`;
+  if (spec) report += `Spec: ${spec}
+`;
+  report += `
+---
+
+`;
+  report += `## Resultado
+
+`;
+  report += `| M\xE9trica | Valor |
+`;
+  report += `|---------|-------|
+`;
+  report += `| Passou | ${passed}/${runs} |
+`;
+  report += `| Falhou | ${failed}/${runs} |
+`;
+  report += `| Taxa de falha | ${Math.round(failed / runs * 100)}% |
+`;
+  report += `| **Flaky?** | ${isFlaky ? "\u26A0\uFE0F SIM" : failed === runs ? "\u274C Falha consistente" : "\u2705 Est\xE1vel"} |
+
+`;
+  if (isFlaky) {
+    report += `## Causa prov\xE1vel
+
+`;
+    report += `${probableCause}
+
+`;
+    if (flakyAnalysis?.patterns?.length) {
+      report += `### Sugest\xF5es
+
+`;
+      flakyAnalysis.patterns.forEach((p) => {
+        report += `- **${p.pattern}:** ${p.suggestion}
+`;
+      });
+      report += `
+`;
+    }
+  }
+  if (failed > 0 && failureOutput) {
+    report += `## \xDAltima sa\xEDda de falha (trecho)
+
+`;
+    report += "```\n";
+    report += failureOutput.slice(0, 1500).trim();
+    if (failureOutput.length > 1500) report += "\n...";
+    report += "\n```\n\n";
+  }
+  report += `---
+
+`;
+  report += `*Use \`mcp-lab-agent por_que_falhou\` (via MCP) ou \`run_tests\` com \`explainOnFailure: true\` para an\xE1lise detalhada.*
+`;
+  if (outputFile) {
+    fs5.writeFileSync(outputFile, report, "utf8");
+    console.log(`
+\u{1F4C4} Relat\xF3rio salvo em: ${outputFile}
+`);
+  } else {
+    console.log("\n" + report);
+  }
+  process.exit(isFlaky ? 1 : 0);
+}
+function getRunCommand(structure, fw, spec) {
+  const cwdMap = {
+    cypress: structure.testDirs.includes("cypress") ? path5.join(PROJECT_ROOT5, "cypress") : structure.testDirs[0] ? path5.join(PROJECT_ROOT5, structure.testDirs[0]) : PROJECT_ROOT5,
+    playwright: structure.testDirs.includes("playwright") ? path5.join(PROJECT_ROOT5, "playwright") : structure.testDirs[0] ? path5.join(PROJECT_ROOT5, structure.testDirs[0]) : PROJECT_ROOT5
+  };
+  const cwd = cwdMap[fw] || getFrameworkCwd(structure, ["specs", "tests", "e2e"]) || PROJECT_ROOT5;
+  if (fw === "cypress") {
+    return { cmd: "npx", args: spec ? ["cypress", "run", "--spec", spec] : ["cypress", "run"], cwd };
+  }
+  if (fw === "playwright") {
+    return { cmd: "npx", args: spec ? ["playwright", "test", spec] : ["playwright", "test"], cwd };
+  }
+  if (fw === "webdriverio" || fw === "appium") {
+    return { cmd: "npx", args: spec ? ["wdio", "run", spec] : ["wdio", "run"], cwd: PROJECT_ROOT5 };
+  }
+  if (fw === "jest") {
+    return { cmd: "npx", args: spec ? ["jest", spec] : ["jest"], cwd: PROJECT_ROOT5 };
+  }
+  if (fw === "vitest") {
+    return { cmd: "npx", args: ["vitest", "run", ...spec ? [spec] : []], cwd: PROJECT_ROOT5 };
+  }
+  if (fw === "mocha") {
+    return { cmd: "npx", args: spec ? ["mocha", spec] : ["mocha"], cwd: PROJECT_ROOT5 };
+  }
+  if (fw === "pytest") {
+    return { cmd: "pytest", args: spec ? [spec] : [], cwd: PROJECT_ROOT5 };
+  }
+  if (fw === "robot") {
+    return { cmd: "robot", args: spec ? [spec] : [structure.testDirs[0] || "tests"], cwd: PROJECT_ROOT5 };
+  }
+  return { cmd: "npm", args: ["test"], cwd: PROJECT_ROOT5 };
+}
+async function handleRunCommand() {
+  const argv = process.argv.slice(2);
+  const deviceIdx = argv.indexOf("--device");
+  const device = deviceIdx !== -1 && argv[deviceIdx + 1] ? argv[deviceIdx + 1] : null;
+  const noAutoFix = argv.includes("--no-auto-fix");
+  const spec = argv.filter((a) => !a.startsWith("--") && a !== "run")[0] || null;
+  const structure = detectProjectStructure();
+  if (!structure.hasTests) {
+    console.error("\u274C Nenhum framework de teste detectado.");
+    process.exit(1);
+  }
+  const fw = structure.testFrameworks[0];
+  const deviceConfig = structure.hasMobile ? detectDeviceConfig(structure) : {};
+  const useDevice = device || deviceConfig.configuration || deviceConfig.device;
+  const doAutoFix = !noAutoFix && structure.hasMobile && !!spec;
+  let runEnv = { ...process.env };
+  if (Object.keys(deviceConfig.envOverrides || {}).length) {
+    runEnv = { ...runEnv, ...deviceConfig.envOverrides };
   }
-  if (cmd === "stats") {
-    const stats = getMemoryStats();
-    console.log(`
-\u{1F4CA} Estat\xEDsticas de Aprendizado
-
-Total de aprendizados: ${stats.totalLearnings}
-Corre\xE7\xF5es bem-sucedidas: ${stats.successfulFixes}
-Corre\xE7\xF5es de seletores: ${stats.selectorFixes}
-Corre\xE7\xF5es de timing: ${stats.timingFixes}
-Testes gerados: ${stats.testsGenerated}
-Taxa de sucesso na 1\xAA tentativa: ${stats.firstAttemptSuccessRate}%
-
-${stats.totalLearnings === 0 ? "\u26A0\uFE0F Ainda n\xE3o h\xE1 aprendizados. Use 'mcp-lab-agent auto <descri\xE7\xE3o>' para gerar testes e aprender com erros." : ""}
+  if (device) {
+    if (fw === "detox") runEnv.DETOX_CONFIGURATION = device;
+    else if (fw === "appium") runEnv.APPIUM_DEVICE_NAME = device;
+  } else if (deviceConfig.configuration && fw === "detox") {
+    runEnv.DETOX_CONFIGURATION = deviceConfig.configuration;
+  }
+  let { cmd, args, cwd } = getRunCommand(structure, fw, spec);
+  if (fw === "detox" && useDevice) {
+    args = [...args.slice(0, 2), "--configuration", useDevice, ...args.slice(2)];
+  }
+  const isSelectorFailure = (out) => /element not found|selector|timeout|locator|cy\.get|page\.locator|Unable to find/i.test(out || "");
+  console.log(`
+\u25B6\uFE0F Rodando testes${spec ? `: ${spec}` : ""}
 `);
-    return true;
+  if (useDevice) console.log(`   Device: ${useDevice}
+`);
+  let result = await runTestsOnce(cmd, args, cwd, runEnv);
+  let autoFixed = false;
+  if (!result.passed && doAutoFix && isSelectorFailure(result.runOutput) && resolveLLMProvider("complex").apiKey) {
+    console.log("\n\u26A0\uFE0F Falha por seletor. Aplicando corre\xE7\xE3o autom\xE1tica...\n");
+    const fixResult = await applySelectorFixAndRetry(spec, result.runOutput, fw);
+    if (fixResult.applied) {
+      autoFixed = true;
+      result = await runTestsOnce(cmd, args, cwd, runEnv);
+    }
   }
-  if (cmd === "analyze") {
-    await handleAnalyzeCommand();
-    return true;
+  if (result.passed) {
+    console.log(`
+\u2705 Testes passaram${autoFixed ? " (ap\xF3s corre\xE7\xE3o de seletor)" : ""}.
+`);
+  } else {
+    console.log(`
+\u274C Testes falharam.
+`);
+    if (result.runOutput) console.log(result.runOutput.slice(0, 800) + (result.runOutput.length > 800 ? "\n..." : ""));
   }
-  return false;
+  process.exit(result.passed ? 0 : 1);
+}
+function runTestsOnce(cmd, args, cwd, env = process.env) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: process.platform === "win32",
+      env: { ...process.env, ...env }
+    });
+    let stdout = "";
+    let stderr = "";
+    if (child.stdout) child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    if (child.stderr) child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      const output = [stdout, stderr].filter(Boolean).join("\n");
+      resolve({ passed: code === 0, code: code ?? 1, output });
+    });
+  });
 }
 async function handleAutoCommand() {
   const request = process.argv.slice(3).join(" ");
@@ -781,16 +1586,16 @@ Framework: ${fw}`;
         const fileName = cleanRequest.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").slice(0, 30);
         const { ext, baseDir } = getExtensionAndBaseDir(fw, structure);
         const safeName = fileName + ext;
-        testFilePath = path4.join(baseDir, safeName);
-        if (!fs4.existsSync(baseDir)) fs4.mkdirSync(baseDir, { recursive: true });
+        testFilePath = path5.join(baseDir, safeName);
+        if (!fs5.existsSync(baseDir)) fs5.mkdirSync(baseDir, { recursive: true });
       }
-      fs4.writeFileSync(testFilePath, testContent, "utf8");
+      fs5.writeFileSync(testFilePath, testContent, "utf8");
       console.log(`\u2705 Teste gravado: ${testFilePath}`);
       console.log(`
 [Tentativa ${attempt}/${maxRetries}] Executando teste...`);
       const runResult = await new Promise((resolve) => {
         const child = spawn("npx", [fw === "cypress" ? "cypress" : fw === "playwright" ? "playwright" : fw, fw === "cypress" ? "run" : fw === "playwright" ? "test" : "run", testFilePath], {
-          cwd: PROJECT_ROOT4,
+          cwd: PROJECT_ROOT5,
           stdio: ["inherit", "pipe", "pipe"],
           shell: process.platform === "win32"
         });
@@ -857,9 +1662,9 @@ async function handleAnalyzeCommand() {
   console.log(`\u2705 ${structure.testFrameworks.join(", ")} detectado(s)
 `);
   const testFiles = structure.testDirs.flatMap((dir) => {
-    const fullPath = path4.join(PROJECT_ROOT4, dir);
-    if (!fs4.existsSync(fullPath)) return [];
-    return fs4.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
+    const fullPath = path5.join(PROJECT_ROOT5, dir);
+    if (!fs5.existsSync(fullPath)) return [];
+    return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
   });
   console.log(`\u2705 ${testFiles.length} teste(s) encontrado(s)
 `);
@@ -918,13 +1723,13 @@ async function handleAnalyzeCommand() {
 }
 
 // src/index.js
-var PROJECT_ROOT5 = process.cwd();
-config({ path: path5.join(PROJECT_ROOT5, ".env") });
+var PROJECT_ROOT6 = process.cwd();
+config({ path: path6.join(PROJECT_ROOT6, ".env") });
 var server = new McpServer({
   name: "mcp-lab-agent",
-  version: "2.1.0"
+  version: "2.1.9"
 });
-var METRICS_FILE2 = path5.join(PROJECT_ROOT5, ".qa-lab-metrics.json");
+var METRICS_FILE2 = path6.join(PROJECT_ROOT6, ".qa-lab-metrics.json");
 function appendMetricsEvent(event) {
   recordMetricEvent(event);
 }
@@ -945,20 +1750,20 @@ server.registerTool(
   },
   async ({ path: filePath, encoding = "utf8" }) => {
     const normalized = filePath.replace(/^\//, "").replace(/\\/g, "/");
-    const fullPath = path5.join(PROJECT_ROOT5, normalized);
-    if (!fullPath.startsWith(PROJECT_ROOT5)) {
+    const fullPath = path6.join(PROJECT_ROOT6, normalized);
+    if (!fullPath.startsWith(PROJECT_ROOT6)) {
       return {
         content: [{ type: "text", text: "Caminho fora do projeto." }],
         structuredContent: { ok: false, error: "Path outside project" }
       };
     }
-    if (!fs5.existsSync(fullPath)) {
+    if (!fs6.existsSync(fullPath)) {
       return {
         content: [{ type: "text", text: `Arquivo n\xE3o encontrado: ${normalized}` }],
         structuredContent: { ok: false, error: "File not found" }
       };
     }
-    const stat = fs5.statSync(fullPath);
+    const stat = fs6.statSync(fullPath);
     if (stat.isDirectory()) {
       return {
         content: [{ type: "text", text: "\xC9 um diret\xF3rio. Use um caminho de arquivo." }],
@@ -966,7 +1771,7 @@ server.registerTool(
       };
     }
     try {
-      const content = fs5.readFileSync(fullPath, encoding);
+      const content = fs6.readFileSync(fullPath, encoding);
       return {
         content: [{ type: "text", text: content }],
         structuredContent: { ok: true, content }
@@ -983,7 +1788,7 @@ server.registerTool(
   "detect_project",
   {
     title: "Detectar estrutura do projeto",
-    description: "Analisa o projeto e identifica frameworks de teste, pastas, backend, frontend.",
+    description: "Analisa o projeto e identifica frameworks de teste, pastas, backend, frontend, ambiente (web/mobile) e hints para gera\xE7\xE3o de testes.",
     inputSchema: z.object({}),
     outputSchema: z.object({
       ok: z.boolean(),
@@ -994,17 +1799,22 @@ server.registerTool(
         hasBackend: z.boolean(),
         backendDir: z.string().nullable(),
         hasFrontend: z.boolean(),
-        frontendDir: z.string().nullable()
+        frontendDir: z.string().nullable(),
+        hasMobile: z.boolean().optional(),
+        environment: z.string().optional(),
+        environmentHints: z.array(z.string()).optional()
       })
     })
   },
   async () => {
     const structure = detectProjectStructure();
+    const envLine = structure.environment ? `Ambiente: ${structure.environment}${structure.environmentHints?.length ? ` (${structure.environmentHints.join(", ")})` : ""}` : "";
     const summary = [
       `Frameworks de teste: ${structure.testFrameworks.join(", ") || "nenhum"}`,
       `Pastas de teste: ${structure.testDirs.join(", ") || "nenhuma"}`,
       `Backend: ${structure.backendDir || "n\xE3o detectado"}`,
-      `Frontend: ${structure.frontendDir || "n\xE3o detectado"}`
+      `Frontend: ${structure.frontendDir || "n\xE3o detectado"}`,
+      ...envLine ? [envLine] : []
     ].join("\n");
     return {
       content: [{ type: "text", text: summary }],
@@ -1045,7 +1855,7 @@ server.registerTool(
         structuredContent: { ok: false, error: "Playwright not installed. Run: npm install playwright" }
       };
     }
-    const outPath = screenshotPath ? path5.join(PROJECT_ROOT5, screenshotPath.replace(/^\//, "")) : path5.join(PROJECT_ROOT5, ".qa-lab-screenshot.png");
+    const outPath = screenshotPath ? path6.join(PROJECT_ROOT6, screenshotPath.replace(/^\//, "")) : path6.join(PROJECT_ROOT6, ".qa-lab-screenshot.png");
     const consoleLogs = [];
     const consoleErrors = [];
     const networkRequests = [];
@@ -1072,7 +1882,7 @@ server.registerTool(
       await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
       await page.screenshot({ path: outPath, fullPage: false });
       await browser.close();
-      const relPath = path5.relative(PROJECT_ROOT5, outPath);
+      const relPath = path6.relative(PROJECT_ROOT6, outPath);
       let summary = `Screenshot salvo: ${relPath}`;
       if (consoleErrors.length) summary += `
 
@@ -1104,11 +1914,11 @@ var QA_AGENTS2 = {
   intelligence: { tools: ["qa_full_analysis", "qa_health_check", "qa_suggest_next_test", "qa_predict_flaky", "qa_compare_with_industry"], desc: "Executor + Consultor: an\xE1lise completa, diagn\xF3stico, sugest\xF5es e predi\xE7\xF5es" },
   detection: { tools: ["detect_project", "read_project", "list_test_files"], desc: "Detec\xE7\xE3o de estrutura, frameworks e arquivos" },
   execution: { tools: ["run_tests", "watch_tests", "get_test_coverage"], desc: "Execu\xE7\xE3o de testes e cobertura" },
-  generation: { tools: ["generate_tests", "write_test", "create_test_template"], desc: "Gera\xE7\xE3o de testes com LLM" },
+  generation: { tools: ["generate_tests", "write_test", "create_test_template", "map_mobile_elements"], desc: "Gera\xE7\xE3o de testes com LLM" },
   analysis: { tools: ["analyze_failures", "por_que_falhou", "suggest_fix", "suggest_selector_fix"], desc: "An\xE1lise de falhas e sugest\xF5es" },
   browser: { tools: ["web_eval_browser"], desc: "Avalia\xE7\xE3o em browser real (screenshots, network, console)" },
   reporting: { tools: ["create_bug_report", "get_business_metrics"], desc: "Relat\xF3rios e m\xE9tricas" },
-  learning: { tools: ["qa_learning_stats", "qa_time_travel"], desc: "Estat\xEDsticas de aprendizado e evolu\xE7\xE3o" },
+  learning: { tools: ["qa_learning_stats", "get_learning_report", "qa_time_travel"], desc: "Estat\xEDsticas de aprendizado e evolu\xE7\xE3o" },
   maintenance: { tools: ["run_linter", "install_dependencies", "analyze_file_methods"], desc: "Manuten\xE7\xE3o e an\xE1lise de c\xF3digo" }
 };
 server.registerTool(
@@ -1140,8 +1950,17 @@ server.registerTool(
     if (/rodar|executar|run|test|coverage|watch/i.test(t)) {
       return { content: [{ type: "text", text: "Agente: execution \u2192 run_tests, get_test_coverage" }], structuredContent: { ok: true, suggestedAgent: "execution", suggestedTools: QA_AGENTS2.execution.tools, description: QA_AGENTS2.execution.desc } };
     }
+    if (/mapear|elementos mobile|deep link|deeplink|app package|bundle.?id|appium inspector/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements (mapear elementos), depois generate_tests + write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: ["map_mobile_elements", "generate_tests", "write_test"], description: QA_AGENTS2.generation.desc } };
+    }
+    if (/mapear|elementos mobile|deep link|deeplink|app package|bundle.?id/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements (mapear elementos), depois generate_tests + write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: ["map_mobile_elements", "generate_tests", "write_test"], description: "Mapeamento de elementos mobile + gera\xE7\xE3o de testes" } };
+    }
+    if (/mobile|deeplink|deep link|elementos|mapear.*app|appium|detox/i.test(t) && !/rodar|run|executar/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements, generate_tests, write_test (mobile)" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
+    }
     if (/gerar|criar|escrever|generate|write|template/i.test(t)) {
-      return { content: [{ type: "text", text: "Agente: generation \u2192 generate_tests, write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
+      return { content: [{ type: "text", text: "Agente: generation \u2192 generate_tests, write_test, map_mobile_elements" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
     }
     if (/analisar|por que|falhou|suggest|correção|selector|fix/i.test(t)) {
       return { content: [{ type: "text", text: "Agente: analysis \u2192 analyze_failures, por_que_falhou, suggest_fix" }], structuredContent: { ok: true, suggestedAgent: "analysis", suggestedTools: QA_AGENTS2.analysis.tools, description: QA_AGENTS2.analysis.desc } };
@@ -1185,7 +2004,9 @@ server.registerTool(
       ]).optional().describe("Framework espec\xEDfico ou 'npm' para npm test."),
       spec: z.string().optional().describe("Caminho do spec (ex: cypress/e2e/test.cy.js)."),
       suite: z.string().optional().describe("Suite ou pattern (ex: e2e, api)."),
-      explainOnFailure: z.boolean().optional().describe("Se true, quando falhar gera automaticamente: O que aconteceu, Por que falhou, O que fazer, Sugest\xE3o de corre\xE7\xE3o. Requer API key.")
+      device: z.string().optional().describe("Device/configuration para mobile. Se vazio, detecta de qa-lab-agent.config.json, wdio.conf ou .detoxrc."),
+      explainOnFailure: z.boolean().optional().describe("Se true, quando falhar gera automaticamente: O que aconteceu, Por que falhou, O que fazer, Sugest\xE3o de corre\xE7\xE3o. Requer API key."),
+      autoFixSelector: z.boolean().optional().describe("Se true e falhar por seletor, aplica corre\xE7\xE3o automaticamente e tenta novamente. Requer spec e API key. Default: true para mobile.")
     }),
     outputSchema: z.object({
       status: z.enum(["passed", "failed", "not_found"]),
@@ -1194,7 +2015,7 @@ server.registerTool(
       runOutput: z.string().optional()
     })
   },
-  async ({ framework, spec, suite, explainOnFailure }) => {
+  async ({ framework, spec, suite, explainOnFailure, device, autoFixSelector }) => {
     const structure = detectProjectStructure();
     if (!structure.hasTests) {
       return {
@@ -1210,15 +2031,28 @@ server.registerTool(
     if (!selectedFramework && structure.testFrameworks.length > 0) {
       selectedFramework = structure.testFrameworks[0];
     }
+    const deviceConfig = structure.hasMobile ? detectDeviceConfig(structure) : {};
+    const useDevice = device || deviceConfig.configuration || deviceConfig.device;
+    const doAutoFixSelector = autoFixSelector ?? (structure.hasMobile && !!spec);
+    let runEnv = { ...process.env };
+    if (useDevice && Object.keys(deviceConfig.envOverrides || {}).length) {
+      runEnv = { ...runEnv, ...deviceConfig.envOverrides };
+    }
+    if (device) {
+      if (selectedFramework === "detox") runEnv.DETOX_CONFIGURATION = device;
+      else if (selectedFramework === "appium") runEnv.APPIUM_DEVICE_NAME = device;
+    } else if (deviceConfig.configuration && selectedFramework === "detox") {
+      runEnv.DETOX_CONFIGURATION = deviceConfig.configuration;
+    }
     let cmd, args, cwd;
     if (selectedFramework === "cypress") {
       cmd = "npx";
       args = spec ? ["cypress", "run", "--spec", spec] : ["cypress", "run"];
-      cwd = structure.testDirs.includes("cypress") ? path5.join(PROJECT_ROOT5, "cypress") : structure.testDirs[0] ? path5.join(PROJECT_ROOT5, structure.testDirs[0]) : PROJECT_ROOT5;
+      cwd = structure.testDirs.includes("cypress") ? path6.join(PROJECT_ROOT6, "cypress") : structure.testDirs[0] ? path6.join(PROJECT_ROOT6, structure.testDirs[0]) : PROJECT_ROOT6;
     } else if (selectedFramework === "playwright") {
       cmd = "npx";
       args = spec ? ["playwright", "test", spec] : ["playwright", "test"];
-      cwd = structure.testDirs.includes("playwright") ? path5.join(PROJECT_ROOT5, "playwright") : structure.testDirs[0] ? path5.join(PROJECT_ROOT5, structure.testDirs[0]) : PROJECT_ROOT5;
+      cwd = structure.testDirs.includes("playwright") ? path6.join(PROJECT_ROOT6, "playwright") : structure.testDirs[0] ? path6.join(PROJECT_ROOT6, structure.testDirs[0]) : PROJECT_ROOT6;
     } else if (selectedFramework === "webdriverio") {
       cmd = "npx";
       args = spec ? ["wdio", "run", spec] : ["wdio", "run"];
@@ -1243,108 +2077,138 @@ server.registerTool(
       cmd = "npx";
       args = ["jest"];
       if (spec) args.push(spec);
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "vitest") {
       cmd = "npx";
       args = ["vitest", "run"];
       if (spec) args.push(spec);
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "mocha") {
       cmd = "npx";
       args = spec ? ["mocha", spec] : ["mocha"];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "appium") {
       cmd = "npx";
       args = spec ? ["wdio", "run", spec] : ["wdio", "run"];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "detox") {
       cmd = "npx";
       args = ["detox", "test"];
+      if (useDevice) args.push("--configuration", useDevice);
       if (spec) args.push(spec);
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "robot") {
       cmd = "robot";
       args = spec ? [spec] : [structure.testDirs[0] || "tests"];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "pytest") {
       cmd = "pytest";
       args = spec ? [spec] : [];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else if (selectedFramework === "supertest" || selectedFramework === "pactum") {
       cmd = "npm";
       args = ["test"];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     } else {
       cmd = "npm";
       args = ["test"];
-      cwd = PROJECT_ROOT5;
+      cwd = PROJECT_ROOT6;
     }
-    const startTime = Date.now();
-    return new Promise((resolve) => {
+    const runTestsOnce2 = () => new Promise((resolve) => {
+      const startTime = Date.now();
       const child = spawn2(cmd, args, {
         cwd,
         stdio: ["inherit", "pipe", "pipe"],
         shell: process.platform === "win32",
-        env: { ...process.env }
+        env: runEnv
       });
       let stdout = "";
       let stderr = "";
-      if (child.stdout) {
-        child.stdout.on("data", (d) => {
-          const s = d.toString();
-          stdout += s;
-          process.stdout.write(s);
-        });
-      }
-      if (child.stderr) {
-        child.stderr.on("data", (d) => {
-          const s = d.toString();
-          stderr += s;
-          process.stderr.write(s);
-        });
-      }
+      if (child.stdout) child.stdout.on("data", (d) => {
+        stdout += d.toString();
+        process.stdout.write(d);
+      });
+      if (child.stderr) child.stderr.on("data", (d) => {
+        stderr += d.toString();
+        process.stderr.write(d);
+      });
       child.on("close", (code) => {
         const runOutput = [stdout, stderr].filter(Boolean).join("\n").trim();
-        const passed = code === 0;
-        const durationSeconds = Math.round((Date.now() - startTime) / 1e3);
-        if (!passed && runOutput) {
-          try {
-            fs5.writeFileSync(path5.join(PROJECT_ROOT5, ".qa-lab-last-failure.log"), runOutput, "utf8");
-          } catch {
-          }
-        }
-        const { passed: p, failed: f } = parseTestRunResult(runOutput, code);
-        appendMetricsEvent({
-          type: "test_run",
-          framework: selectedFramework,
-          spec: spec || void 0,
-          passed: p,
-          failed: f,
-          durationSeconds,
-          exitCode: code ?? 1,
-          failures: !passed ? extractFailuresFromOutput(runOutput) : void 0
-        });
-        if (passed) saveProjectMemory({ lastRun: { spec: spec || null, framework: selectedFramework, passed: p } });
-        saveProjectMemory({
-          execution: {
-            testFile: spec || "all",
-            passed,
-            duration: durationSeconds,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            framework: selectedFramework
-          }
-        });
         resolve({
-          content: [{ type: "text", text: passed ? "Testes executados com sucesso." : "Falha na execu\xE7\xE3o dos testes." }],
-          structuredContent: {
-            status: passed ? "passed" : "failed",
-            message: passed ? "Tests passed" : "Tests failed",
-            exitCode: code ?? 1,
-            runOutput: !passed ? runOutput : void 0
-          }
+          passed: code === 0,
+          exitCode: code ?? 1,
+          runOutput,
+          durationSeconds: Math.round((Date.now() - startTime) / 1e3)
         });
       });
     });
+    const isSelectorFailure = (out) => /element not found|selector|timeout|locator|cy\.get|page\.locator|Unable to find/i.test(out || "");
+    let result = await runTestsOnce2();
+    let autoFixed = false;
+    if (!result.passed && doAutoFixSelector && spec && isSelectorFailure(result.runOutput) && resolveLLMProvider("complex").apiKey) {
+      const fixResult = await applySelectorFixAndRetry(spec, result.runOutput, selectedFramework);
+      if (fixResult.applied) {
+        autoFixed = true;
+        result = await runTestsOnce2();
+      }
+    }
+    if (!result.passed && result.runOutput) {
+      try {
+        fs6.writeFileSync(path6.join(PROJECT_ROOT6, ".qa-lab-last-failure.log"), result.runOutput, "utf8");
+      } catch {
+      }
+    }
+    const { passed: p, failed: f } = parseTestRunResult(result.runOutput, result.exitCode);
+    appendMetricsEvent({
+      type: "test_run",
+      framework: selectedFramework,
+      spec: spec || void 0,
+      passed: p,
+      failed: f,
+      durationSeconds: result.durationSeconds,
+      exitCode: result.exitCode,
+      failures: !result.passed ? extractFailuresFromOutput(result.runOutput) : void 0
+    });
+    if (result.passed) saveProjectMemory({ lastRun: { spec: spec || null, framework: selectedFramework, passed: p } });
+    saveProjectMemory({
+      execution: {
+        testFile: spec || "all",
+        passed: result.passed,
+        duration: result.durationSeconds,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        framework: selectedFramework
+      }
+    });
+    const baseMsg = result.passed ? autoFixed ? "Testes executados com sucesso (ap\xF3s corre\xE7\xE3o autom\xE1tica de seletor)." : "Testes executados com sucesso." : "Falha na execu\xE7\xE3o dos testes.";
+    const structured = {
+      status: result.passed ? "passed" : "failed",
+      message: result.passed ? "Tests passed" : "Tests failed",
+      exitCode: result.exitCode,
+      runOutput: !result.passed ? result.runOutput : void 0,
+      autoFixed: autoFixed || void 0
+    };
+    if (!result.passed && explainOnFailure && result.runOutput) {
+      const explainResult = await generateFailureExplanation(result.runOutput, spec || void 0);
+      if (explainResult.ok && explainResult.structuredContent) {
+        const oneLine = explainResult.structuredContent.resumoEmUmaFrase || oneLineFailureSummary(result.runOutput, selectedFramework, explainResult.structuredContent.oQueAconteceu, explainResult.structuredContent.sugestaoCorrecao);
+        structured.explanation = explainResult.structuredContent.formattedText;
+        structured.resumoEmUmaFrase = oneLine;
+        return {
+          content: [{ type: "text", text: `${baseMsg}
+
+**${oneLine}**
+
+---
+
+${explainResult.structuredContent.formattedText}` }],
+          structuredContent: structured
+        };
+      }
+    }
+    return {
+      content: [{ type: "text", text: baseMsg }],
+      structuredContent: structured
+    };
   }
 );
 server.registerTool(
@@ -1433,10 +2297,10 @@ server.registerTool(
 ${referenceCode.slice(0, 8e3)}`;
     if (referencePaths?.length) {
       for (const p of referencePaths.slice(0, 5)) {
-        const full = path5.join(PROJECT_ROOT5, p.replace(/^\//, "").replace(/\\/g, "/"));
-        if (fs5.existsSync(full)) {
+        const full = path6.join(PROJECT_ROOT6, p.replace(/^\//, "").replace(/\\/g, "/"));
+        if (fs6.existsSync(full)) {
           try {
-            const content = fs5.readFileSync(full, "utf8");
+            const content = fs6.readFileSync(full, "utf8");
             referenceBlock += `
 
 --- Arquivo: ${p} ---
@@ -1465,8 +2329,17 @@ O c\xF3digo de refer\xEAncia pode estar em QUALQUER framework (Cypress, Robot, P
 - Mantenha a MESMA l\xF3gica e fluxo de teste
 - Traduza seletores, comandos e asser\xE7\xF5es para ${fw}
 - Use Page Objects se o projeto j\xE1 usa
-- Retorne SOMENTE o c\xF3digo, sem markdown` : `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
+- Retorne SOMENTE o c\xF3digo, sem markdown
+
+${UNIVERSAL_TEST_PRACTICES}
+${fw === "appium" || fw === "detox" ? `
+IMPORTANTE: ${MOBILE_MAPPING_LESSON}
+
+HIERARQUIA DE SELETORES: ${MOBILE_SELECTOR_HIERARCHY}` : ""}` : `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
 Framework: ${fw}
+
+${UNIVERSAL_TEST_PRACTICES}
+
 Regras:
 - Cypress: cy.request(), cy.visit(), cy.get()
 - Playwright: test(), test.describe(), page.goto(), page.locator()
@@ -1474,7 +2347,11 @@ Regras:
 - Jest/Vitest: describe(), test(), expect()
 - Robot: Keywords, [Tags], Steps
 - pytest: def test_*, assert, fixtures
-- C\xF3digo limpo. Retorne SOMENTE o c\xF3digo, sem markdown`;
+- C\xF3digo limpo. Retorne SOMENTE o c\xF3digo, sem markdown${fw === "appium" || fw === "detox" ? `
+
+IMPORTANTE (Appium/Detox): ${MOBILE_MAPPING_LESSON}
+
+HIERARQUIA: ${MOBILE_SELECTOR_HIERARCHY}` : ""}`;
     const userPrompt = `Contexto do projeto:
 ${contextWithMemory.slice(0, 5e3)}
 
@@ -1558,7 +2435,7 @@ function getExtensionAndBaseDir2(fw, structure) {
     robot: structure.testDirs.includes("robot") ? "robot" : structure.testDirs[0] || "tests",
     behave: structure.testDirs.includes("features") ? "features" : structure.testDirs[0] || "tests"
   };
-  const baseDir = path5.join(PROJECT_ROOT5, baseMap[fw] || structure.testDirs[0] || "tests");
+  const baseDir = path6.join(PROJECT_ROOT6, baseMap[fw] || structure.testDirs[0] || "tests");
   return { ext, baseDir };
 }
 server.registerTool(
@@ -1603,13 +2480,13 @@ server.registerTool(
     const { ext, baseDir } = getExtensionAndBaseDir2(fw, structure);
     const safeName = name.replace(/[^a-z0-9-_]/gi, "-").replace(/-+/g, "-").replace(/_+/g, "_").replace(/\.(cy|spec|test|robot|feature|py)\.?(js|ts|py)?$/i, "").replace(/^[-_]+|[-_]+$/g, "");
     const fileName = ext.startsWith("_") ? `${safeName}${ext}` : `${safeName}${ext}`;
-    const targetDir = subdir ? path5.join(baseDir, subdir) : baseDir;
-    const filePath = path5.join(targetDir, fileName);
+    const targetDir = subdir ? path6.join(baseDir, subdir) : baseDir;
+    const filePath = path6.join(targetDir, fileName);
     try {
-      if (!fs5.existsSync(targetDir)) {
-        fs5.mkdirSync(targetDir, { recursive: true });
+      if (!fs6.existsSync(targetDir)) {
+        fs6.mkdirSync(targetDir, { recursive: true });
       }
-      fs5.writeFileSync(filePath, content, "utf8");
+      fs6.writeFileSync(filePath, content, "utf8");
       return {
         content: [{ type: "text", text: `Arquivo gravado: ${filePath}` }],
         structuredContent: { ok: true, path: filePath }
@@ -1679,8 +2556,10 @@ server.registerTool(
     };
   }
 );
-function formatFailureExplanation(data) {
-  const lines = [
+function formatFailureExplanation(data, oneLine = null) {
+  const summary = oneLine || data.resumoEmUmaFrase || "";
+  const lines = summary ? [`**${summary}**`, "", "---", ""] : [];
+  lines.push(
     "## O que aconteceu",
     "",
     data.oQueAconteceu || "",
@@ -1692,7 +2571,7 @@ function formatFailureExplanation(data) {
     "## O que fazer agora",
     "",
     ...Array.isArray(data.oQueFazerAgora) ? data.oQueFazerAgora.map((s, i) => `${i + 1}. ${s}`) : [data.oQueFazerAgora || ""]
-  ];
+  );
   if (data.sugestaoCorrecao) {
     lines.push("", "## Sugest\xE3o de corre\xE7\xE3o", "", "```" + (data.framework || "js"), data.sugestaoCorrecao, "```");
   }
@@ -1734,6 +2613,70 @@ async function callLlmForExplanation(provider, apiKey, baseUrl, model, systemPro
   const data = await res.json();
   return data.choices?.[0]?.message?.content || "";
 }
+async function generateFailureExplanation(resolvedOutput, testFilePath = null) {
+  const structure = detectProjectStructure();
+  const fw = structure.testFrameworks[0] || "unknown";
+  let testCode = "";
+  if (testFilePath) {
+    const normalized = testFilePath.replace(/^\//, "").replace(/\\/g, "/");
+    const fullPath = path6.join(PROJECT_ROOT6, normalized);
+    if (fs6.existsSync(fullPath) && !fs6.statSync(fullPath).isDirectory()) {
+      try {
+        testCode = fs6.readFileSync(fullPath, "utf8");
+      } catch {
+      }
+    }
+  }
+  const llm = resolveLLMProvider("complex");
+  if (!llm.apiKey) return { ok: false, structuredContent: null };
+  const { provider, apiKey, baseUrl, model } = llm;
+  const fwHints = {
+    webdriverio: "WebdriverIO (describe/it, $, browser.$)",
+    appium: "Appium/WebdriverIO (mobile, $, browser.$)",
+    playwright: "Playwright (test, page, locator)",
+    cypress: "Cypress (cy.get, cy.click)",
+    jest: "Jest (describe, test, expect)",
+    vitest: "Vitest (describe, test, expect)",
+    robot: "Robot Framework",
+    pytest: "pytest"
+  };
+  const systemPrompt = `Voc\xEA \xE9 um mentor de QA. Analise o output de falha e responda em JSON (apenas o JSON, sem markdown) com as chaves:
+- resumoEmUmaFrase: string (OBRIGAT\xD3RIO - uma frase: "Falhou porque X. Solu\xE7\xE3o: Y.")
+- oQueAconteceu: string (explica\xE7\xE3o em portugu\xEAs do que aconteceu, simples)
+- porQueProvavelmenteFalhou: array de strings (lista de poss\xEDveis causas)
+- oQueFazerAgora: array de strings (passos numerados do que fazer)
+- sugestaoCorrecao: string ou null (c\xF3digo de corre\xE7\xE3o no formato do framework)
+- conceito: string ou null
+- framework: string (framework do projeto)
+
+Framework: ${fw}. ${fwHints[fw] || ""}
+Responda APENAS com o JSON v\xE1lido, sem texto antes ou depois.`;
+  const userPrompt = `Output do terminal/log (teste falhou):
+---
+${resolvedOutput.slice(0, 12e3)}
+---
+${testCode ? `
+C\xF3digo do teste:
+---
+${testCode.slice(0, 6e3)}
+---` : ""}`;
+  try {
+    let raw = await callLlmForExplanation(provider, apiKey, baseUrl, model, systemPrompt, userPrompt);
+    raw = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+    let data = {};
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      data = { oQueAconteceu: raw.slice(0, 500) || "N\xE3o foi poss\xEDvel parsear.", porQueProvavelmenteFalhou: [], oQueFazerAgora: [], sugestaoCorrecao: null, conceito: null, framework: fw };
+    }
+    data.framework = data.framework || fw;
+    const oneLine = oneLineFailureSummary(resolvedOutput, fw, data.oQueAconteceu, data.sugestaoCorrecao);
+    const formattedText = formatFailureExplanation(data, data.resumoEmUmaFrase || oneLine);
+    return { ok: true, formattedText, structuredContent: { ...data, formattedText } };
+  } catch (err) {
+    return { ok: false, error: err.message, structuredContent: null };
+  }
+}
 server.registerTool(
   "por_que_falhou",
   {
@@ -1756,14 +2699,12 @@ server.registerTool(
     })
   },
   async ({ errorOutput, testFilePath }) => {
-    const structure = detectProjectStructure();
-    const fw = structure.testFrameworks[0] || "unknown";
     let resolvedOutput = errorOutput?.trim() || "";
     if (!resolvedOutput) {
-      const lastFailurePath = path5.join(PROJECT_ROOT5, ".qa-lab-last-failure.log");
-      if (fs5.existsSync(lastFailurePath)) {
+      const lastFailurePath = path6.join(PROJECT_ROOT6, ".qa-lab-last-failure.log");
+      if (fs6.existsSync(lastFailurePath)) {
         try {
-          resolvedOutput = fs5.readFileSync(lastFailurePath, "utf8");
+          resolvedOutput = fs6.readFileSync(lastFailurePath, "utf8");
         } catch {
         }
       }
@@ -1777,94 +2718,36 @@ server.registerTool(
         structuredContent: { ok: false, error: "No error output" }
       };
     }
-    let testCode = "";
-    if (testFilePath) {
-      const normalized = testFilePath.replace(/^\//, "").replace(/\\/g, "/");
-      const fullPath = path5.join(PROJECT_ROOT5, normalized);
-      if (fs5.existsSync(fullPath) && !fs5.statSync(fullPath).isDirectory()) {
-        try {
-          testCode = fs5.readFileSync(fullPath, "utf8");
-        } catch {
-        }
-      }
-    }
-    const llm = resolveLLMProvider("complex");
-    if (!llm.apiKey) {
-      return {
-        content: [{
-          type: "text",
-          text: "Configure GROQ_API_KEY, GEMINI_API_KEY ou OPENAI_API_KEY no .env do projeto para usar a explica\xE7\xE3o com LLM."
-        }],
-        structuredContent: { ok: false, error: "No API key configured" }
-      };
-    }
-    const { provider, apiKey, baseUrl, model } = llm;
-    const fwHints = {
-      webdriverio: "WebdriverIO (describe/it, $, browser.$)",
-      appium: "Appium/WebdriverIO (mobile, $, browser.$)",
-      playwright: "Playwright (test, page, locator)",
-      cypress: "Cypress (cy.get, cy.click)",
-      jest: "Jest (describe, test, expect)",
-      vitest: "Vitest (describe, test, expect)",
-      robot: "Robot Framework",
-      pytest: "pytest"
-    };
-    const systemPrompt = `Voc\xEA \xE9 um mentor de QA. Analise o output de falha e responda em JSON (apenas o JSON, sem markdown) com as chaves:
-- oQueAconteceu: string (explica\xE7\xE3o em portugu\xEAs do que aconteceu, simples)
-- porQueProvavelmenteFalhou: array de strings (lista de poss\xEDveis causas, uma por item)
-- oQueFazerAgora: array de strings (passos numerados do que fazer)
-- sugestaoCorrecao: string ou null (c\xF3digo de corre\xE7\xE3o se aplic\xE1vel, no formato do framework)
-- conceito: string ou null (ex: "Flaky test = teste intermitente. Geralmente por timing ou seletores fr\xE1geis.")
-- framework: string (framework do projeto)
-
-Framework do projeto: ${fw}. ${fwHints[fw] || ""}
-Responda APENAS com o JSON v\xE1lido, sem texto antes ou depois.`;
-    const userPrompt = `Output do terminal/log (teste falhou):
----
-${resolvedOutput.slice(0, 12e3)}
----
-${testCode ? `
-C\xF3digo do teste que falhou:
----
-${testCode.slice(0, 6e3)}
----` : ""}`;
-    try {
-      let raw = await callLlmForExplanation(provider, apiKey, baseUrl, model, systemPrompt, userPrompt);
-      raw = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
-      let data = {};
-      try {
-        data = JSON.parse(raw);
-      } catch {
-        data = {
-          oQueAconteceu: raw.slice(0, 500) || "N\xE3o foi poss\xEDvel parsear a resposta.",
-          porQueProvavelmenteFalhou: [],
-          oQueFazerAgora: [],
-          sugestaoCorrecao: null,
-          conceito: null,
-          framework: fw
+    const explainResult = await generateFailureExplanation(resolvedOutput, testFilePath);
+    if (!explainResult.ok) {
+      if (!resolveLLMProvider("complex").apiKey) {
+        return {
+          content: [{
+            type: "text",
+            text: "Configure GROQ_API_KEY, GEMINI_API_KEY ou OPENAI_API_KEY no .env do projeto para usar a explica\xE7\xE3o com LLM."
+          }],
+          structuredContent: { ok: false, error: "No API key configured" }
         };
       }
-      data.framework = data.framework || fw;
-      const formattedText = formatFailureExplanation(data);
-      return {
-        content: [{ type: "text", text: formattedText }],
-        structuredContent: {
-          ok: true,
-          oQueAconteceu: data.oQueAconteceu,
-          porQueProvavelmenteFalhou: data.porQueProvavelmenteFalhou,
-          oQueFazerAgora: data.oQueFazerAgora,
-          sugestaoCorrecao: data.sugestaoCorrecao ?? null,
-          conceito: data.conceito ?? null,
-          framework: data.framework,
-          formattedText
-        }
-      };
-    } catch (err) {
       return {
-        content: [{ type: "text", text: `Erro ao analisar: ${err.message}` }],
-        structuredContent: { ok: false, error: err.message }
+        content: [{ type: "text", text: `Erro ao analisar: ${explainResult.error || "erro desconhecido"}` }],
+        structuredContent: { ok: false, error: explainResult.error }
       };
     }
+    const sc = explainResult.structuredContent;
+    return {
+      content: [{ type: "text", text: sc.formattedText }],
+      structuredContent: {
+        ok: true,
+        oQueAconteceu: sc.oQueAconteceu,
+        porQueProvavelmenteFalhou: sc.porQueProvavelmenteFalhou,
+        oQueFazerAgora: sc.oQueFazerAgora,
+        sugestaoCorrecao: sc.sugestaoCorrecao ?? null,
+        conceito: sc.conceito ?? null,
+        framework: sc.framework,
+        formattedText: sc.formattedText
+      }
+    };
   }
 );
 server.registerTool(
@@ -1932,7 +2815,7 @@ server.registerTool(
     inputSchema: z.object({
       testFilePath: z.string().describe("Caminho do arquivo de teste que falhou (ex: specs/login.spec.js)."),
       errorOutput: z.string().optional().describe("Output do terminal da falha. Se vazio, l\xEA de .qa-lab-last-failure.log."),
-      framework: z.enum(["cypress", "playwright", "webdriverio", "appium"]).optional().describe("Framework do teste. Detectado automaticamente se omitido.")
+      framework: z.enum(["cypress", "playwright", "webdriverio", "appium", "detox"]).optional().describe("Framework do teste. Detectado automaticamente se omitido.")
     }),
     outputSchema: z.object({
       ok: z.boolean(),
@@ -1947,9 +2830,9 @@ server.registerTool(
     const fw = framework || inferFrameworkFromFile(testFilePath.split("/").pop(), structure);
     let resolvedOutput = errorOutput;
     if (!resolvedOutput) {
-      const logPath = path5.join(PROJECT_ROOT5, ".qa-lab-last-failure.log");
-      if (fs5.existsSync(logPath)) {
-        resolvedOutput = fs5.readFileSync(logPath, "utf8");
+      const logPath = path6.join(PROJECT_ROOT6, ".qa-lab-last-failure.log");
+      if (fs6.existsSync(logPath)) {
+        resolvedOutput = fs6.readFileSync(logPath, "utf8");
       }
     }
     if (!resolvedOutput) {
@@ -1965,10 +2848,10 @@ server.registerTool(
       };
     }
     let testCode = "";
-    const fullPath = path5.join(PROJECT_ROOT5, testFilePath.replace(/^\//, "").replace(/\\/g, "/"));
-    if (fs5.existsSync(fullPath)) {
+    const fullPath = path6.join(PROJECT_ROOT6, testFilePath.replace(/^\//, "").replace(/\\/g, "/"));
+    if (fs6.existsSync(fullPath)) {
       try {
-        testCode = fs5.readFileSync(fullPath, "utf8");
+        testCode = fs6.readFileSync(fullPath, "utf8");
       } catch {
       }
     }
@@ -1984,15 +2867,18 @@ server.registerTool(
       cypress: "Cypress: cy.get('[data-testid=...]'), cy.contains(), cy.get('button').filter(':visible')",
       playwright: `Playwright: page.getByRole(), page.getByTestId(), page.locator('button:has-text("...")')`,
       webdriverio: "WebdriverIO: $('[data-testid=...]'), $('button=Texto')",
-      appium: "Appium: $('~accessibility-id'), $('//android.view.View')"
+      appium: `Appium (HIERARQUIA \xDANICA): 1) id: $('~accessibility-id') ou $('~content-desc'). 2) XPath relacional: \xE2ncora est\xE1vel + eixos + TIPO ESPEC\xCDFICO (android.widget.Button, XCUIElementTypeButton). NUNCA use * em XPath \u2014 quebra por timing e m\xFAltiplos matches. Ex: //android.widget.LinearLayout[@resource-id='login_form']/descendant::android.widget.Button[@text='Entrar']. 3) resource-id. Explique a hierarquia.`,
+      detox: `Detox: testID > accessibilityLabel > text. Explique por que \xE9 mais est\xE1vel.`
     };
+    const mobileRules = fw === "appium" || fw === "detox" ? "\n\nMOBILE: 1) id. 2) XPath relacional: \xE2ncora + eixos + TIPO ESPEC\xCDFICO (android.widget.Button, XCUIElementTypeButton). NUNCA use * \u2014 quebra por timing. Ex: //android.widget.LinearLayout[@resource-id='login_form']/descendant::android.widget.Button[@text='Entrar']. 3) resource-id. Explique por que o seletor \xE9 forte." : "";
     const systemPrompt = `Voc\xEA \xE9 um especialista em testes E2E. O teste falhou porque um seletor n\xE3o encontrou o elemento (UI mudou).
 Analise o erro e o c\xF3digo e responda APENAS em JSON (sem markdown) com as chaves:
 - selectorSugerido: string (o novo seletor recomendado, mais resiliente)
 - codigoCorrigido: string (bloco de c\xF3digo completo corrigido, apenas a parte relevante do teste)
-- explicacao: string (breve explica\xE7\xE3o em portugu\xEAs: por que o antigo falhou e por que o novo \xE9 melhor)
+- explicacao: string (breve explica\xE7\xE3o em portugu\xEAs: por que o antigo falhou e por que o novo \xE9 melhor. Em mobile: mencione a hierarquia de estabilidade)
 
 Priorize nesta ordem: data-testid > role + accessible name > texto vis\xEDvel > estrutura. Evite classes CSS e IDs que mudam.
+${mobileRules}
 
 Framework: ${fw}. ${fwHints[fw] || ""}`;
     const userPrompt = `Output do erro:
@@ -2043,6 +2929,114 @@ ${data.codigoCorrigido}
     }
   }
 );
+server.registerTool(
+  "map_mobile_elements",
+  {
+    title: "Mapear elementos mobile (estrutura para testes)",
+    description: "Gera estrutura/template de elementos para testes mobile. Aceita deep link, appPackage/appActivity (Android) ou bundleId (iOS). Retorna instru\xE7\xF5es para mapear elementos (Appium Inspector, uiautomator) e template para usar em generate_tests. Se elementsJsonPath fornecido, l\xEA arquivo e formata para contexto.",
+    inputSchema: z.object({
+      deepLink: z.string().optional().describe("Deep link do app (ex: meuapp://login). Indica ambiente mobile."),
+      appPackage: z.string().optional().describe("Android: package do app (ex: com.example.app)."),
+      appActivity: z.string().optional().describe("Android: activity principal (ex: .MainActivity)."),
+      bundleId: z.string().optional().describe("iOS: bundle identifier do app."),
+      elementsJsonPath: z.string().optional().describe("Caminho para arquivo JSON com elementos mapeados (id, text, accessibilityId, xpath).")
+    }),
+    outputSchema: z.object({
+      ok: z.boolean(),
+      environment: z.string().optional(),
+      elements: z.array(z.object({
+        id: z.string().optional(),
+        text: z.string().optional(),
+        accessibilityId: z.string().optional(),
+        xpath: z.string().optional(),
+        resourceId: z.string().optional(),
+        className: z.string().optional()
+      })).optional(),
+      instructions: z.string().optional(),
+      contextForGenerate: z.string().optional().describe("Texto formatado para passar em generate_tests como contexto."),
+      error: z.string().optional()
+    })
+  },
+  async ({ deepLink, appPackage, appActivity, bundleId, elementsJsonPath }) => {
+    const hasMobileContext = deepLink || appPackage || bundleId;
+    const elements = [];
+    let instructions = "";
+    let contextForGenerate = "";
+    if (elementsJsonPath) {
+      const fullPath = path6.join(PROJECT_ROOT6, elementsJsonPath.replace(/^\//, "").replace(/\\/g, "/"));
+      if (fs6.existsSync(fullPath)) {
+        try {
+          const raw = fs6.readFileSync(fullPath, "utf8");
+          const parsed = JSON.parse(raw);
+          const arr = Array.isArray(parsed) ? parsed : parsed.elements || parsed.items || [];
+          arr.forEach((el) => {
+            elements.push({
+              id: el.id || el.resourceId,
+              text: el.text || el.label,
+              accessibilityId: el.accessibilityId || el["content-desc"] || el.contentDesc,
+              xpath: el.xpath,
+              resourceId: el.resourceId || el.id,
+              className: el.className || el.class
+            });
+          });
+          contextForGenerate = `
+Elementos mapeados da tela (use para seletores est\xE1veis em Appium/WDIO):
+${JSON.stringify(elements, null, 2)}
+`;
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Erro ao ler ${elementsJsonPath}: ${err.message}` }],
+            structuredContent: { ok: false, error: err.message }
+          };
+        }
+      } else {
+        return {
+          content: [{ type: "text", text: `Arquivo n\xE3o encontrado: ${elementsJsonPath}` }],
+          structuredContent: { ok: false, error: "File not found" }
+        };
+      }
+    }
+    if (hasMobileContext || elementsJsonPath) {
+      instructions = [
+        "## Como mapear elementos do app mobile",
+        "",
+        "**Android (Appium):**",
+        "- Use Appium Inspector (appium.io) com appPackage/appActivity",
+        "- Ou: `adb shell uiautomator dump` \u2192 analise o XML exportado",
+        "- Priorize: accessibility-id > resource-id > xpath relativo",
+        "",
+        "**iOS (Appium):**",
+        "- Appium Inspector com bundleId",
+        "- Xcode Accessibility Inspector",
+        "- Priorize: accessibility-id > name",
+        "",
+        "**Formato esperado (elements.json):**",
+        "```json",
+        '[{"accessibilityId": "login_btn", "text": "Entrar", "resourceId": "com.app:id/btn"}]',
+        "```",
+        "",
+        "Salve em um arquivo e passe em `elementsJsonPath` na pr\xF3xima chamada."
+      ].join("\n");
+    }
+    const env = deepLink ? "mobile" : appPackage || bundleId ? "mobile" : elements.length ? "mobile" : "unknown";
+    const text = [
+      contextForGenerate && `## Contexto para generate_tests
+${contextForGenerate}`,
+      instructions && `## Instru\xE7\xF5es
+${instructions}`
+    ].filter(Boolean).join("\n\n");
+    return {
+      content: [{ type: "text", text: text || (hasMobileContext ? `Ambiente: ${env}. ${instructions}` : "Informe deepLink, appPackage ou elementsJsonPath.") }],
+      structuredContent: {
+        ok: true,
+        environment: env,
+        elements: elements.length ? elements : void 0,
+        instructions: instructions || void 0,
+        contextForGenerate: contextForGenerate || void 0
+      }
+    };
+  }
+);
 server.registerTool(
   "analyze_file_methods",
   {
@@ -2073,20 +3067,20 @@ server.registerTool(
   },
   async ({ path: filePath }) => {
     const normalized = filePath.replace(/^\//, "").replace(/\\/g, "/");
-    const fullPath = path5.join(PROJECT_ROOT5, normalized);
-    if (!fullPath.startsWith(PROJECT_ROOT5)) {
+    const fullPath = path6.join(PROJECT_ROOT6, normalized);
+    if (!fullPath.startsWith(PROJECT_ROOT6)) {
       return {
         content: [{ type: "text", text: "Caminho fora do projeto." }],
         structuredContent: { ok: false, error: "Path outside project" }
       };
     }
-    if (!fs5.existsSync(fullPath)) {
+    if (!fs6.existsSync(fullPath)) {
       return {
         content: [{ type: "text", text: `Arquivo n\xE3o encontrado: ${normalized}` }],
         structuredContent: { ok: false, error: "File not found" }
       };
     }
-    const stat = fs5.statSync(fullPath);
+    const stat = fs6.statSync(fullPath);
     if (stat.isDirectory()) {
       return {
         content: [{ type: "text", text: "\xC9 um diret\xF3rio. Informe um arquivo." }],
@@ -2095,7 +3089,7 @@ server.registerTool(
     }
     let fileContent = "";
     try {
-      fileContent = fs5.readFileSync(fullPath, "utf8");
+      fileContent = fs6.readFileSync(fullPath, "utf8");
     } catch (err) {
       return {
         content: [{ type: "text", text: `Erro ao ler: ${err.message}` }],
@@ -2113,7 +3107,7 @@ server.registerTool(
       };
     }
     const { provider, apiKey, baseUrl, model } = llm;
-    const ext = path5.extname(fullPath).toLowerCase();
+    const ext = path6.extname(fullPath).toLowerCase();
     const lang = [".ts", ".tsx"].includes(ext) ? "TypeScript" : [".js", ".jsx"].includes(ext) ? "JavaScript" : [".py"].includes(ext) ? "Python" : "c\xF3digo";
     const systemPrompt = `Voc\xEA \xE9 um revisor de c\xF3digo experiente em QA e testes. Analise o arquivo e cada m\xE9todo/fun\xE7\xE3o, respondendo em JSON v\xE1lido (sem markdown) com a estrutura:
 
@@ -2305,9 +3299,9 @@ server.registerTool(
     const msByPeriod = { "7d": 7 * 24 * 60 * 60 * 1e3, "30d": 30 * 24 * 60 * 60 * 1e3, all: Infinity };
     const cutoff = now - msByPeriod[period];
     let data = { events: [] };
-    if (fs5.existsSync(METRICS_FILE2)) {
+    if (fs6.existsSync(METRICS_FILE2)) {
       try {
-        data = JSON.parse(fs5.readFileSync(METRICS_FILE2, "utf8"));
+        data = JSON.parse(fs6.readFileSync(METRICS_FILE2, "utf8"));
       } catch {
       }
     }
@@ -2344,9 +3338,9 @@ server.registerTool(
       };
     }
     let flowCoverage = null;
-    if (fs5.existsSync(FLOWS_CONFIG_FILE)) {
+    if (fs6.existsSync(FLOWS_CONFIG_FILE)) {
       try {
-        const flowsConfig = JSON.parse(fs5.readFileSync(FLOWS_CONFIG_FILE, "utf8"));
+        const flowsConfig = JSON.parse(fs6.readFileSync(FLOWS_CONFIG_FILE, "utf8"));
         const flows = flowsConfig.flows || [];
         const structure = detectProjectStructure();
         const allTestFiles = new Set(collectTestFiles(structure).map((e) => e.path));
@@ -2485,7 +3479,7 @@ server.registerTool(
     }
     return new Promise((resolve) => {
       const child = spawn2(cmd, args, {
-        cwd: PROJECT_ROOT5,
+        cwd: PROJECT_ROOT6,
         stdio: ["inherit", "pipe", "pipe"],
         shell: process.platform === "win32",
         env: { ...process.env }
@@ -2531,13 +3525,13 @@ server.registerTool(
   async ({ packageManager = "auto" }) => {
     let pm = packageManager;
     if (pm === "auto") {
-      if (fs5.existsSync(path5.join(PROJECT_ROOT5, "yarn.lock"))) pm = "yarn";
-      else if (fs5.existsSync(path5.join(PROJECT_ROOT5, "pnpm-lock.yaml"))) pm = "pnpm";
+      if (fs6.existsSync(path6.join(PROJECT_ROOT6, "yarn.lock"))) pm = "yarn";
+      else if (fs6.existsSync(path6.join(PROJECT_ROOT6, "pnpm-lock.yaml"))) pm = "pnpm";
       else pm = "npm";
     }
     return new Promise((resolve) => {
       const child = spawn2(pm, ["install"], {
-        cwd: PROJECT_ROOT5,
+        cwd: PROJECT_ROOT6,
         stdio: "inherit",
         shell: process.platform === "win32",
         env: { ...process.env }
@@ -2592,9 +3586,9 @@ server.registerTool(
     report += `\u2705 ${structure.testFrameworks.join(", ")} detectado(s)
 `;
     const testFiles = structure.testDirs.flatMap((dir) => {
-      const fullPath = path5.join(PROJECT_ROOT5, dir);
-      if (!fs5.existsSync(fullPath)) return [];
-      return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
+      const fullPath = path6.join(PROJECT_ROOT6, dir);
+      if (!fs6.existsSync(fullPath)) return [];
+      return fs6.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
     });
     report += `\u2705 ${testFiles.length} teste(s) encontrado(s)
 
@@ -2605,7 +3599,7 @@ server.registerTool(
       if (fw) {
         const runResult = await new Promise((resolve) => {
           const child = spawn2("npx", [fw === "cypress" ? "cypress" : fw === "playwright" ? "playwright" : fw, fw === "cypress" ? "run" : fw === "playwright" ? "test" : "run"], {
-            cwd: PROJECT_ROOT5,
+            cwd: PROJECT_ROOT6,
             stdio: ["inherit", "pipe", "pipe"],
             shell: process.platform === "win32"
           });
@@ -2778,9 +3772,9 @@ server.registerTool(
     const memory = loadProjectMemory();
     const stats = getMemoryStats();
     const testFiles = structure.testDirs.flatMap((dir) => {
-      const fullPath = path5.join(PROJECT_ROOT5, dir);
-      if (!fs5.existsSync(fullPath)) return [];
-      return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
+      const fullPath = path6.join(PROJECT_ROOT6, dir);
+      if (!fs6.existsSync(fullPath)) return [];
+      return fs6.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
     });
     let score = 0;
     const recommendations = [];
@@ -2847,9 +3841,9 @@ server.registerTool(
     const memory = loadProjectMemory();
     const suggestions = [];
     const testFiles = structure.testDirs.flatMap((dir) => {
-      const fullPath = path5.join(PROJECT_ROOT5, dir);
-      if (!fs5.existsSync(fullPath)) return [];
-      return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f)).map((f) => f.toLowerCase());
+      const fullPath = path6.join(PROJECT_ROOT6, dir);
+      if (!fs6.existsSync(fullPath)) return [];
+      return fs6.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f)).map((f) => f.toLowerCase());
     });
     const criticalFlows = ["login", "logout", "checkout", "payment", "signup", "search"];
     const missingFlows = criticalFlows.filter((flow) => !testFiles.some((f) => f.includes(flow)));
@@ -3011,6 +4005,70 @@ ${stats.totalLearnings === 0 ? "\u26A0\uFE0F Ainda n\xE3o h\xE1 aprendizados. Us
     };
   }
 );
+server.registerTool(
+  "get_learning_report",
+  {
+    title: "Relat\xF3rio de evolu\xE7\xE3o e aprendizado",
+    description: "Gera relat\xF3rio de evolu\xE7\xE3o dos aprendizados: resumo por tipo, evolu\xE7\xE3o no tempo e recomenda\xE7\xF5es para aprimorar o c\xF3digo.",
+    inputSchema: z.object({
+      format: z.enum(["summary", "full"]).optional().describe("summary = resumo executivo, full = relat\xF3rio completo com recomenda\xE7\xF5es. Default: summary")
+    }),
+    outputSchema: z.object({
+      summary: z.string(),
+      byType: z.record(z.number()),
+      evolution: z.array(z.object({ date: z.string(), type: z.string(), framework: z.string() })).optional(),
+      recommendations: z.array(z.string()).optional()
+    })
+  },
+  async ({ format = "summary" }) => {
+    const memory = loadProjectMemory();
+    const learnings = memory.learnings || [];
+    const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const evolution = format === "full" && learnings.length > 0 ? learnings.slice(-30).map((l) => ({
+      date: (l.timestamp || "").slice(0, 10),
+      type: l.type || "unknown",
+      framework: l.framework || "-"
+    })) : [];
+    const recommendations = [];
+    if (byType.element_not_rendered > 0 || byType.element_not_visible > 0) {
+      recommendations.push("Use waits expl\xEDcitos (waitForSelector, waitForDisplayed) ANTES de interagir com elementos.");
+    }
+    if (byType.timing_fix > 0 || byType.element_stale > 0) {
+      recommendations.push("Aumente timeouts e use re-localiza\xE7\xE3o de elementos em listas din\xE2micas.");
+    }
+    if (byType.selector_fix > 0 || byType.mobile_mapping_invisible > 0) {
+      recommendations.push("Priorize data-testid, role e seletores est\xE1veis; em mobile, use mapeamento vis\xEDvel no topo do spec.");
+    }
+    if (stats.firstAttemptSuccessRate < 70 && stats.testsGenerated > 0) {
+      recommendations.push("Aplique UNIVERSAL_TEST_PRACTICES em cada teste gerado: waits inteligentes + assert final.");
+    }
+    if (recommendations.length === 0 && learnings.length > 0) {
+      recommendations.push("Continue aplicando as pr\xE1ticas aprendidas em novos testes.");
+    }
+    const summary = `\u{1F4C8} **Relat\xF3rio de Evolu\xE7\xE3o e Aprendizado**
+
+**Resumo por tipo:**
+${Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `- ${t}: ${v}`).join("\n") || "- Nenhum aprendizado por tipo ainda"}
+
+**M\xE9tricas gerais:**
+- Total de aprendizados: ${stats.totalLearnings}
+- Taxa de sucesso (1\xAA tentativa): ${stats.firstAttemptSuccessRate}%
+- Testes gerados: ${stats.testsGenerated}
+
+${format === "full" && recommendations.length > 0 ? `**Recomenda\xE7\xF5es para aprimorar o c\xF3digo:**
+${recommendations.map((r) => `\u2022 ${r}`).join("\n")}` : ""}`;
+    return {
+      content: [{ type: "text", text: summary }],
+      structuredContent: {
+        summary: summary.trim(),
+        byType,
+        evolution: format === "full" ? evolution : void 0,
+        recommendations: format === "full" ? recommendations : void 0
+      }
+    };
+  }
+);
 server.registerTool(
   "qa_compare_with_industry",
   {
@@ -3034,9 +4092,9 @@ server.registerTool(
     const structure = detectProjectStructure();
     const stats = getMemoryStats();
     const testFiles = structure.testDirs.flatMap((dir) => {
-      const fullPath = path5.join(PROJECT_ROOT5, dir);
-      if (!fs5.existsSync(fullPath)) return [];
-      return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
+      const fullPath = path6.join(PROJECT_ROOT6, dir);
+      if (!fs6.existsSync(fullPath)) return [];
+      return fs6.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f));
     });
     const industryBenchmarks = {
       coverageAvg: "70-80%",
@@ -3103,16 +4161,16 @@ server.registerTool(
       testFiles = [testFile];
     } else {
       testFiles = structure.testDirs.flatMap((dir) => {
-        const fullPath = path5.join(PROJECT_ROOT5, dir);
-        if (!fs5.existsSync(fullPath)) return [];
-        return fs5.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f)).map((f) => path5.join(dir, f));
+        const fullPath = path6.join(PROJECT_ROOT6, dir);
+        if (!fs6.existsSync(fullPath)) return [];
+        return fs6.readdirSync(fullPath, { recursive: true }).filter((f) => /\.(spec|test|cy)\.(js|ts|jsx|tsx|py)$/.test(f)).map((f) => path6.join(dir, f));
       });
     }
     const predictions = [];
     for (const file of testFiles.slice(0, 20)) {
-      const fullPath = path5.join(PROJECT_ROOT5, file);
-      if (!fs5.existsSync(fullPath)) continue;
-      const content = fs5.readFileSync(fullPath, "utf8");
+      const fullPath = path6.join(PROJECT_ROOT6, file);
+      if (!fs6.existsSync(fullPath)) continue;
+      const content = fs6.readFileSync(fullPath, "utf8");
       const reasons = [];
       let riskScore = 0;
       if (/\.(class|id)\s*=|querySelector|\.class-name/i.test(content)) {
@@ -3187,7 +4245,7 @@ server.registerTool(
     if (fw === "jest") {
       return new Promise((resolve) => {
         const child = spawn2("npx", ["jest", "--coverage"], {
-          cwd: PROJECT_ROOT5,
+          cwd: PROJECT_ROOT6,
           stdio: ["inherit", "pipe", "pipe"],
           shell: process.platform === "win32",
           env: { ...process.env }
@@ -3303,14 +4361,16 @@ server.registerTool(
     let testFilePath = null;
     let testContent = null;
     let attempt = 0;
+    let appliedLearningFix = false;
     learnings.push({ attempt: 0, action: "detect_project", result: `${structure.testFrameworks.length} framework(s)` });
     for (attempt = 1; attempt <= maxRetries; attempt++) {
       learnings.push({ attempt, action: "generate_tests", result: "gerando..." });
       const { provider, apiKey, baseUrl, model } = llm;
-      const memoryHints = memory.learnings?.filter((l) => l.success).slice(-10).map((l) => l.fix).join("\n") || "";
+      const memoryHints = memory.learnings?.filter((l) => l.fix).slice(-10).map((l) => l.fix).join("\n") || "";
       const systemPrompt = `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
-${memoryHints ? `
-Aprendizados anteriores (use como refer\xEAncia):
+${UNIVERSAL_TEST_PRACTICES}
+
+${memoryHints ? `Aprendizados anteriores (use como refer\xEAncia):
 ${memoryHints.slice(0, 1e3)}` : ""}
 Retorne SOMENTE o c\xF3digo, sem markdown.`;
       const userPrompt = `Contexto:
@@ -3352,15 +4412,15 @@ Framework: ${fw}`;
           const fileName = request.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").slice(0, 30);
           const { ext, baseDir } = getExtensionAndBaseDir2(fw, structure);
           const safeName = fileName + ext;
-          testFilePath = path5.join(baseDir, safeName);
-          if (!fs5.existsSync(baseDir)) fs5.mkdirSync(baseDir, { recursive: true });
+          testFilePath = path6.join(baseDir, safeName);
+          if (!fs6.existsSync(baseDir)) fs6.mkdirSync(baseDir, { recursive: true });
         }
-        fs5.writeFileSync(testFilePath, testContent, "utf8");
+        fs6.writeFileSync(testFilePath, testContent, "utf8");
         learnings.push({ attempt, action: "write_test", result: `gravado: ${testFilePath}` });
         learnings.push({ attempt, action: "run_tests", result: "executando..." });
         const runResult = await new Promise((resolve) => {
           const child = spawn2("npx", [fw === "cypress" ? "cypress" : fw === "playwright" ? "playwright" : fw, fw === "cypress" ? "run" : fw === "playwright" ? "test" : "run", testFilePath], {
-            cwd: PROJECT_ROOT5,
+            cwd: PROJECT_ROOT6,
             stdio: ["inherit", "pipe", "pipe"],
             shell: process.platform === "win32"
           });
@@ -3378,12 +4438,15 @@ Framework: ${fw}`;
           saveProjectMemory({
             learnings: [{ type: "test_generated", request, framework: fw, success: true, passedFirstTime: attempt === 1, attempts: attempt, timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
           });
+          const learnedAppendix2 = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ runOutput: runResult?.output, fixSummary: "Ajustei o c\xF3digo aplicando waits e valida\xE7\xE3o correta.", framework: fw })}` : "";
           return {
             content: [{ type: "text", text: `\u2705 Teste passou na tentativa ${attempt}!
 
 Arquivo: ${testFilePath}
 
-Aprendizados salvos.` }],
+Aprendizados salvos.${learnedAppendix2}` }],
             structuredContent: { ok: true, testFilePath, attempts: attempt, finalStatus: "passed", learnings }
           };
         }
@@ -3393,11 +4456,14 @@ Aprendizados salvos.` }],
           saveProjectMemory({
             learnings: [{ type: "test_generated", request, framework: fw, success: false, attempts: attempt, timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
           });
+          const learnedAppendix2 = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ runOutput: runResult.output, framework: fw, fixSummary: "Tentei corrigir. Nas pr\xF3ximas execu\xE7\xF5es usarei esse aprendizado desde o in\xEDcio." })}` : "";
           return {
             content: [{ type: "text", text: `\u274C Teste falhou ap\xF3s ${attempt} tentativa(s).
 
 \xDAltimo erro:
-${runResult.output.slice(0, 500)}` }],
+${runResult.output.slice(0, 500)}${learnedAppendix2}` }],
             structuredContent: { ok: false, testFilePath, attempts: attempt, finalStatus: "max_retries", learnings }
           };
         }
@@ -3412,19 +4478,24 @@ ${runResult.output.slice(0, 500)}` }],
         learnings.push({ attempt, action: "apply_fix", result: "aplicando corre\xE7\xE3o..." });
         const fixedCode = explainResult.structuredContent.sugestaoCorrecao;
         testContent = fixedCode;
-        fs5.writeFileSync(testFilePath, testContent, "utf8");
+        fs6.writeFileSync(testFilePath, testContent, "utf8");
         learnings.push({ attempt, action: "apply_fix", result: "corre\xE7\xE3o aplicada" });
         if (flakyAnalysis.isLikelyFlaky) {
+          const inferredPattern = inferFailurePattern(runResult.output, fw);
+          const learningType = inferredPattern?.learningType || (flakyAnalysis.patterns[0]?.pattern === "selector" ? "selector_fix" : "timing_fix");
+          const learningFix = inferredPattern?.lesson || fixedCode.slice(0, 500);
           saveProjectMemory({
             learnings: [{
-              type: flakyAnalysis.patterns[0]?.pattern === "selector" ? "selector_fix" : "timing_fix",
+              type: learningType,
               request,
               framework: fw,
-              fix: fixedCode.slice(0, 500),
+              fix: learningFix,
+              pattern: inferredPattern?.name,
               success: false,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             }]
           });
+          appliedLearningFix = true;
         }
       } catch (err) {
         learnings.push({ attempt, action: "error", result: err.message });
@@ -3434,8 +4505,11 @@ ${runResult.output.slice(0, 500)}` }],
         };
       }
     }
+    const learnedAppendix = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ fixSummary: "Tentei corrigir. Nas pr\xF3ximas execu\xE7\xF5es usarei esse aprendizado desde o in\xEDcio." })}` : "";
     return {
-      content: [{ type: "text", text: `\u274C Falhou ap\xF3s ${maxRetries} tentativa(s).` }],
+      content: [{ type: "text", text: `\u274C Falhou ap\xF3s ${maxRetries} tentativa(s).${learnedAppendix}` }],
       structuredContent: { ok: false, testFilePath, attempts: maxRetries, finalStatus: "max_retries", learnings }
     };
   }
@@ -3488,9 +4562,16 @@ test.describe('${type.toUpperCase()} Test', () => {
 );
 async function main() {
   const cmd = process.argv[2];
+  if (cmd === "learning-hub") {
+    const __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
+    const hubPath = path6.join(__dirname2, "..", "learning-hub", "src", "server.js");
+    const hubUrl2 = pathToFileURL(hubPath).href;
+    await import(hubUrl2);
+    return;
+  }
   if (cmd === "slack-bot") {
-    const __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
-    const slackBotPath = path5.join(__dirname2, "..", "slack-bot", "src", "index.js");
+    const __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
+    const slackBotPath = path6.join(__dirname2, "..", "slack-bot", "src", "index.js");
     const slackBotUrl = pathToFileURL(slackBotPath).href;
     await import(slackBotUrl);
     return;