@decocms/parity 0.7.0 → 0.8.0

package/dist/cli.js

@@ -8473,6 +8473,9 @@ async function tracePage(page, url, selector, settleMs) {
     return;
   });
   await page.waitForTimeout(settleMs);
+  return traceLoadedPage(page, page.url(), selector);
+}
+async function traceLoadedPage(page, url, selector) {
   const cdp = await page.context().newCDPSession(page);
   await cdp.send("DOM.enable");
   await cdp.send("CSS.enable");
@@ -8825,820 +8828,1892 @@ ${JSON.stringify(checks.map((c) => ({ name: c.name, status: c.status, summary: c
   return text ? 0 : 1;
 }
 
-// src/commands/journey.ts
-import { writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join10 } from "node:path";
+// src/commands/section.ts
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve } from "node:path";
 import chalk10 from "chalk";
-import ora3 from "ora";
+import * as cheerio5 from "cheerio";
+import * as diff2 from "diff";
+import prettier2 from "prettier";
 
-// src/llm/pick-plp.ts
-var PATH_BLOCKLIST = [
-  "/atendimento",
-  "/lojas",
-  "/empresa",
-  "/sobre",
-  "/blog",
-  "/vale-presente",
-  "/contato",
-  "/ajuda",
-  "/trabalhe-conosco",
-  "/imprensa",
-  "/institucional",
-  "/privacidade",
-  "/termos",
-  "/quem-somos",
-  "/loja-fisica",
-  "/franquia"
+// src/engine/computed-styles.ts
+var SECTION_STYLE_KEYS = [
+  "display",
+  "visibility",
+  "opacity",
+  "position",
+  "z-index",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "width",
+  "height",
+  "max-width",
+  "max-height",
+  "min-width",
+  "min-height",
+  "transform",
+  "clip-path",
+  "overflow",
+  "overflow-x",
+  "overflow-y",
+  "margin",
+  "padding",
+  "border",
+  "font-size",
+  "font-weight",
+  "color",
+  "background-color",
+  "background-image",
+  "flex-direction",
+  "justify-content",
+  "align-items",
+  "gap",
+  "grid-template-columns",
+  "grid-template-rows"
 ];
-async function pickCategoryLink(candidates) {
-  if (candidates.length === 0)
-    return null;
-  if (candidates.length === 1)
-    return candidates[0];
-  const filtered = candidates.filter((c) => !isBlocked(c.href));
-  if (filtered.length === 0)
-    return candidates[0] ?? null;
-  if (filtered.length === 1)
-    return filtered[0];
-  const strong = filtered.filter((c) => /\/c\/|\/category\/|\/collections\//.test(c.href));
-  if (strong.length === 1)
-    return strong[0];
-  if (strong.length > 0 && strong.length < filtered.length) {
-    return await llmPick(strong) ?? strong[0];
+async function readComputedStyles(page, selector) {
+  const keys = SECTION_STYLE_KEYS;
+  let exists = false;
+  try {
+    exists = await page.locator(selector).count() > 0;
+  } catch (err) {
+    return { found: false, error: `seletor inválido: ${err.message}` };
   }
-  return await llmPick(filtered) ?? filtered[0];
-}
-function isBlocked(href) {
+  if (!exists) {
+    return { found: false, error: `seletor '${selector}' não casou nenhum elemento` };
+  }
+  const hiddenByPlaywright = !await page.locator(selector).first().isVisible({ timeout: 1000 }).catch(() => false);
+  let got;
   try {
-    const path = new URL(href, "http://placeholder.invalid").pathname.toLowerCase();
-    return PATH_BLOCKLIST.some((b) => path.startsWith(b));
-  } catch {
-    return false;
+    got = await page.evaluate(({ sel, keys: keys2 }) => {
+      try {
+        const el = document.querySelector(sel);
+        if (!el || !(el instanceof HTMLElement)) {
+          return { ok: false, reason: "querySelector retornou null ou non-HTMLElement" };
+        }
+        const cs = window.getComputedStyle(el);
+        const out = {};
+        for (const k of keys2)
+          out[k] = cs.getPropertyValue(k) || "";
+        const r = el.getBoundingClientRect();
+        return {
+          ok: true,
+          styles: out,
+          rect: { x: r.x, y: r.y, width: r.width, height: r.height }
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          reason: `document.querySelector inválido em '${sel}': ${err.message ?? "syntax error"}`
+        };
+      }
+    }, { sel: selector, keys });
+  } catch (err) {
+    return {
+      found: false,
+      error: `falha no page.evaluate de '${selector}': ${err.message ?? "unknown"}. Se o seletor usa sintaxe Playwright-only (text=..., :visible, xpath=...), use um seletor CSS puro.`
+    };
   }
+  if (!got.ok) {
+    return { found: false, error: got.reason };
+  }
+  return { found: true, styles: got.styles, rect: got.rect, hiddenByPlaywright };
 }
-async function llmPick(candidates) {
-  const input = await callTool({
-    systemPrompt: "Você escolhe links de categoria reais em sites de e-commerce. Categoria real = página que lista produtos à venda. Evite: institucional, atendimento, blog, vale-presente, lojas físicas. Prefira URLs com /c/, /category/, /collections/ ou claramente vinculadas a tipos de produto.",
-    userText: `Candidatos:
-${candidates.map((c, i) => `${i}. "${c.text}" → ${c.href}`).join(`
-`)}`,
-    maxTokens: 200,
-    tool: {
-      name: "pick_category",
-      description: "Pick the index of the best category link",
-      inputSchema: {
-        type: "object",
-        properties: {
-          index: { type: "number", description: "Index in the input list (0-based)" },
-          reasoning: { type: "string", description: "1 sentence rationale" }
-        },
-        required: ["index"]
+
+// src/engine/css-source-resolver.ts
+var INHERITABLE_PROPERTIES = new Set([
+  "color",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "font-style",
+  "line-height",
+  "letter-spacing",
+  "text-align",
+  "text-transform",
+  "text-indent",
+  "visibility",
+  "direction"
+]);
+function resolveFromTrace(trace, props) {
+  const result = new Map;
+  const wanted = new Set;
+  for (const p of props)
+    wanted.add(p.toLowerCase());
+  const candidates = new Map;
+  for (const rule of trace.rules) {
+    for (const prop of rule.properties) {
+      const name = prop.name.toLowerCase();
+      if (!wanted.has(name))
+        continue;
+      const dist = rule.inheritedFromDistance ?? 0;
+      if (dist > 0 && !INHERITABLE_PROPERTIES.has(name))
+        continue;
+      const list = candidates.get(name) ?? [];
+      list.push({ rule, value: prop.value, important: prop.important });
+      candidates.set(name, list);
+    }
+  }
+  for (const prop of wanted) {
+    const list = candidates.get(prop);
+    if (!list || list.length === 0) {
+      result.set(prop, null);
+      continue;
+    }
+    let winner = list[list.length - 1];
+    for (let i = list.length - 1;i >= 0; i--) {
+      if (list[i]?.important) {
+        winner = list[i];
+        break;
       }
     }
-  });
-  const idx = input?.index;
-  if (typeof idx === "number" && idx >= 0 && idx < candidates.length) {
-    return candidates[idx];
+    if (!winner) {
+      result.set(prop, null);
+      continue;
+    }
+    result.set(prop, {
+      source: winner.rule.source,
+      selector: winner.rule.selector,
+      value: winner.value,
+      important: winner.important,
+      inheritedFromDistance: winner.rule.inheritedFromDistance ?? 0
+    });
   }
-  return null;
+  return result;
 }
 
-// src/llm/recover-step.ts
-import * as cheerio5 from "cheerio";
-var RECOVER_STEP_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    selector: { type: "string", description: "CSS or Playwright selector that targets the element" },
-    action: { type: "string", enum: ["click", "fill", "press"] },
-    value: { type: "string", description: "For 'fill' or 'press', the text/key to use" },
-    reasoning: { type: "string" }
-  },
-  required: ["selector", "action"]
-};
-function compactHtmlForRecovery(html, maxChars = 12000) {
-  try {
-    const $ = cheerio5.load(html);
-    $("script, style, noscript, svg, picture source, link, meta").remove();
-    const allowed = $("header, nav, main, footer, dialog, [role='dialog'], form, button, a, input, [data-buy-button], [data-checkout], [data-minicart], [role='button']").map((_, el) => $.html(el)).get().join(`
+// src/diff/heatmap-regions.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+import { PNG as PNG3 } from "pngjs";
+var DEFAULT_MAX_HOTSPOTS = 5;
+var DEFAULT_MIN_COMPONENT_PIXELS = 50;
+function analyzeHeatmapRegions(pngPath, opts = {}) {
+  const png = PNG3.sync.read(readFileSync7(pngPath));
+  return analyzeHeatmapBuffer(png.data, png.width, png.height, opts);
+}
+function analyzeHeatmapBuffer(data, width, height, opts = {}) {
+  const maxHotspots = opts.maxHotspots ?? DEFAULT_MAX_HOTSPOTS;
+  const minPixels = opts.minComponentPixels ?? DEFAULT_MIN_COMPONENT_PIXELS;
+  const mask = new Uint8Array(width * height);
+  let diffPixels = 0;
+  for (let i = 0, p = 0;i < data.length; i += 4, p++) {
+    const r = data[i] ?? 0;
+    const g = data[i + 1] ?? 0;
+    const b = data[i + 2] ?? 0;
+    if (r > 100 && r > g + 40 && r > b + 40) {
+      mask[p] = 1;
+      diffPixels++;
+    }
+  }
+  const totalPixels = width * height;
+  const pctDiff = totalPixels > 0 ? diffPixels / totalPixels : 0;
+  if (diffPixels === 0) {
+    return {
+      imageWidth: width,
+      imageHeight: height,
+      diffPixels: 0,
+      pctDiff: 0,
+      boundingBox: null,
+      hotspots: []
+    };
+  }
+  const components = [];
+  const stack = [];
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let p = 0;p < mask.length; p++) {
+    if (mask[p] !== 1)
+      continue;
+    const componentMinX = p % width;
+    const componentMinY = Math.floor(p / width);
+    let cMinX = componentMinX;
+    let cMinY = componentMinY;
+    let cMaxX = componentMinX;
+    let cMaxY = componentMinY;
+    let cPixels = 0;
+    stack.push(p);
+    mask[p] = 2;
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      cPixels++;
+      const cx = cur % width;
+      const cy = Math.floor(cur / width);
+      if (cx < cMinX)
+        cMinX = cx;
+      if (cx > cMaxX)
+        cMaxX = cx;
+      if (cy < cMinY)
+        cMinY = cy;
+      if (cy > cMaxY)
+        cMaxY = cy;
+      for (let dy = -1;dy <= 1; dy++) {
+        for (let dx = -1;dx <= 1; dx++) {
+          if (dx === 0 && dy === 0)
+            continue;
+          const nx = cx + dx;
+          const ny = cy + dy;
+          if (nx < 0 || nx >= width || ny < 0 || ny >= height)
+            continue;
+          const np = ny * width + nx;
+          if (mask[np] !== 1)
+            continue;
+          mask[np] = 2;
+          stack.push(np);
+        }
+      }
+    }
+    if (cPixels >= minPixels) {
+      components.push({
+        x: cMinX,
+        y: cMinY,
+        width: cMaxX - cMinX + 1,
+        height: cMaxY - cMinY + 1,
+        pixelCount: cPixels
+      });
+    }
+    if (cMinX < minX)
+      minX = cMinX;
+    if (cMinY < minY)
+      minY = cMinY;
+    if (cMaxX > maxX)
+      maxX = cMaxX;
+    if (cMaxY > maxY)
+      maxY = cMaxY;
+  }
+  const sorted = components.sort((a, b) => b.width * b.height - a.width * a.height).slice(0, maxHotspots);
+  const boundingBox = maxX >= 0 ? {
+    x: minX,
+    y: minY,
+    width: maxX - minX + 1,
+    height: maxY - minY + 1,
+    pixelCount: diffPixels
+  } : { x: 0, y: 0, width: 0, height: 0, pixelCount: 0 };
+  return {
+    imageWidth: width,
+    imageHeight: height,
+    diffPixels,
+    pctDiff,
+    boundingBox,
+    hotspots: sorted
+  };
+}
+
+// src/diff/section-bundle.ts
+import { writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, dirname, join as join8, relative as relative3 } from "node:path";
+function buildStyleDeltas(input) {
+  const cs = input.computedStyles;
+  if (!cs)
+    return [];
+  const prod = cs.prod;
+  const cand = cs.cand;
+  if (!("found" in prod) || !("found" in cand) || !prod.found || !cand.found)
+    return [];
+  const deltas = [];
+  for (const key of SECTION_STYLE_KEYS) {
+    const p = prod.styles[key] ?? "";
+    const c = cand.styles[key] ?? "";
+    if (p === c)
+      continue;
+    deltas.push({
+      property: key,
+      prod: p,
+      cand: c,
+      prodSource: input.cssSources?.prod.get(key) ?? null,
+      candSource: input.cssSources?.cand.get(key) ?? null
+    });
+  }
+  return deltas;
+}
+function assembleSectionDiffBundle(input) {
+  const styleDeltas = buildStyleDeltas(input);
+  const json = {
+    selector: input.selector,
+    pageKey: input.pageKey ?? null,
+    viewport: input.viewport,
+    prodUrl: input.prodUrl,
+    candUrl: input.candUrl,
+    html: input.html ? {
+      diffPatch: input.html.diffPatch,
+      prodHtmlBytes: input.html.prod.length,
+      candHtmlBytes: input.html.cand.length
+    } : null,
+    screenshots: input.screenshots ?? null,
+    heatmap: input.heatmap ?? null,
+    boundingRects: styleResultsToRects(input.computedStyles),
+    styleDeltas
+  };
+  const jsonPath = join8(input.outDir, `${input.filePrefix}-bundle.json`);
+  writeFileSync6(jsonPath, `${JSON.stringify(json, mapReplacer, 2)}
+`, "utf8");
+  const markdown = renderMarkdownBundle(input, styleDeltas);
+  const markdownPath = join8(input.outDir, `${input.filePrefix}-prompt.md`);
+  writeFileSync6(markdownPath, markdown, "utf8");
+  const summary = oneLineSummary(input, styleDeltas);
+  return { jsonPath, markdownPath, summary };
+}
+function mapReplacer(_key, value) {
+  if (value instanceof Map)
+    return Object.fromEntries(value);
+  return value;
+}
+function styleResultsToRects(cs) {
+  if (!cs)
+    return null;
+  const p = cs.prod;
+  const c = cs.cand;
+  if (!("found" in p) || !("found" in c) || !p.found || !c.found)
+    return null;
+  return { prod: p.rect, cand: c.rect };
+}
+function oneLineSummary(input, deltas) {
+  const parts = [];
+  if (input.heatmap && input.heatmap.diffPixels > 0) {
+    const pct = (input.heatmap.pctDiff * 100).toFixed(1);
+    parts.push(`${pct}% pixels differ`);
+  }
+  if (deltas.length > 0)
+    parts.push(`${deltas.length} style delta(s)`);
+  if (input.html?.diffPatch) {
+    const diffLines2 = input.html.diffPatch.split(`
+`).filter((l) => /^[-+](?![-+])/.test(l)).length;
+    if (diffLines2 > 0)
+      parts.push(`${diffLines2} HTML line(s) changed`);
+  }
+  if (parts.length === 0)
+    return "no diffs detected for this section";
+  return parts.join(" · ");
+}
+function renderMarkdownBundle(input, deltas) {
+  const lines = [];
+  const md = lines.push.bind(lines);
+  md(`# Pixel-perfect fix request: \`${input.selector}\``);
+  md("");
+  md('You are reviewing a migrated page. The **"prod"** version is the');
+  md('source of truth. The **"cand"** version has divergences that need');
+  md("to be fixed. Your job is to identify the smallest possible change");
+  md("to make `cand` match `prod` for this section.");
+  md("");
+  md("## Section identification");
+  md(`- **Selector**: \`${input.selector}\``);
+  if (input.pageKey)
+    md(`- **Page**: \`${input.pageKey}\``);
+  md(`- **Viewport**: ${input.viewport}`);
+  md(`- **prod URL**: ${input.prodUrl}`);
+  md(`- **cand URL**: ${input.candUrl}`);
+  md("");
+  if (input.screenshots || input.heatmap) {
+    md("## Visual diff");
+    if (input.heatmap) {
+      const pct = (input.heatmap.pctDiff * 100).toFixed(2);
+      md(`- **${pct}% of pixels differ** (${input.heatmap.diffPixels} / ${input.heatmap.imageWidth * input.heatmap.imageHeight})`);
+      if (input.heatmap.boundingBox) {
+        const bb = input.heatmap.boundingBox;
+        md(`- Bounding box of divergence: \`x=${bb.x} y=${bb.y} w=${bb.width} h=${bb.height}\``);
+      }
+      if (input.heatmap.hotspots.length > 0) {
+        md("- Hotspots (top regions by area):");
+        for (const h of input.heatmap.hotspots.slice(0, 5)) {
+          md(`  - \`(${h.x}, ${h.y}) ${h.width}×${h.height}\` — ${h.pixelCount} px`);
+        }
+      }
+    }
+    if (input.screenshots) {
+      md("");
+      md("**prod** (source of truth):");
+      md(`![prod](${relativeOrAbs(input.outDir, input.screenshots.prodPath)})`);
+      md("");
+      md("**cand** (needs to match prod):");
+      md(`![cand](${relativeOrAbs(input.outDir, input.screenshots.candPath)})`);
+      if (input.screenshots.heatmapPath) {
+        md("");
+        md("**Heatmap** (red = differs):");
+        md(`![heatmap](${relativeOrAbs(input.outDir, input.screenshots.heatmapPath)})`);
+      }
+    }
+    md("");
+  }
+  const cs = input.computedStyles;
+  if (cs && "found" in cs.prod && "found" in cs.cand && cs.prod.found && cs.cand.found) {
+    const pr = cs.prod.rect;
+    const cr = cs.cand.rect;
+    if (pr && cr && (pr.width !== cr.width || pr.height !== cr.height)) {
+      md("## Layout");
+      md(`- prod section box: ${pr.width}×${pr.height} at (${pr.x}, ${pr.y})`);
+      md(`- cand section box: ${cr.width}×${cr.height} at (${cr.x}, ${cr.y})`);
+      const dw = cr.width - pr.width;
+      const dh = cr.height - pr.height;
+      if (dw !== 0)
+        md(`  - cand width Δ = ${dw > 0 ? "+" : ""}${dw}px`);
+      if (dh !== 0)
+        md(`  - cand height Δ = ${dh > 0 ? "+" : ""}${dh}px`);
+      md("");
+    }
+  }
+  if (deltas.length > 0) {
+    md("## Computed-styles deltas");
+    md("");
+    md("| Property | prod | cand | Likely source |");
+    md("|---|---|---|---|");
+    for (const d of deltas) {
+      const source = formatSource(d.candSource);
+      md(`| \`${d.property}\` | \`${truncate4(d.prod, 60)}\` | \`${truncate4(d.cand, 60)}\` | ${source} |`);
+    }
+    md("");
+  }
+  if (input.html?.diffPatch) {
+    md("## HTML diff");
+    md("");
+    md("```diff");
+    const cappedDiff = capDiff(input.html.diffPatch, 200);
+    md(cappedDiff);
+    md("```");
+    md("");
+  }
+  md("## What I want you to do");
+  md("");
+  md("**Step 1: confirm understanding (this turn).** In ONE paragraph,");
+  md("summarize what you see:");
+  md("- What is the most visible difference in the heatmap?");
+  md("- Which CSS property is most likely responsible?");
+  md("- Which file/component would you edit?");
+  md("");
+  md("Do **NOT** write code yet. Just confirm what you understood.");
+  md("");
+  md("**Step 2 (next turn, after I confirm).** I will ask you to write");
+  md("the patch. Plan to make the smallest change possible. Reuse");
+  md("existing utilities/classes when the diff suggests it; avoid net-new");
+  md("CSS rules unless absolutely needed.");
+  md("");
+  return lines.join(`
 `);
-    const truncated = allowed.length > maxChars ? `${allowed.slice(0, maxChars)}
-<!-- TRUNCATED -->` : allowed;
-    return truncated;
+}
+function relativeOrAbs(outDir, absPath) {
+  try {
+    if (dirname(absPath) === outDir)
+      return basename2(absPath);
+    return relative3(outDir, absPath);
   } catch {
-    return html.slice(0, maxChars);
+    return absPath;
   }
 }
-var RECOVERY_SYSTEM_PROMPT = `
-Você ajuda a recuperar passos de teste E2E (Playwright) que falharam contra sites de e-commerce.
-
-Receba o nome do step, a ação desejada e o HTML compactado da página ATUAL. Sugira UM seletor + ação ('click' | 'fill' | 'press') que provavelmente funciona NESTE HTML específico.
-
-REGRAS CRÍTICAS:
-
-1. **Baseie no HTML fornecido.** Encontre o elemento literal no markup. Confirme mentalmente que o seletor que você vai retornar casa um elemento VISÍVEL no HTML compactado.
-
-2. **Se o step é 'go-checkout' ou 'go-checkout-retry':**
-   - O alvo é um BOTÃO/LINK CTA com texto visível contendo "Finalizar", "Finalizar compra", "Continuar", "Continuar para pagamento", "Ir para o checkout", "Checkout", "Concluir", "Pagar", "Ir para o pagamento", "Avançar", "Próxima etapa".
-   - **NUNCA** sugira o ícone genérico de carrinho do HEADER (texto curto "0", "1", badge counter, ou aria-label "Carrinho" sozinho). Esse é o gatilho que ABRE o drawer/cart-page, não o que finaliza compra.
-   - **Selectors com href de checkout (\`a[href*="checkout"]\`, \`a[href="/checkout/#/cart?v=1"]\`) PODEM funcionar** mas SOMENTE quando qualificados — ou seja, garanta uma das duas:
-     a. Qualificação por **texto**: \`a[href*="checkout"]:has-text('Finalizar')\`, \`a[href*="checkout"]:has-text('Continuar')\`
-     b. Qualificação por **scope**: \`[role='dialog'] a[href*="checkout"]\`, \`[class*='minicart' i] a[href*="checkout"]\`, \`.cart-drawer a[href*="checkout"]\`
-     Selectors GENÉRICOS sem qualificador (apenas \`a[href*="checkout"]\` sozinho) casam o ícone do header e devem ser EVITADOS.
-   - Se NENHUM elemento com texto/scope plausível existe no HTML, retorne selector="" para sinalizar incerteza honestamente.
+function formatSource(s) {
+  if (!s)
+    return "_(no rule found / user-agent default)_";
+  const tag = s.important ? " **!important**" : "";
+  const inh = s.inheritedFromDistance > 0 ? " _(inherited)_" : "";
+  return `\`${s.selector}\` in ${s.source}${tag}${inh}`;
+}
+function truncate4(s, max) {
+  if (!s)
+    return "";
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+function capDiff(diff2, maxLines) {
+  const lines = diff2.split(`
+`);
+  if (lines.length <= maxLines)
+    return diff2;
+  const kept = lines.slice(0, maxLines);
+  kept.push("");
+  kept.push(`... [${lines.length - maxLines} more lines truncated]`);
+  return kept.join(`
+`);
+}
 
-3. **Se o step é 'shipping-calc-cart' ou 'shipping-calc-pdp':**
-   - O alvo é um \`<input>\` (não button/link) visível com label/placeholder mencionando "CEP", "Frete", "Calcular", "Entrega", "Zip".
-   - Prefira inputs cujo container/pai está visível (não escondido em accordion fechado).
-
-4. **Seletores preferidos** (nesta ordem):
-   - Text-based Playwright: \`button:has-text('Finalizar')\`, \`a:has-text('Continuar para pagamento')\`
-   - data-attributes específicos: \`[data-checkout-button]\`, \`[data-cart-finalize]\`, \`[data-fs-cart-button]\`
-   - ARIA: \`[aria-label*='finalizar' i]\`, \`[role='button'][aria-label*='checkout' i]\`
-   - Classes específicas de plataforma: \`.vtex-minicart-2-x-checkoutButton\`, \`.fs-cart__checkout\`
-   - Por último, escopo hierárquico curto: \`[role='dialog'] button.cta\`, \`.minicart-drawer button[type='submit']\`
-
-5. **EVITE:**
-   - IDs hash-gerados (\`#r-abc123\`)
-   - Tailwind utility classes encadeadas (\`.flex.items-center.bg-blue\`)
-   - Seletores genéricos sem qualificador (\`a[href*=...]\`, \`button[type=submit]\` sozinho)
-   - Seletores que casam o ELEMENTO ERRADO em outra parte do DOM (ex: link de "checkout your reviews" no footer)
-   - Seletores muito profundos (>4 níveis hierárquicos)
-
-6. **Quando incerto, retorne selector="" (string vazia).** É preferível que o flow declare a falha honestamente a chutar um seletor errado que apenas clica em coisa aleatória.
-
-Responda SEMPRE via tool_use suggest_recovery.
+// src/llm/section-understanding.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+var SUMMARIZE_TOOL = {
+  name: "summarize_understanding",
+  description: "Return a single paragraph describing what you understood from the section diff signals. NO code — only diagnosis.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      summary: {
+        type: "string",
+        description: "ONE paragraph (4-6 sentences). Cover: (a) the most visible visual difference, (b) the CSS property most likely responsible, (c) which file/component the user should probably edit. Be concrete — name the property, name the file. NO code blocks. NO patches."
+      }
+    },
+    required: ["summary"]
+  }
+};
+var SYSTEM_PROMPT2 = `
+You are a senior frontend engineer reviewing a migrated e-commerce page
+(Fresh → TanStack Start). The user shows you a Markdown bundle with
+production vs candidate signals for ONE section: heatmap, screenshots,
+computed-style deltas, and an HTML diff.
+
+Your ONLY job in this turn is to confirm what you understood. Do NOT
+write code. Do NOT propose a patch. The user will explicitly ask for
+the patch in a follow-up turn after they sanity-check your reading.
+
+Format: ONE paragraph. Be concrete about which property/rule is the
+likely culprit and which file/component the user should edit. If the
+signals don't agree (e.g. heatmap says diff but computed-styles match),
+say so — that's a useful diagnosis too.
 `.trim();
-async function suggestRecovery(input) {
-  const compacted = compactHtmlForRecovery(input.html);
-  const inp = await callTool({
-    systemPrompt: RECOVERY_SYSTEM_PROMPT,
-    userText: `Step: ${input.stepName}
-Ação desejada: ${input.intendedAction}
-${input.alreadyTried?.length ? `Já tentei (não repita estes): ${input.alreadyTried.join(", ")}
-` : ""}
-HTML compactado da página NESTE momento:
-\`\`\`html
-${compacted}
-\`\`\``,
-    maxTokens: 400,
+function isUnderstandingAvailable() {
+  return isLlmAvailable();
+}
+async function invokeUnderstandingSummary(input) {
+  if (!isLlmAvailable())
+    return null;
+  let markdown;
+  try {
+    markdown = readFileSync8(input.markdownPath, "utf8");
+  } catch (err) {
+    console.error(`[section-understanding] failed to read markdown: ${err.message}`);
+    return null;
+  }
+  const images = [];
+  for (const p of [input.prodScreenshotPath, input.candScreenshotPath, input.heatmapPath]) {
+    if (!p)
+      continue;
+    try {
+      const buf = readFileSync8(p);
+      images.push({ base64: buf.toString("base64"), mediaType: "image/png" });
+    } catch (err) {
+      console.error(`[section-understanding] skipping image ${p}: ${err.message}`);
+    }
+  }
+  const result = await callTool({
+    systemPrompt: SYSTEM_PROMPT2,
+    userText: markdown,
+    userImages: images,
+    maxTokens: 600,
     tool: {
-      name: "suggest_recovery",
-      description: "Suggest a selector and action to recover a failed E2E step",
-      inputSchema: RECOVER_STEP_INPUT_SCHEMA
+      name: SUMMARIZE_TOOL.name,
+      description: SUMMARIZE_TOOL.description,
+      inputSchema: SUMMARIZE_TOOL.inputSchema
     }
   });
-  if (inp?.selector?.trim() && inp.action) {
-    return {
-      selector: inp.selector.trim(),
-      action: inp.action,
-      value: inp.value,
-      reasoning: inp.reasoning
-    };
-  }
-  return null;
+  if (!result?.summary)
+    return null;
+  return { summary: result.summary.trim() };
 }
 
-// src/learned/repo.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname } from "node:path";
-import { z as z2 } from "zod";
-var SelectorKey = z2.enum([
-  "categoryLink",
-  "productCard",
-  "buyButton",
-  "minicartTrigger",
-  "cepInputPdp",
-  "cepInputCart",
-  "checkoutButton",
-  "sizeSwatch",
-  "colorSwatch",
-  "variantRow",
-  "quantityIncrement",
-  "quantityInput",
-  "minicartCount"
-]);
-var SelectorEntry = z2.object({
-  selector: z2.string(),
-  confirmedHosts: z2.array(z2.string()),
-  successRate: z2.number().min(0).max(1),
-  totalAttempts: z2.number().int().nonnegative(),
-  lastValidated: z2.string(),
-  deprecated: z2.boolean().optional()
-});
-var LearnedSelectors = z2.object({
-  schemaVersion: z2.literal("0.1"),
-  platforms: z2.record(z2.string(), z2.record(SelectorKey, z2.array(SelectorEntry)))
-});
-var DEFAULT_PATH = "learned-selectors.json";
-function emptyLib() {
-  return { schemaVersion: "0.1", platforms: {} };
+// src/commands/section.ts
+async function sectionCommand(opts) {
+  const viewport = parseViewport4(opts.viewport);
+  if (!viewport) {
+    console.error(chalk10.red(`viewport inválido: ${opts.viewport} (use mobile|desktop|tablet)`));
+    return 2;
+  }
+  const waitMs = Number.parseInt(opts.wait, 10);
+  if (!Number.isFinite(waitMs) || waitMs < 0) {
+    console.error(chalk10.red(`--wait inválido: ${opts.wait}`));
+    return 2;
+  }
+  if (!opts.selector || opts.selector.trim().length === 0) {
+    console.error(chalk10.red("--selector é obrigatório"));
+    return 2;
+  }
+  if (!isValidUrl2(opts.prod) || !isValidUrl2(opts.cand)) {
+    console.error(chalk10.red("--prod ou --cand inválido"));
+    return 2;
+  }
+  const facetsAsked = Boolean(opts.outputHtml) || Boolean(opts.screenshot) || Boolean(opts.computedStyles);
+  const want = {
+    html: facetsAsked ? Boolean(opts.outputHtml) : true,
+    screenshot: facetsAsked ? Boolean(opts.screenshot) : true,
+    styles: facetsAsked ? Boolean(opts.computedStyles) : true,
+    heatmap: Boolean(opts.heatmap),
+    cssSource: Boolean(opts.cssSource),
+    prompt: Boolean(opts.prompt) || Boolean(opts.llmSummary),
+    llmSummary: Boolean(opts.llmSummary)
+  };
+  if (want.heatmap)
+    want.screenshot = true;
+  mkdirSync4(opts.outDir, { recursive: true });
+  const hash2 = hashSelector(opts.selector);
+  const filePrefix = `section-${hash2}-${viewport}`;
+  const screenshotPaths = {
+    prod: resolve(opts.outDir, `${filePrefix}-prod.png`),
+    cand: resolve(opts.outDir, `${filePrefix}-cand.png`)
+  };
+  const heatmapPath = resolve(opts.outDir, `${filePrefix}-heatmap.png`);
+  const browser = await launchBrowser({ headless: true });
+  try {
+    const [prodSide, candSide] = await Promise.all([
+      gatherSide(browser, {
+        url: opts.prod,
+        viewport,
+        waitMs,
+        selector: opts.selector,
+        wantScreenshot: want.screenshot,
+        wantStyles: want.styles,
+        wantHtml: want.html,
+        wantCssSource: want.cssSource,
+        screenshotPath: screenshotPaths.prod
+      }),
+      gatherSide(browser, {
+        url: opts.cand,
+        viewport,
+        waitMs,
+        selector: opts.selector,
+        wantScreenshot: want.screenshot,
+        wantStyles: want.styles,
+        wantHtml: want.html,
+        wantCssSource: want.cssSource,
+        screenshotPath: screenshotPaths.cand
+      })
+    ]);
+    const heatmap = want.heatmap ? computeHeatmap(prodSide, candSide, screenshotPaths, heatmapPath) : null;
+    const bundlePaths = want.prompt ? await buildPromptBundle({
+      opts,
+      viewport,
+      prodSide,
+      candSide,
+      screenshotPaths,
+      heatmapPath: heatmap?.wrote ? heatmapPath : undefined,
+      heatmap: heatmap?.analysis ?? undefined,
+      filePrefix
+    }) : null;
+    let llmSummary = null;
+    if (want.llmSummary && bundlePaths) {
+      llmSummary = await maybeRunLlmSummary({
+        markdownPath: bundlePaths.markdownPath,
+        screenshotPaths,
+        heatmapPath: heatmap?.wrote ? heatmapPath : undefined
+      });
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        prod: opts.prod,
+        cand: opts.cand,
+        selector: opts.selector,
+        viewport,
+        prodSide,
+        candSide,
+        screenshotPaths: want.screenshot ? screenshotPaths : null,
+        heatmap: heatmap?.analysis ?? null,
+        heatmapPath: heatmap?.wrote ? heatmapPath : null,
+        bundle: bundlePaths,
+        llmSummary
+      }));
+      return verdict(prodSide, candSide);
+    }
+    await printResults2({ opts, viewport, prodSide, candSide, screenshotPaths, want });
+    if (heatmap)
+      printHeatmap(heatmap, heatmapPath);
+    if (bundlePaths)
+      printBundlePaths(bundlePaths);
+    if (llmSummary)
+      printLlmSummary(llmSummary);
+    return verdict(prodSide, candSide);
+  } finally {
+    await browser.close().catch(() => {
+      return;
+    });
+  }
 }
-function loadLearned(path = DEFAULT_PATH) {
-  if (!existsSync6(path))
-    return emptyLib();
+async function gatherSide(browser, opts) {
+  const ctx = await newContext(browser, { viewport: opts.viewport });
+  const page = await ctx.newPage();
+  const result = {
+    html: null,
+    styles: null,
+    screenshotTaken: false
+  };
   try {
-    const raw = JSON.parse(readFileSync7(path, "utf8"));
-    return LearnedSelectors.parse(raw);
+    await page.goto(opts.url, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await page.waitForLoadState("networkidle", { timeout: 8000 }).catch(() => {
+      return;
+    });
+    if (opts.waitMs > 0)
+      await page.waitForTimeout(opts.waitMs);
+    await Promise.race([
+      stabilizeCarousels(page).catch(() => {
+        return;
+      }),
+      new Promise((resolve2) => setTimeout(resolve2, 3000))
+    ]);
+    if (opts.wantHtml) {
+      try {
+        const fullHtml = await page.content();
+        const $ = cheerio5.load(fullHtml);
+        const matches = $(opts.selector);
+        if (matches.length === 0) {
+          result.htmlError = `seletor '${opts.selector}' não casou nenhum elemento`;
+        } else {
+          result.html = $.html(matches.first());
+        }
+      } catch (err) {
+        result.htmlError = `falha lendo HTML: ${err.message}`;
+      }
+    }
+    if (opts.wantStyles) {
+      result.styles = await readComputedStyles(page, opts.selector);
+    }
+    if (opts.wantCssSource) {
+      try {
+        const trace = await traceLoadedPage(page, opts.url, opts.selector);
+        if (trace.found) {
+          result.cssSources = resolveFromTrace(trace, SECTION_STYLE_KEYS);
+        } else {
+          result.cssSourceError = `tracePage não encontrou '${opts.selector}'`;
+        }
+      } catch (err) {
+        result.cssSourceError = `tracePage falhou: ${err.message}`;
+      }
+    }
+    if (opts.wantScreenshot) {
+      await captureSectionScreenshot(page, opts.selector, opts.screenshotPath).then((err) => {
+        if (err)
+          result.screenshotError = err;
+        else
+          result.screenshotTaken = true;
+      });
+    }
+  } finally {
+    await page.close().catch(() => {
+      return;
+    });
+    await ctx.close().catch(() => {
+      return;
+    });
+  }
+  return result;
+}
+async function captureSectionScreenshot(page, selector, outPath) {
+  try {
+    const loc = page.locator(selector).first();
+    if (await loc.count() === 0) {
+      return `seletor '${selector}' não casou nenhum elemento`;
+    }
+    await loc.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {
+      return;
+    });
+    await loc.screenshot({ path: outPath, timeout: 8000 });
+    return null;
   } catch (err) {
-    console.warn(`[learned] failed to parse ${path}: ${err.message}, starting fresh`);
-    return emptyLib();
+    return `falha no screenshot: ${err.message}`;
   }
 }
-function saveLearned(lib, path = DEFAULT_PATH) {
-  const dir = dirname(path);
-  if (dir && dir !== "." && !existsSync6(dir))
-    mkdirSync4(dir, { recursive: true });
-  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync6(tmp, `${JSON.stringify(lib, null, 2)}
-`, "utf8");
-  renameSync(tmp, path);
+function isValidUrl2(s) {
+  try {
+    new URL(s);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function getLearnedSelectors(lib, platform, key) {
-  const platformEntries = lib.platforms[platform];
-  if (!platformEntries)
-    return [];
-  const entries = platformEntries[key] ?? [];
-  return entries.filter((e) => !e.deprecated).sort((a, b) => b.successRate - a.successRate);
+function parseViewport4(raw) {
+  if (raw === "mobile" || raw === "desktop" || raw === "tablet")
+    return raw;
+  return null;
 }
-function ensureSlot(lib, platform, key) {
-  if (!lib.platforms[platform])
-    lib.platforms[platform] = {};
-  const platformEntries = lib.platforms[platform];
-  if (!platformEntries[key])
-    platformEntries[key] = [];
-  return platformEntries[key];
+function hashSelector(selector) {
+  let h = 0;
+  for (let i = 0;i < selector.length; i++) {
+    h = (h << 5) - h + selector.charCodeAt(i);
+    h |= 0;
+  }
+  return (h >>> 0).toString(16).padStart(8, "0").slice(0, 8);
 }
-function recordSuccess(lib, platform, key, selector, host) {
-  const list = ensureSlot(lib, platform, key);
-  let entry = list.find((e) => e.selector === selector);
-  if (!entry) {
-    entry = {
-      selector,
-      confirmedHosts: [host],
-      successRate: 1,
-      totalAttempts: 1,
-      lastValidated: new Date().toISOString()
+function verdict(prod, cand) {
+  if (prod.htmlError || cand.htmlError)
+    return 1;
+  if (prod.styles && "found" in prod.styles && cand.styles && "found" in cand.styles) {
+    if (prod.styles.found && cand.styles.found) {
+      for (const k of SECTION_STYLE_KEYS) {
+        if (prod.styles.styles[k] !== cand.styles.styles[k])
+          return 1;
+      }
+      if (prod.styles.hiddenByPlaywright !== cand.styles.hiddenByPlaywright)
+        return 1;
+      const pr = prod.styles.rect;
+      const cr = cand.styles.rect;
+      if (pr && cr && (pr.width !== cr.width || pr.height !== cr.height))
+        return 1;
+    } else if (prod.styles.found !== cand.styles.found) {
+      return 1;
+    }
+  }
+  if (prod.html && cand.html) {
+    if (prod.html !== cand.html)
+      return 1;
+  }
+  return 0;
+}
+async function printResults2(args) {
+  const { opts, viewport, prodSide, candSide, screenshotPaths, want } = args;
+  console.log(chalk10.bold(`
+  parity section`));
+  console.log(chalk10.dim(`  selector: ${opts.selector}`));
+  console.log(chalk10.dim(`  viewport: ${viewport}`));
+  console.log(chalk10.dim(`  prod:     ${opts.prod}`));
+  console.log(chalk10.dim(`  cand:     ${opts.cand}`));
+  console.log("");
+  if (want.html)
+    await printHtmlDiff(prodSide, candSide, opts.selector);
+  if (want.styles)
+    printStylesDiff(prodSide, candSide);
+  if (want.screenshot)
+    printScreenshotPaths(prodSide, candSide, screenshotPaths);
+}
+async function printHtmlDiff(prod, cand, selector) {
+  console.log(chalk10.bold("  HTML diff"));
+  if (prod.htmlError) {
+    console.log(chalk10.red(`    prod: ${prod.htmlError}`));
+    return;
+  }
+  if (cand.htmlError) {
+    console.log(chalk10.red(`    cand: ${cand.htmlError}`));
+    return;
+  }
+  if (!prod.html || !cand.html) {
+    console.log(chalk10.dim("    (nenhum lado tem HTML disponível)"));
+    return;
+  }
+  const [prodFmt, candFmt] = await Promise.all([formatHtml(prod.html), formatHtml(cand.html)]);
+  if (prodFmt === candFmt) {
+    console.log(chalk10.green("    ✓ idêntico após pretty-print"));
+    console.log("");
+    return;
+  }
+  const patch = diff2.createPatch(selector, prodFmt, candFmt, "prod", "cand");
+  console.log(colorPatch(patch));
+  console.log("");
+}
+function printStylesDiff(prod, cand) {
+  console.log(chalk10.bold("  Computed styles diff"));
+  if (!prod.styles || !cand.styles) {
+    console.log(chalk10.dim("    (styles não foram coletados)"));
+    return;
+  }
+  if (!prod.styles.found) {
+    console.log(chalk10.red(`    prod: ${prod.styles.error}`));
+    return;
+  }
+  if (!cand.styles.found) {
+    console.log(chalk10.red(`    cand: ${cand.styles.error}`));
+    return;
+  }
+  const rows = [];
+  for (const k of SECTION_STYLE_KEYS) {
+    const p = prod.styles.styles[k] ?? "";
+    const c = cand.styles.styles[k] ?? "";
+    if (p !== c)
+      rows.push({ key: k, prod: p, cand: c });
+  }
+  if (prod.styles.hiddenByPlaywright !== cand.styles.hiddenByPlaywright) {
+    rows.unshift({
+      key: "(playwright isVisible)",
+      prod: prod.styles.hiddenByPlaywright ? "hidden" : "visible",
+      cand: cand.styles.hiddenByPlaywright ? "hidden" : "visible"
+    });
+  }
+  const prodRect = prod.styles.rect;
+  const candRect = cand.styles.rect;
+  if (prodRect && candRect && (prodRect.width !== candRect.width || prodRect.height !== candRect.height)) {
+    rows.unshift({
+      key: "(boundingRect)",
+      prod: `${prodRect.width}×${prodRect.height} @ ${prodRect.x},${prodRect.y}`,
+      cand: `${candRect.width}×${candRect.height} @ ${candRect.x},${candRect.y}`
+    });
+  }
+  if (rows.length === 0) {
+    console.log(chalk10.green("    ✓ todos os SECTION_STYLE_KEYS são iguais"));
+    console.log("");
+    return;
+  }
+  const keyWidth = Math.max(...rows.map((r) => r.key.length));
+  for (const r of rows) {
+    console.log(`    ${chalk10.cyan(r.key.padEnd(keyWidth))}  ${chalk10.red(`prod=${r.prod || "(vazio)"}`)}  ${chalk10.green(`cand=${r.cand || "(vazio)"}`)}`);
+  }
+  console.log("");
+}
+function printScreenshotPaths(prod, cand, paths) {
+  console.log(chalk10.bold("  Screenshots"));
+  if (prod.screenshotError) {
+    console.log(chalk10.red(`    prod: ${prod.screenshotError}`));
+  } else if (prod.screenshotTaken) {
+    console.log(`    prod: ${chalk10.dim(paths.prod)}`);
+  }
+  if (cand.screenshotError) {
+    console.log(chalk10.red(`    cand: ${cand.screenshotError}`));
+  } else if (cand.screenshotTaken) {
+    console.log(`    cand: ${chalk10.dim(paths.cand)}`);
+  }
+  console.log("");
+}
+async function formatHtml(raw) {
+  try {
+    return await prettier2.format(raw, {
+      parser: "html",
+      printWidth: 100,
+      htmlWhitespaceSensitivity: "ignore"
+    });
+  } catch {
+    return raw;
+  }
+}
+function colorPatch(patch) {
+  const lines = patch.split(`
+`);
+  const out = [];
+  for (const line of lines) {
+    if (line.startsWith("Index:") || line.startsWith("==="))
+      continue;
+    if (line.startsWith("---") || line.startsWith("+++"))
+      out.push(chalk10.dim(line));
+    else if (line.startsWith("@@"))
+      out.push(chalk10.cyan(line));
+    else if (line.startsWith("+"))
+      out.push(chalk10.green(line));
+    else if (line.startsWith("-"))
+      out.push(chalk10.red(line));
+    else
+      out.push(line);
+  }
+  return out.join(`
+`);
+}
+function computeHeatmap(prod, cand, paths, heatmapPath) {
+  if (!prod.screenshotTaken || !cand.screenshotTaken) {
+    return {
+      wrote: false,
+      analysis: null,
+      error: "heatmap pulado: um dos screenshots falhou"
     };
-    list.push(entry);
-    return entry;
   }
-  const successes = entry.successRate * entry.totalAttempts + 1;
-  entry.totalAttempts += 1;
-  entry.successRate = successes / entry.totalAttempts;
-  if (!entry.confirmedHosts.includes(host))
-    entry.confirmedHosts.push(host);
-  entry.lastValidated = new Date().toISOString();
-  if (entry.deprecated && entry.successRate > 0.5)
-    entry.deprecated = undefined;
-  return entry;
+  try {
+    diffScreenshots(paths.prod, paths.cand, heatmapPath, { maxPctDiff: 1 });
+    const analysis = analyzeHeatmapRegions(heatmapPath);
+    return { wrote: true, analysis };
+  } catch (err) {
+    return { wrote: false, analysis: null, error: err.message };
+  }
+}
+async function buildPromptBundle(args) {
+  const { opts, viewport, prodSide, candSide, screenshotPaths, heatmapPath, heatmap, filePrefix } = args;
+  let htmlBundle;
+  if (prodSide.html && candSide.html) {
+    const [pFmt, cFmt] = await Promise.all([formatHtml(prodSide.html), formatHtml(candSide.html)]);
+    htmlBundle = {
+      prod: pFmt,
+      cand: cFmt,
+      diffPatch: diff2.createPatch(opts.selector, pFmt, cFmt, "prod", "cand")
+    };
+  }
+  const computedStyles = prodSide.styles && candSide.styles ? { prod: prodSide.styles, cand: candSide.styles } : undefined;
+  const cssSources = prodSide.cssSources && candSide.cssSources ? { prod: prodSide.cssSources, cand: candSide.cssSources } : undefined;
+  const screenshots = prodSide.screenshotTaken && candSide.screenshotTaken ? {
+    prodPath: screenshotPaths.prod,
+    candPath: screenshotPaths.cand,
+    heatmapPath
+  } : undefined;
+  return assembleSectionDiffBundle({
+    selector: opts.selector,
+    pageKey: `${new URL(opts.prod).pathname}::${viewport}`,
+    viewport,
+    prodUrl: opts.prod,
+    candUrl: opts.cand,
+    html: htmlBundle,
+    screenshots,
+    heatmap,
+    computedStyles,
+    cssSources,
+    outDir: opts.outDir,
+    filePrefix
+  });
 }
-function recordFailure(lib, platform, key, selector, host) {
-  const list = ensureSlot(lib, platform, key);
-  const entry = list.find((e) => e.selector === selector);
-  if (!entry)
+async function maybeRunLlmSummary(args) {
+  if (!isUnderstandingAvailable()) {
+    console.warn(chalk10.yellow("  --llm-summary pulado: nenhum ANTHROPIC_API_KEY ou OPENROUTER_API_KEY configurado."));
     return null;
-  const successes = entry.successRate * entry.totalAttempts;
-  entry.totalAttempts += 1;
-  entry.successRate = successes / entry.totalAttempts;
-  if (entry.successRate < 0.3 && entry.totalAttempts >= 3) {
-    entry.deprecated = true;
   }
-  entry.lastValidated = new Date().toISOString();
-  return entry;
-}
-function promoteFromLlm(lib, platform, key, selector, host) {
-  const list = ensureSlot(lib, platform, key);
-  const existing = list.find((e) => e.selector === selector);
-  if (existing)
-    return recordSuccess(lib, platform, key, selector, host);
-  const entry = {
-    selector,
-    confirmedHosts: [host],
-    successRate: 0.5,
-    totalAttempts: 1,
-    lastValidated: new Date().toISOString()
-  };
-  list.push(entry);
-  return entry;
+  const result = await invokeUnderstandingSummary({
+    markdownPath: args.markdownPath,
+    prodScreenshotPath: args.screenshotPaths.prod,
+    candScreenshotPath: args.screenshotPaths.cand,
+    heatmapPath: args.heatmapPath
+  });
+  return result?.summary ?? null;
 }
-function statsFromLib(lib) {
-  const out = { platforms: [] };
-  for (const [platform, byKey] of Object.entries(lib.platforms)) {
-    let totalSelectors = 0;
-    let deprecated = 0;
-    const topByKey = [];
-    for (const [key, entries] of Object.entries(byKey)) {
-      for (const e of entries) {
-        totalSelectors += 1;
-        if (e.deprecated)
-          deprecated += 1;
-      }
-      const top = entries.filter((e) => !e.deprecated).sort((a, b) => b.successRate - a.successRate)[0];
-      if (top) {
-        topByKey.push({
-          key,
-          selector: top.selector,
-          successRate: top.successRate,
-          hosts: top.confirmedHosts.length
-        });
-      }
+function printHeatmap(state, heatmapPath) {
+  console.log(chalk10.bold("  Heatmap"));
+  if (state.error) {
+    console.log(chalk10.yellow(`    ${state.error}`));
+    console.log("");
+    return;
+  }
+  if (!state.analysis) {
+    console.log(chalk10.dim("    (sem dados de heatmap)"));
+    console.log("");
+    return;
+  }
+  const a = state.analysis;
+  const pct = (a.pctDiff * 100).toFixed(2);
+  console.log(`    ${chalk10.cyan("diffPixels")}: ${a.diffPixels} (${pct}%)`);
+  if (a.boundingBox) {
+    const bb = a.boundingBox;
+    console.log(`    ${chalk10.cyan("boundingBox")}: x=${bb.x} y=${bb.y} w=${bb.width} h=${bb.height}`);
+  }
+  if (a.hotspots.length > 0) {
+    console.log(`    ${chalk10.cyan("hotspots")}:`);
+    for (const h of a.hotspots.slice(0, 5)) {
+      console.log(`      (${h.x}, ${h.y}) ${h.width}×${h.height} — ${h.pixelCount} px`);
     }
-    out.platforms.push({
-      platform,
-      totalSelectors,
-      activeSelectors: totalSelectors - deprecated,
-      deprecatedSelectors: deprecated,
-      topByKey
-    });
   }
-  return out;
+  console.log(`    ${chalk10.dim(`heatmap: ${heatmapPath}`)}`);
+  console.log("");
 }
-var LEARNED_PATH = DEFAULT_PATH;
-
-// src/engine/selectors.ts
-var DEFAULT_SELECTORS = {
-  categoryLink: [
-    "header nav a[href*='/c/']",
-    "header nav a[href*='/category/']",
-    "header nav a[href*='/collections/']",
-    "[data-mega-menu] a[href*='/c/']",
-    "header a[href]:not([href='/']):not([href='#']):not([href*='login']):not([href*='cart'])"
-  ],
-  productCard: [
-    "[data-product-card] a",
-    "[data-deco='view-product'] a",
-    "[data-testid='product-card'] a",
-    ".product-card a",
-    "article a[href*='/p/']",
-    "a[href*='/products/']"
-  ],
-  buyButton: [
-    "button:has-text('Comprar')",
-    "button:has-text('Adicionar')",
-    "button:has-text('Add to cart')",
-    "button:has-text('Add to bag')",
-    "[data-buy-button]",
-    "[data-testid='add-to-cart']",
-    "button[type='submit']:has-text('Comprar')"
-  ],
-  minicartTrigger: [
-    "[data-minicart-trigger]",
-    "[data-testid='minicart-trigger']",
-    "[aria-label*='carrinho' i]",
-    "[aria-label*='cart' i]",
-    "header button:has([data-cart-icon])",
-    "header a[href='/checkout']"
-  ],
-  cepInputPdp: [
-    "input[name='shipping-zipcode']",
-    "input[name='zipcode']",
-    "input[name='cep']",
-    "input[placeholder*='CEP' i]",
-    "input[placeholder*='Postal' i]",
-    "[data-shipping-input] input"
-  ],
-  cepInputCart: [
-    "input[name='cart-zipcode']",
-    "[data-minicart] input[name*='zip' i]",
-    "[data-cart] input[name*='zip' i]",
-    "[role='dialog'] input[name*='cep' i]",
-    "[role='dialog'] input[placeholder*='CEP' i]"
-  ],
-  checkoutButton: [
-    "a:has-text('Finalizar compra')",
-    "button:has-text('Finalizar compra')",
-    "a:has-text('Ir para o checkout')",
-    "button:has-text('Ir para o checkout')",
-    "[role='dialog'] a:has-text('Finalizar')",
-    "[role='dialog'] button:has-text('Finalizar')",
-    "[data-minicart] a:has-text('Finalizar')",
-    "[data-minicart] button:has-text('Finalizar')",
-    "[data-cart-drawer] a:has-text('Finalizar')",
-    "[data-cart-drawer] button:has-text('Finalizar')",
-    "a:has-text('Checkout')",
-    "[data-checkout-button]",
-    "a:text-is('Finalizar')",
-    "button:text-is('Finalizar')"
-  ],
-  sizeSwatch: [
-    "[data-size]:not([disabled]):not([aria-disabled='true']):not(.unavailable):not(.sold-out)",
-    "[data-variant-size]:not([disabled]):not([aria-disabled='true']):not(.unavailable)",
-    "button[aria-label*='tamanho' i]:not([aria-disabled='true']):not([disabled])",
-    "button[aria-label*='size' i]:not([aria-disabled='true']):not([disabled])",
-    "[data-testid='size-selector'] button:not([disabled]):not(.unavailable)",
-    ".size-selector button:not([disabled]):not(.unavailable):not(.sold-out)",
-    "[class*='size'] button:not([disabled]):not(.unavailable)",
-    "label:has(input[name*='size' i]:not([disabled])) "
-  ],
-  colorSwatch: [
-    "[data-color]:not([disabled]):not([aria-disabled='true']):not(.unavailable):not(.sold-out)",
-    "[data-variant-color]:not([disabled]):not([aria-disabled='true']):not(.unavailable)",
-    "button[aria-label*='cor' i]:not([aria-disabled='true']):not([disabled])",
-    "button[aria-label*='color' i]:not([aria-disabled='true']):not([disabled])",
-    "[data-testid='color-selector'] button:not([disabled]):not(.unavailable)",
-    ".color-swatch:not(.unavailable):not(.sold-out)",
-    "[class*='color'] button:not([disabled]):not(.unavailable)"
-  ],
-  variantRow: [
-    "[data-sku-row]",
-    "[data-variant-row]",
-    "tr[data-variant]",
-    "tr:has([aria-label*='quantidade' i])",
-    "tbody tr:has(input[type='number'])"
-  ],
-  quantityIncrement: [
-    "[data-qty-plus]",
-    "[data-quantity-plus]",
-    "button[aria-label*='aumentar' i]",
-    "button[aria-label*='increase' i]",
-    "button[aria-label*='increment' i]",
-    "button:has-text('+')",
-    "[class*='qty'] button:has-text('+')"
-  ],
-  quantityInput: [
-    "input[type='number'][min='0'][value='0']",
-    "input[id*='quantity-input' i]",
-    "input[name*='qty' i]",
-    "input[name*='quantity' i]",
-    "input[name*='quantidade' i]",
-    "input[aria-label*='quantidade' i]",
-    "[data-qty-input]",
-    "input[type='number'][min='0']",
-    "input[type='number'][min='1']"
-  ],
-  minicartCount: [
-    "[data-minicart-count]",
-    "[data-cart-count]",
-    ".cart-count",
-    ".minicart__count",
-    "[class*='cart-count']",
-    "[class*='CartCount']",
-    "[aria-label*='itens' i][role='status']",
-    "header [data-minicart-trigger] [class*='badge']",
-    "header [aria-label*='cart' i] [class*='count']",
-    "header [aria-label*='sacola' i] [class*='badge']",
-    "header [aria-label*='sacola' i] [class*='count']",
-    "header a[href*='/cart'] [class*='count']",
-    "header a[href*='/checkout'] [class*='count']",
-    "[data-fs-cart-icon] + [class*='count']",
-    "[class*='Minicart'] [class*='count']",
-    "[class*='minicart'] [class*='count']"
-  ]
-};
-function selectorsFor(key, ctxOrRc = {}) {
-  const ctx = isResolutionContext(ctxOrRc) ? ctxOrRc : { rc: ctxOrRc };
-  const out = [];
-  const override = ctx.rc?.selectors?.[key];
-  if (override)
-    out.push(override);
-  if (ctx.learned && ctx.platform) {
-    for (const entry of getLearnedSelectors(ctx.learned, ctx.platform, key)) {
-      out.push(entry.selector);
-    }
-  }
-  out.push(...DEFAULT_SELECTORS[key]);
-  return [...new Set(out)];
+function printBundlePaths(b) {
+  console.log(chalk10.bold("  Bundle"));
+  console.log(`    ${chalk10.cyan("summary")}: ${b.summary}`);
+  console.log(`    ${chalk10.cyan("json")}:    ${chalk10.dim(b.jsonPath)}`);
+  console.log(`    ${chalk10.cyan("prompt")}:  ${chalk10.dim(b.markdownPath)}`);
+  console.log("");
 }
-function isResolutionContext(v) {
-  if (!v || typeof v !== "object")
-    return false;
-  const k = Object.keys(v);
-  return k.length === 0 || k.some((x) => x === "rc" || x === "learned" || x === "platform");
+function printLlmSummary(summary) {
+  console.log(chalk10.bold("  What the LLM understood"));
+  console.log(`    ${summary.split(`
+`).join(`
+    `)}`);
+  console.log("");
 }
 
-// src/engine/flows.ts
-async function screenshotStable(page, opts) {
-  await Promise.race([
-    stabilizeCarousels(page).catch(() => {
-      return;
-    }),
-    new Promise((resolve) => setTimeout(resolve, 3000))
-  ]);
-  await page.screenshot({ path: opts.path, fullPage: opts.fullPage ?? false }).catch(() => {
-    return;
-  });
-}
-var PURCHASE_JOURNEY_TOTAL_STEPS = 9;
-var DEBUG_PARITY2 = process.env.DEBUG_PARITY === "1" || process.env.DEBUG_PARITY === "true";
-var DEBUG_START2 = Date.now();
-function dlog2(ctx, msg) {
-  if (!DEBUG_PARITY2)
-    return;
-  const elapsed = ((Date.now() - DEBUG_START2) / 1000).toFixed(1);
-  process.stderr.write(`[+${elapsed}s ${ctx.viewport}/${ctx.side}] ${msg}
-`);
-}
-function withCap(p, capMs, fallback) {
-  return Promise.race([
-    p.catch(() => fallback),
-    new Promise((resolve) => setTimeout(() => resolve(fallback), capMs))
-  ]);
+// src/commands/fix.ts
+async function fixCommand(opts) {
+  const sectionOpts = {
+    prod: opts.prod,
+    cand: opts.cand,
+    selector: opts.selector,
+    viewport: opts.viewport,
+    wait: opts.wait,
+    outDir: opts.outDir,
+    json: opts.json,
+    outputHtml: true,
+    screenshot: true,
+    computedStyles: true,
+    heatmap: true,
+    cssSource: true,
+    prompt: true,
+    llmSummary: !opts.noLlm
+  };
+  return sectionCommand(sectionOpts);
 }
-var VARIANT_REQUIRED_TEXT_PATTERNS = [
-  /selecione um produto/i,
-  /selecione um tamanho/i,
-  /selecione uma cor/i,
-  /selecione uma op[cç][aã]o/i,
-  /select a size/i,
-  /select a color/i,
-  /select an option/i,
-  /choose an option/i,
-  /please select/i,
-  /select size/i,
-  /select color/i
-];
-var ADD_TO_CART_ERROR_PATTERNS = [
-  ...VARIANT_REQUIRED_TEXT_PATTERNS,
-  /estoque esgotado/i,
-  /out of stock/i,
-  /indispon[ií]vel/i,
-  /unavailable/i
-];
-var ADD_TO_CART_SUCCESS_PATTERNS = [
-  /produto adicionado/i,
-  /adicionado ao carrinho/i,
-  /adicionado [aà]\s+sacola/i,
-  /added to cart/i,
-  /added to bag/i,
-  /item added/i,
-  /successfully added/i
+
+// src/commands/journey.ts
+import { writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join11 } from "node:path";
+import chalk11 from "chalk";
+import ora3 from "ora";
+
+// src/llm/pick-plp.ts
+var PATH_BLOCKLIST = [
+  "/atendimento",
+  "/lojas",
+  "/empresa",
+  "/sobre",
+  "/blog",
+  "/vale-presente",
+  "/contato",
+  "/ajuda",
+  "/trabalhe-conosco",
+  "/imprensa",
+  "/institucional",
+  "/privacidade",
+  "/termos",
+  "/quem-somos",
+  "/loja-fisica",
+  "/franquia"
 ];
-function selFor(ctx, key) {
-  return selectorsFor(key, { rc: ctx.rc, learned: ctx.learned, platform: ctx.platform });
+async function pickCategoryLink(candidates) {
+  if (candidates.length === 0)
+    return null;
+  if (candidates.length === 1)
+    return candidates[0];
+  const filtered = candidates.filter((c) => !isBlocked(c.href));
+  if (filtered.length === 0)
+    return candidates[0] ?? null;
+  if (filtered.length === 1)
+    return filtered[0];
+  const strong = filtered.filter((c) => /\/c\/|\/category\/|\/collections\//.test(c.href));
+  if (strong.length === 1)
+    return strong[0];
+  if (strong.length > 0 && strong.length < filtered.length) {
+    return await llmPick(strong) ?? strong[0];
+  }
+  return await llmPick(filtered) ?? filtered[0];
 }
-var FLOW_DEADLINE_MS = {
-  homepage: 90000,
-  plp: 180000,
-  pdp: 240000,
-  "purchase-journey": 420000
-};
-async function runFlow(flow, ctx) {
-  const start = Date.now();
-  const deadlineMs = FLOW_DEADLINE_MS[flow];
-  const inner = async () => {
-    switch (flow) {
-      case "homepage":
-        return finalize(flow, ctx, await flowHomepage(ctx), [], start);
-      case "plp":
-        return finalize(flow, ctx, await flowPlp(ctx), [], start);
-      case "pdp":
-        return finalize(flow, ctx, await flowPdp(ctx), [], start);
-      case "purchase-journey": {
-        const { pages, steps } = await flowPurchaseJourney(ctx);
-        return finalize(flow, ctx, pages, steps, start);
+function isBlocked(href) {
+  try {
+    const path = new URL(href, "http://placeholder.invalid").pathname.toLowerCase();
+    return PATH_BLOCKLIST.some((b) => path.startsWith(b));
+  } catch {
+    return false;
+  }
+}
+async function llmPick(candidates) {
+  const input = await callTool({
+    systemPrompt: "Você escolhe links de categoria reais em sites de e-commerce. Categoria real = página que lista produtos à venda. Evite: institucional, atendimento, blog, vale-presente, lojas físicas. Prefira URLs com /c/, /category/, /collections/ ou claramente vinculadas a tipos de produto.",
+    userText: `Candidatos:
+${candidates.map((c, i) => `${i}. "${c.text}" → ${c.href}`).join(`
+`)}`,
+    maxTokens: 200,
+    tool: {
+      name: "pick_category",
+      description: "Pick the index of the best category link",
+      inputSchema: {
+        type: "object",
+        properties: {
+          index: { type: "number", description: "Index in the input list (0-based)" },
+          reasoning: { type: "string", description: "1 sentence rationale" }
+        },
+        required: ["index"]
       }
     }
-  };
-  const innerPromise = inner();
-  innerPromise.catch(() => {
-    return;
-  });
-  let timer;
-  let cleanup = Promise.resolve();
-  const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      const pages = ctx.ctx.pages();
-      resolve(finalize(flow, ctx, [], [
-        {
-          step: 0,
-          name: "flow-timeout",
-          side: ctx.side,
-          viewport: ctx.viewport,
-          status: "failed",
-          durationMs: deadlineMs,
-          screenshotPath: "",
-          actionDescription: `[flow-timeout] flow "${flow}" excedeu ${deadlineMs}ms — captura abortada pela safety net externa, ${pages.length} page(s) fechada(s) para liberar o contexto.`
-        }
-      ], start));
-      const CLOSE_CAP_MS = 5000;
-      const cappedClose = (p) => Promise.race([
-        p.close().catch(() => {
-          return;
-        }),
-        new Promise((resolveClose) => setTimeout(resolveClose, CLOSE_CAP_MS))
-      ]);
-      cleanup = Promise.allSettled(pages.map(cappedClose));
-    }, deadlineMs);
   });
-  try {
-    const result = await Promise.race([innerPromise, timeoutPromise]);
-    await cleanup;
-    return result;
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
+  const idx = input?.index;
+  if (typeof idx === "number" && idx >= 0 && idx < candidates.length) {
+    return candidates[idx];
   }
+  return null;
 }
-function finalize(flow, ctx, pages, steps, start) {
-  return {
-    flow,
-    side: ctx.side,
-    viewport: ctx.viewport,
-    pages,
-    steps,
-    totalDurationMs: Date.now() - start
-  };
-}
-function screenshotPath(ctx, label) {
-  const safe = label.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
-  return `${ctx.outDir}/${safe}-${ctx.viewport}-${ctx.side}.png`;
-}
-async function flowHomepage(ctx) {
-  const page = await ctx.ctx.newPage();
+
+// src/llm/recover-step.ts
+import * as cheerio6 from "cheerio";
+var RECOVER_STEP_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    selector: { type: "string", description: "CSS or Playwright selector that targets the element" },
+    action: { type: "string", enum: ["click", "fill", "press"] },
+    value: { type: "string", description: "For 'fill' or 'press', the text/key to use" },
+    reasoning: { type: "string" }
+  },
+  required: ["selector", "action"]
+};
+function compactHtmlForRecovery(html, maxChars = 12000) {
   try {
-    const cap = await capturePage(page, {
-      url: ctx.baseUrl,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "home")
-    });
-    return [cap];
-  } finally {
-    await page.close();
+    const $ = cheerio6.load(html);
+    $("script, style, noscript, svg, picture source, link, meta").remove();
+    const allowed = $("header, nav, main, footer, dialog, [role='dialog'], form, button, a, input, [data-buy-button], [data-checkout], [data-minicart], [role='button']").map((_, el) => $.html(el)).get().join(`
+`);
+    const truncated = allowed.length > maxChars ? `${allowed.slice(0, maxChars)}
+<!-- TRUNCATED -->` : allowed;
+    return truncated;
+  } catch {
+    return html.slice(0, maxChars);
   }
 }
-async function flowPlp(ctx) {
-  const home = await ctx.ctx.newPage();
-  const homeCap = await capturePage(home, {
-    url: ctx.baseUrl,
-    side: ctx.side,
-    viewport: ctx.viewport,
-    screenshotPath: screenshotPath(ctx, "home")
+var RECOVERY_SYSTEM_PROMPT = `
+Você ajuda a recuperar passos de teste E2E (Playwright) que falharam contra sites de e-commerce.
+
+Receba o nome do step, a ação desejada e o HTML compactado da página ATUAL. Sugira UM seletor + ação ('click' | 'fill' | 'press') que provavelmente funciona NESTE HTML específico.
+
+REGRAS CRÍTICAS:
+
+1. **Baseie no HTML fornecido.** Encontre o elemento literal no markup. Confirme mentalmente que o seletor que você vai retornar casa um elemento VISÍVEL no HTML compactado.
+
+2. **Se o step é 'go-checkout' ou 'go-checkout-retry':**
+   - O alvo é um BOTÃO/LINK CTA com texto visível contendo "Finalizar", "Finalizar compra", "Continuar", "Continuar para pagamento", "Ir para o checkout", "Checkout", "Concluir", "Pagar", "Ir para o pagamento", "Avançar", "Próxima etapa".
+   - **NUNCA** sugira o ícone genérico de carrinho do HEADER (texto curto "0", "1", badge counter, ou aria-label "Carrinho" sozinho). Esse é o gatilho que ABRE o drawer/cart-page, não o que finaliza compra.
+   - **Selectors com href de checkout (\`a[href*="checkout"]\`, \`a[href="/checkout/#/cart?v=1"]\`) PODEM funcionar** mas SOMENTE quando qualificados — ou seja, garanta uma das duas:
+     a. Qualificação por **texto**: \`a[href*="checkout"]:has-text('Finalizar')\`, \`a[href*="checkout"]:has-text('Continuar')\`
+     b. Qualificação por **scope**: \`[role='dialog'] a[href*="checkout"]\`, \`[class*='minicart' i] a[href*="checkout"]\`, \`.cart-drawer a[href*="checkout"]\`
+     Selectors GENÉRICOS sem qualificador (apenas \`a[href*="checkout"]\` sozinho) casam o ícone do header e devem ser EVITADOS.
+   - Se NENHUM elemento com texto/scope plausível existe no HTML, retorne selector="" para sinalizar incerteza honestamente.
+
+3. **Se o step é 'shipping-calc-cart' ou 'shipping-calc-pdp':**
+   - O alvo é um \`<input>\` (não button/link) visível com label/placeholder mencionando "CEP", "Frete", "Calcular", "Entrega", "Zip".
+   - Prefira inputs cujo container/pai está visível (não escondido em accordion fechado).
+
+4. **Seletores preferidos** (nesta ordem):
+   - Text-based Playwright: \`button:has-text('Finalizar')\`, \`a:has-text('Continuar para pagamento')\`
+   - data-attributes específicos: \`[data-checkout-button]\`, \`[data-cart-finalize]\`, \`[data-fs-cart-button]\`
+   - ARIA: \`[aria-label*='finalizar' i]\`, \`[role='button'][aria-label*='checkout' i]\`
+   - Classes específicas de plataforma: \`.vtex-minicart-2-x-checkoutButton\`, \`.fs-cart__checkout\`
+   - Por último, escopo hierárquico curto: \`[role='dialog'] button.cta\`, \`.minicart-drawer button[type='submit']\`
+
+5. **EVITE:**
+   - IDs hash-gerados (\`#r-abc123\`)
+   - Tailwind utility classes encadeadas (\`.flex.items-center.bg-blue\`)
+   - Seletores genéricos sem qualificador (\`a[href*=...]\`, \`button[type=submit]\` sozinho)
+   - Seletores que casam o ELEMENTO ERRADO em outra parte do DOM (ex: link de "checkout your reviews" no footer)
+   - Seletores muito profundos (>4 níveis hierárquicos)
+
+6. **Quando incerto, retorne selector="" (string vazia).** É preferível que o flow declare a falha honestamente a chutar um seletor errado que apenas clica em coisa aleatória.
+
+Responda SEMPRE via tool_use suggest_recovery.
+`.trim();
+async function suggestRecovery(input) {
+  const compacted = compactHtmlForRecovery(input.html);
+  const inp = await callTool({
+    systemPrompt: RECOVERY_SYSTEM_PROMPT,
+    userText: `Step: ${input.stepName}
+Ação desejada: ${input.intendedAction}
+${input.alreadyTried?.length ? `Já tentei (não repita estes): ${input.alreadyTried.join(", ")}
+` : ""}
+HTML compactado da página NESTE momento:
+\`\`\`html
+${compacted}
+\`\`\``,
+    maxTokens: 400,
+    tool: {
+      name: "suggest_recovery",
+      description: "Suggest a selector and action to recover a failed E2E step",
+      inputSchema: RECOVER_STEP_INPUT_SCHEMA
+    }
   });
-  const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(home, ctx);
-  await home.close();
-  if (!plpHit)
-    return [homeCap];
-  const plp = await ctx.ctx.newPage();
-  try {
-    const cap = await capturePage(plp, {
-      url: plpHit.url,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "plp")
-    });
-    return [homeCap, cap];
-  } finally {
-    await plp.close();
-  }
-}
-async function flowPdp(ctx) {
-  const pages = [];
-  const home = await ctx.ctx.newPage();
-  pages.push(await capturePage(home, {
-    url: ctx.baseUrl,
-    side: ctx.side,
-    viewport: ctx.viewport,
-    screenshotPath: screenshotPath(ctx, "home")
-  }));
-  const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(home, ctx);
-  await home.close();
-  if (!plpHit)
-    return pages;
-  const plp = await ctx.ctx.newPage();
-  pages.push(await capturePage(plp, {
-    url: plpHit.url,
-    side: ctx.side,
-    viewport: ctx.viewport,
-    screenshotPath: screenshotPath(ctx, "plp")
-  }));
-  const pdpHit = await findProductUrl(plp, ctx);
-  await plp.close();
-  if (!pdpHit)
-    return pages;
-  const pdp = await ctx.ctx.newPage();
-  try {
-    pages.push(await capturePage(pdp, {
-      url: pdpHit.url,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "pdp")
-    }));
-    return pages;
-  } finally {
-    await pdp.close();
+  if (inp?.selector?.trim() && inp.action) {
+    return {
+      selector: inp.selector.trim(),
+      action: inp.action,
+      value: inp.value,
+      reasoning: inp.reasoning
+    };
   }
+  return null;
 }
-async function flowPurchaseJourney(ctx) {
-  const pages = [];
-  const steps = [];
-  const page = await ctx.ctx.newPage();
-  const budget = { remaining: ctx.recoveryBudget ?? 5 };
-  const total = PURCHASE_JOURNEY_TOTAL_STEPS;
-  const reportStart = (idx, name) => {
-    ctx.onStep?.({ phase: "start", name, index: idx, total });
-  };
-  const reportEnd = (idx, name, status, durationMs, note) => {
-    ctx.onStep?.({ phase: "end", name, index: idx, total, status, durationMs, note });
-  };
+
+// src/learned/repo.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { z as z2 } from "zod";
+var SelectorKey = z2.enum([
+  "categoryLink",
+  "productCard",
+  "buyButton",
+  "minicartTrigger",
+  "cepInputPdp",
+  "cepInputCart",
+  "checkoutButton",
+  "sizeSwatch",
+  "colorSwatch",
+  "variantRow",
+  "quantityIncrement",
+  "quantityInput",
+  "minicartCount"
+]);
+var SelectorEntry = z2.object({
+  selector: z2.string(),
+  confirmedHosts: z2.array(z2.string()),
+  successRate: z2.number().min(0).max(1),
+  totalAttempts: z2.number().int().nonnegative(),
+  lastValidated: z2.string(),
+  deprecated: z2.boolean().optional()
+});
+var LearnedSelectors = z2.object({
+  schemaVersion: z2.literal("0.1"),
+  platforms: z2.record(z2.string(), z2.record(SelectorKey, z2.array(SelectorEntry)))
+});
+var DEFAULT_PATH = "learned-selectors.json";
+function emptyLib() {
+  return { schemaVersion: "0.1", platforms: {} };
+}
+function loadLearned(path = DEFAULT_PATH) {
+  if (!existsSync6(path))
+    return emptyLib();
   try {
-    reportStart(1, "visit-home");
-    const homeCap = await capturePage(page, {
-      url: ctx.baseUrl,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "pj-1-home")
-    });
-    pages.push(homeCap);
-    const step1Status = homeCap.status >= 200 && homeCap.status < 400 ? "ok" : "failed";
-    steps.push({
-      step: 1,
-      name: "visit-home",
-      side: ctx.side,
-      viewport: ctx.viewport,
-      status: step1Status,
-      durationMs: homeCap.durationMs,
-      url: homeCap.finalUrl,
-      screenshotPath: homeCap.screenshotPath
-    });
-    reportEnd(1, "visit-home", step1Status, homeCap.durationMs);
-    steps[steps.length - 1].actionDescription = `Navegou pra home \`${ctx.baseUrl}\` (HTTP ${homeCap.status})`;
-    if (homeCap.status >= 400 || homeCap.status === 0) {
-      return { pages, steps };
-    }
-    reportStart(2, "navigate-plp");
-    const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(page, ctx);
-    if (!plpHit) {
-      steps.push(makeSkipStep(2, "navigate-plp", ctx, "no category link found"));
-      reportEnd(2, "navigate-plp", "skipped", 0, "no category link found");
-      return { pages, steps };
-    }
-    const t2 = Date.now();
-    const plpCap = await capturePage(page, {
-      url: plpHit.url,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "pj-2-plp")
-    });
-    pages.push(plpCap);
-    const step2Status = plpCap.status >= 200 && plpCap.status < 400 ? "ok" : "failed";
-    steps.push({
-      step: 2,
-      name: "navigate-plp",
-      side: ctx.side,
-      viewport: ctx.viewport,
-      status: step2Status,
-      durationMs: Date.now() - t2,
-      url: plpCap.finalUrl,
-      screenshotPath: plpCap.screenshotPath,
-      selectorKey: "categoryLink",
-      usedSelector: plpHit.selector
-    });
-    reportEnd(2, "navigate-plp", step2Status, Date.now() - t2);
-    steps[steps.length - 1].actionDescription = `Navegou pra categoria \`${plpHit.url}\` (via \`${plpHit.selector}\`)`;
-    steps[steps.length - 1].beforeUrl = ctx.baseUrl;
-    reportStart(3, "enter-pdp");
-    let pdpHit = await findProductUrl(page, ctx);
-    let pdpRecoveredByLlm = false;
-    if (!pdpHit && budget.remaining > 0) {
-      const html = await page.content().catch(() => "");
-      if (html) {
-        const suggestion = await suggestRecovery({
-          stepName: "enter-pdp",
-          intendedAction: "Encontrar um link <a> que leve para a página de detalhes (PDP) de algum produto listado na PLP atual",
-          html,
-          alreadyTried: selFor(ctx, "productCard")
+    const raw = JSON.parse(readFileSync9(path, "utf8"));
+    return LearnedSelectors.parse(raw);
+  } catch (err) {
+    console.warn(`[learned] failed to parse ${path}: ${err.message}, starting fresh`);
+    return emptyLib();
+  }
+}
+function saveLearned(lib, path = DEFAULT_PATH) {
+  const dir = dirname2(path);
+  if (dir && dir !== "." && !existsSync6(dir))
+    mkdirSync5(dir, { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync7(tmp, `${JSON.stringify(lib, null, 2)}
+`, "utf8");
+  renameSync(tmp, path);
+}
+function getLearnedSelectors(lib, platform, key) {
+  const platformEntries = lib.platforms[platform];
+  if (!platformEntries)
+    return [];
+  const entries = platformEntries[key] ?? [];
+  return entries.filter((e) => !e.deprecated).sort((a, b) => b.successRate - a.successRate);
+}
+function ensureSlot(lib, platform, key) {
+  if (!lib.platforms[platform])
+    lib.platforms[platform] = {};
+  const platformEntries = lib.platforms[platform];
+  if (!platformEntries[key])
+    platformEntries[key] = [];
+  return platformEntries[key];
+}
+function recordSuccess(lib, platform, key, selector, host) {
+  const list = ensureSlot(lib, platform, key);
+  let entry = list.find((e) => e.selector === selector);
+  if (!entry) {
+    entry = {
+      selector,
+      confirmedHosts: [host],
+      successRate: 1,
+      totalAttempts: 1,
+      lastValidated: new Date().toISOString()
+    };
+    list.push(entry);
+    return entry;
+  }
+  const successes = entry.successRate * entry.totalAttempts + 1;
+  entry.totalAttempts += 1;
+  entry.successRate = successes / entry.totalAttempts;
+  if (!entry.confirmedHosts.includes(host))
+    entry.confirmedHosts.push(host);
+  entry.lastValidated = new Date().toISOString();
+  if (entry.deprecated && entry.successRate > 0.5)
+    entry.deprecated = undefined;
+  return entry;
+}
+function recordFailure(lib, platform, key, selector, host) {
+  const list = ensureSlot(lib, platform, key);
+  const entry = list.find((e) => e.selector === selector);
+  if (!entry)
+    return null;
+  const successes = entry.successRate * entry.totalAttempts;
+  entry.totalAttempts += 1;
+  entry.successRate = successes / entry.totalAttempts;
+  if (entry.successRate < 0.3 && entry.totalAttempts >= 3) {
+    entry.deprecated = true;
+  }
+  entry.lastValidated = new Date().toISOString();
+  return entry;
+}
+function promoteFromLlm(lib, platform, key, selector, host) {
+  const list = ensureSlot(lib, platform, key);
+  const existing = list.find((e) => e.selector === selector);
+  if (existing)
+    return recordSuccess(lib, platform, key, selector, host);
+  const entry = {
+    selector,
+    confirmedHosts: [host],
+    successRate: 0.5,
+    totalAttempts: 1,
+    lastValidated: new Date().toISOString()
+  };
+  list.push(entry);
+  return entry;
+}
+function statsFromLib(lib) {
+  const out = { platforms: [] };
+  for (const [platform, byKey] of Object.entries(lib.platforms)) {
+    let totalSelectors = 0;
+    let deprecated = 0;
+    const topByKey = [];
+    for (const [key, entries] of Object.entries(byKey)) {
+      for (const e of entries) {
+        totalSelectors += 1;
+        if (e.deprecated)
+          deprecated += 1;
+      }
+      const top = entries.filter((e) => !e.deprecated).sort((a, b) => b.successRate - a.successRate)[0];
+      if (top) {
+        topByKey.push({
+          key,
+          selector: top.selector,
+          successRate: top.successRate,
+          hosts: top.confirmedHosts.length
         });
-        if (suggestion) {
-          budget.remaining--;
-          try {
-            const el = page.locator(suggestion.selector).first();
-            if (await el.isVisible({ timeout: 2000 }).catch(() => false)) {
-              const href = await el.getAttribute("href");
-              if (href) {
-                const abs = new URL(href, page.url()).toString();
-                pdpHit = { url: abs, selector: suggestion.selector };
-                pdpRecoveredByLlm = true;
-              }
-            }
-          } catch {}
-        }
       }
     }
-    if (!pdpHit) {
-      steps.push(makeSkipStep(3, "enter-pdp", ctx, "no product card found (recovery exhausted)"));
-      reportEnd(3, "enter-pdp", "skipped", 0, "no product card found");
-      return { pages, steps };
-    }
-    const t3 = Date.now();
-    const pdpCap = await capturePage(page, {
-      url: pdpHit.url,
-      side: ctx.side,
-      viewport: ctx.viewport,
-      screenshotPath: screenshotPath(ctx, "pj-3-pdp")
+    out.platforms.push({
+      platform,
+      totalSelectors,
+      activeSelectors: totalSelectors - deprecated,
+      deprecatedSelectors: deprecated,
+      topByKey
     });
-    pages.push(pdpCap);
-    const step3Status = pdpCap.status >= 200 && pdpCap.status < 400 ? "ok" : "failed";
-    steps.push({
-      step: 3,
-      name: "enter-pdp",
-      side: ctx.side,
-      viewport: ctx.viewport,
-      status: step3Status,
-      durationMs: Date.now() - t3,
-      url: pdpCap.finalUrl,
-      screenshotPath: pdpCap.screenshotPath,
-      selectorKey: "productCard",
+  }
+  return out;
+}
+var LEARNED_PATH = DEFAULT_PATH;
+
+// src/engine/selectors.ts
+var DEFAULT_SELECTORS = {
+  categoryLink: [
+    "header nav a[href*='/c/']",
+    "header nav a[href*='/category/']",
+    "header nav a[href*='/collections/']",
+    "[data-mega-menu] a[href*='/c/']",
+    "header a[href]:not([href='/']):not([href='#']):not([href*='login']):not([href*='cart'])"
+  ],
+  productCard: [
+    "[data-product-card] a",
+    "[data-deco='view-product'] a",
+    "[data-testid='product-card'] a",
+    ".product-card a",
+    "article a[href*='/p/']",
+    "a[href*='/products/']"
+  ],
+  buyButton: [
+    "button:has-text('Comprar')",
+    "button:has-text('Adicionar')",
+    "button:has-text('Add to cart')",
+    "button:has-text('Add to bag')",
+    "[data-buy-button]",
+    "[data-testid='add-to-cart']",
+    "button[type='submit']:has-text('Comprar')"
+  ],
+  minicartTrigger: [
+    "[data-minicart-trigger]",
+    "[data-testid='minicart-trigger']",
+    "[aria-label*='carrinho' i]",
+    "[aria-label*='cart' i]",
+    "header button:has([data-cart-icon])",
+    "header a[href='/checkout']"
+  ],
+  cepInputPdp: [
+    "input[name='shipping-zipcode']",
+    "input[name='zipcode']",
+    "input[name='cep']",
+    "input[placeholder*='CEP' i]",
+    "input[placeholder*='Postal' i]",
+    "[data-shipping-input] input"
+  ],
+  cepInputCart: [
+    "input[name='cart-zipcode']",
+    "[data-minicart] input[name*='zip' i]",
+    "[data-cart] input[name*='zip' i]",
+    "[role='dialog'] input[name*='cep' i]",
+    "[role='dialog'] input[placeholder*='CEP' i]"
+  ],
+  checkoutButton: [
+    "a:has-text('Finalizar compra')",
+    "button:has-text('Finalizar compra')",
+    "a:has-text('Ir para o checkout')",
+    "button:has-text('Ir para o checkout')",
+    "[role='dialog'] a:has-text('Finalizar')",
+    "[role='dialog'] button:has-text('Finalizar')",
+    "[data-minicart] a:has-text('Finalizar')",
+    "[data-minicart] button:has-text('Finalizar')",
+    "[data-cart-drawer] a:has-text('Finalizar')",
+    "[data-cart-drawer] button:has-text('Finalizar')",
+    "a:has-text('Checkout')",
+    "[data-checkout-button]",
+    "a:text-is('Finalizar')",
+    "button:text-is('Finalizar')"
+  ],
+  sizeSwatch: [
+    "[data-size]:not([disabled]):not([aria-disabled='true']):not(.unavailable):not(.sold-out)",
+    "[data-variant-size]:not([disabled]):not([aria-disabled='true']):not(.unavailable)",
+    "button[aria-label*='tamanho' i]:not([aria-disabled='true']):not([disabled])",
+    "button[aria-label*='size' i]:not([aria-disabled='true']):not([disabled])",
+    "[data-testid='size-selector'] button:not([disabled]):not(.unavailable)",
+    ".size-selector button:not([disabled]):not(.unavailable):not(.sold-out)",
+    "[class*='size'] button:not([disabled]):not(.unavailable)",
+    "label:has(input[name*='size' i]:not([disabled])) "
+  ],
+  colorSwatch: [
+    "[data-color]:not([disabled]):not([aria-disabled='true']):not(.unavailable):not(.sold-out)",
+    "[data-variant-color]:not([disabled]):not([aria-disabled='true']):not(.unavailable)",
+    "button[aria-label*='cor' i]:not([aria-disabled='true']):not([disabled])",
+    "button[aria-label*='color' i]:not([aria-disabled='true']):not([disabled])",
+    "[data-testid='color-selector'] button:not([disabled]):not(.unavailable)",
+    ".color-swatch:not(.unavailable):not(.sold-out)",
+    "[class*='color'] button:not([disabled]):not(.unavailable)"
+  ],
+  variantRow: [
+    "[data-sku-row]",
+    "[data-variant-row]",
+    "tr[data-variant]",
+    "tr:has([aria-label*='quantidade' i])",
+    "tbody tr:has(input[type='number'])"
+  ],
+  quantityIncrement: [
+    "[data-qty-plus]",
+    "[data-quantity-plus]",
+    "button[aria-label*='aumentar' i]",
+    "button[aria-label*='increase' i]",
+    "button[aria-label*='increment' i]",
+    "button:has-text('+')",
+    "[class*='qty'] button:has-text('+')"
+  ],
+  quantityInput: [
+    "input[type='number'][min='0'][value='0']",
+    "input[id*='quantity-input' i]",
+    "input[name*='qty' i]",
+    "input[name*='quantity' i]",
+    "input[name*='quantidade' i]",
+    "input[aria-label*='quantidade' i]",
+    "[data-qty-input]",
+    "input[type='number'][min='0']",
+    "input[type='number'][min='1']"
+  ],
+  minicartCount: [
+    "[data-minicart-count]",
+    "[data-cart-count]",
+    ".cart-count",
+    ".minicart__count",
+    "[class*='cart-count']",
+    "[class*='CartCount']",
+    "[aria-label*='itens' i][role='status']",
+    "header [data-minicart-trigger] [class*='badge']",
+    "header [aria-label*='cart' i] [class*='count']",
+    "header [aria-label*='sacola' i] [class*='badge']",
+    "header [aria-label*='sacola' i] [class*='count']",
+    "header a[href*='/cart'] [class*='count']",
+    "header a[href*='/checkout'] [class*='count']",
+    "[data-fs-cart-icon] + [class*='count']",
+    "[class*='Minicart'] [class*='count']",
+    "[class*='minicart'] [class*='count']"
+  ]
+};
+function selectorsFor(key, ctxOrRc = {}) {
+  const ctx = isResolutionContext(ctxOrRc) ? ctxOrRc : { rc: ctxOrRc };
+  const out = [];
+  const override = ctx.rc?.selectors?.[key];
+  if (override)
+    out.push(override);
+  if (ctx.learned && ctx.platform) {
+    for (const entry of getLearnedSelectors(ctx.learned, ctx.platform, key)) {
+      out.push(entry.selector);
+    }
+  }
+  out.push(...DEFAULT_SELECTORS[key]);
+  return [...new Set(out)];
+}
+function isResolutionContext(v) {
+  if (!v || typeof v !== "object")
+    return false;
+  const k = Object.keys(v);
+  return k.length === 0 || k.some((x) => x === "rc" || x === "learned" || x === "platform");
+}
+
+// src/engine/flows.ts
+async function screenshotStable(page, opts) {
+  await Promise.race([
+    stabilizeCarousels(page).catch(() => {
+      return;
+    }),
+    new Promise((resolve2) => setTimeout(resolve2, 3000))
+  ]);
+  await page.screenshot({ path: opts.path, fullPage: opts.fullPage ?? false }).catch(() => {
+    return;
+  });
+}
+var PURCHASE_JOURNEY_TOTAL_STEPS = 9;
+var DEBUG_PARITY2 = process.env.DEBUG_PARITY === "1" || process.env.DEBUG_PARITY === "true";
+var DEBUG_START2 = Date.now();
+function dlog2(ctx, msg) {
+  if (!DEBUG_PARITY2)
+    return;
+  const elapsed = ((Date.now() - DEBUG_START2) / 1000).toFixed(1);
+  process.stderr.write(`[+${elapsed}s ${ctx.viewport}/${ctx.side}] ${msg}
+`);
+}
+function withCap(p, capMs, fallback) {
+  return Promise.race([
+    p.catch(() => fallback),
+    new Promise((resolve2) => setTimeout(() => resolve2(fallback), capMs))
+  ]);
+}
+var VARIANT_REQUIRED_TEXT_PATTERNS = [
+  /selecione um produto/i,
+  /selecione um tamanho/i,
+  /selecione uma cor/i,
+  /selecione uma op[cç][aã]o/i,
+  /select a size/i,
+  /select a color/i,
+  /select an option/i,
+  /choose an option/i,
+  /please select/i,
+  /select size/i,
+  /select color/i
+];
+var ADD_TO_CART_ERROR_PATTERNS = [
+  ...VARIANT_REQUIRED_TEXT_PATTERNS,
+  /estoque esgotado/i,
+  /out of stock/i,
+  /indispon[ií]vel/i,
+  /unavailable/i
+];
+var ADD_TO_CART_SUCCESS_PATTERNS = [
+  /produto adicionado/i,
+  /adicionado ao carrinho/i,
+  /adicionado [aà]\s+sacola/i,
+  /added to cart/i,
+  /added to bag/i,
+  /item added/i,
+  /successfully added/i
+];
+function selFor(ctx, key) {
+  return selectorsFor(key, { rc: ctx.rc, learned: ctx.learned, platform: ctx.platform });
+}
+var FLOW_DEADLINE_MS = {
+  homepage: 90000,
+  plp: 180000,
+  pdp: 240000,
+  "purchase-journey": 420000
+};
+async function runFlow(flow, ctx) {
+  const start = Date.now();
+  const deadlineMs = FLOW_DEADLINE_MS[flow];
+  const inner = async () => {
+    switch (flow) {
+      case "homepage":
+        return finalize(flow, ctx, await flowHomepage(ctx), [], start);
+      case "plp":
+        return finalize(flow, ctx, await flowPlp(ctx), [], start);
+      case "pdp":
+        return finalize(flow, ctx, await flowPdp(ctx), [], start);
+      case "purchase-journey": {
+        const { pages, steps } = await flowPurchaseJourney(ctx);
+        return finalize(flow, ctx, pages, steps, start);
+      }
+    }
+  };
+  const innerPromise = inner();
+  innerPromise.catch(() => {
+    return;
+  });
+  let timer;
+  let cleanup = Promise.resolve();
+  const timeoutPromise = new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      const pages = ctx.ctx.pages();
+      resolve2(finalize(flow, ctx, [], [
+        {
+          step: 0,
+          name: "flow-timeout",
+          side: ctx.side,
+          viewport: ctx.viewport,
+          status: "failed",
+          durationMs: deadlineMs,
+          screenshotPath: "",
+          actionDescription: `[flow-timeout] flow "${flow}" excedeu ${deadlineMs}ms — captura abortada pela safety net externa, ${pages.length} page(s) fechada(s) para liberar o contexto.`
+        }
+      ], start));
+      const CLOSE_CAP_MS = 5000;
+      const cappedClose = (p) => Promise.race([
+        p.close().catch(() => {
+          return;
+        }),
+        new Promise((resolveClose) => setTimeout(resolveClose, CLOSE_CAP_MS))
+      ]);
+      cleanup = Promise.allSettled(pages.map(cappedClose));
+    }, deadlineMs);
+  });
+  try {
+    const result = await Promise.race([innerPromise, timeoutPromise]);
+    await cleanup;
+    return result;
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+function finalize(flow, ctx, pages, steps, start) {
+  return {
+    flow,
+    side: ctx.side,
+    viewport: ctx.viewport,
+    pages,
+    steps,
+    totalDurationMs: Date.now() - start
+  };
+}
+function screenshotPath(ctx, label) {
+  const safe = label.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+  return `${ctx.outDir}/${safe}-${ctx.viewport}-${ctx.side}.png`;
+}
+async function flowHomepage(ctx) {
+  const page = await ctx.ctx.newPage();
+  try {
+    const cap = await capturePage(page, {
+      url: ctx.baseUrl,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "home")
+    });
+    return [cap];
+  } finally {
+    await page.close();
+  }
+}
+async function flowPlp(ctx) {
+  const home = await ctx.ctx.newPage();
+  const homeCap = await capturePage(home, {
+    url: ctx.baseUrl,
+    side: ctx.side,
+    viewport: ctx.viewport,
+    screenshotPath: screenshotPath(ctx, "home")
+  });
+  const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(home, ctx);
+  await home.close();
+  if (!plpHit)
+    return [homeCap];
+  const plp = await ctx.ctx.newPage();
+  try {
+    const cap = await capturePage(plp, {
+      url: plpHit.url,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "plp")
+    });
+    return [homeCap, cap];
+  } finally {
+    await plp.close();
+  }
+}
+async function flowPdp(ctx) {
+  const pages = [];
+  const home = await ctx.ctx.newPage();
+  pages.push(await capturePage(home, {
+    url: ctx.baseUrl,
+    side: ctx.side,
+    viewport: ctx.viewport,
+    screenshotPath: screenshotPath(ctx, "home")
+  }));
+  const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(home, ctx);
+  await home.close();
+  if (!plpHit)
+    return pages;
+  const plp = await ctx.ctx.newPage();
+  pages.push(await capturePage(plp, {
+    url: plpHit.url,
+    side: ctx.side,
+    viewport: ctx.viewport,
+    screenshotPath: screenshotPath(ctx, "plp")
+  }));
+  const pdpHit = await findProductUrl(plp, ctx);
+  await plp.close();
+  if (!pdpHit)
+    return pages;
+  const pdp = await ctx.ctx.newPage();
+  try {
+    pages.push(await capturePage(pdp, {
+      url: pdpHit.url,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "pdp")
+    }));
+    return pages;
+  } finally {
+    await pdp.close();
+  }
+}
+async function flowPurchaseJourney(ctx) {
+  const pages = [];
+  const steps = [];
+  const page = await ctx.ctx.newPage();
+  const budget = { remaining: ctx.recoveryBudget ?? 5 };
+  const total = PURCHASE_JOURNEY_TOTAL_STEPS;
+  const reportStart = (idx, name) => {
+    ctx.onStep?.({ phase: "start", name, index: idx, total });
+  };
+  const reportEnd = (idx, name, status, durationMs, note) => {
+    ctx.onStep?.({ phase: "end", name, index: idx, total, status, durationMs, note });
+  };
+  try {
+    reportStart(1, "visit-home");
+    const homeCap = await capturePage(page, {
+      url: ctx.baseUrl,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "pj-1-home")
+    });
+    pages.push(homeCap);
+    const step1Status = homeCap.status >= 200 && homeCap.status < 400 ? "ok" : "failed";
+    steps.push({
+      step: 1,
+      name: "visit-home",
+      side: ctx.side,
+      viewport: ctx.viewport,
+      status: step1Status,
+      durationMs: homeCap.durationMs,
+      url: homeCap.finalUrl,
+      screenshotPath: homeCap.screenshotPath
+    });
+    reportEnd(1, "visit-home", step1Status, homeCap.durationMs);
+    steps[steps.length - 1].actionDescription = `Navegou pra home \`${ctx.baseUrl}\` (HTTP ${homeCap.status})`;
+    if (homeCap.status >= 400 || homeCap.status === 0) {
+      return { pages, steps };
+    }
+    reportStart(2, "navigate-plp");
+    const plpHit = ctx.rc.plpUrlHint ? { url: new URL(ctx.rc.plpUrlHint, ctx.baseUrl).toString(), selector: "__hint__" } : await findCategoryUrl(page, ctx);
+    if (!plpHit) {
+      steps.push(makeSkipStep(2, "navigate-plp", ctx, "no category link found"));
+      reportEnd(2, "navigate-plp", "skipped", 0, "no category link found");
+      return { pages, steps };
+    }
+    const t2 = Date.now();
+    const plpCap = await capturePage(page, {
+      url: plpHit.url,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "pj-2-plp")
+    });
+    pages.push(plpCap);
+    const step2Status = plpCap.status >= 200 && plpCap.status < 400 ? "ok" : "failed";
+    steps.push({
+      step: 2,
+      name: "navigate-plp",
+      side: ctx.side,
+      viewport: ctx.viewport,
+      status: step2Status,
+      durationMs: Date.now() - t2,
+      url: plpCap.finalUrl,
+      screenshotPath: plpCap.screenshotPath,
+      selectorKey: "categoryLink",
+      usedSelector: plpHit.selector
+    });
+    reportEnd(2, "navigate-plp", step2Status, Date.now() - t2);
+    steps[steps.length - 1].actionDescription = `Navegou pra categoria \`${plpHit.url}\` (via \`${plpHit.selector}\`)`;
+    steps[steps.length - 1].beforeUrl = ctx.baseUrl;
+    reportStart(3, "enter-pdp");
+    let pdpHit = await findProductUrl(page, ctx);
+    let pdpRecoveredByLlm = false;
+    if (!pdpHit && budget.remaining > 0) {
+      const html = await page.content().catch(() => "");
+      if (html) {
+        const suggestion = await suggestRecovery({
+          stepName: "enter-pdp",
+          intendedAction: "Encontrar um link <a> que leve para a página de detalhes (PDP) de algum produto listado na PLP atual",
+          html,
+          alreadyTried: selFor(ctx, "productCard")
+        });
+        if (suggestion) {
+          budget.remaining--;
+          try {
+            const el = page.locator(suggestion.selector).first();
+            if (await el.isVisible({ timeout: 2000 }).catch(() => false)) {
+              const href = await el.getAttribute("href");
+              if (href) {
+                const abs = new URL(href, page.url()).toString();
+                pdpHit = { url: abs, selector: suggestion.selector };
+                pdpRecoveredByLlm = true;
+              }
+            }
+          } catch {}
+        }
+      }
+    }
+    if (!pdpHit) {
+      steps.push(makeSkipStep(3, "enter-pdp", ctx, "no product card found (recovery exhausted)"));
+      reportEnd(3, "enter-pdp", "skipped", 0, "no product card found");
+      return { pages, steps };
+    }
+    const t3 = Date.now();
+    const pdpCap = await capturePage(page, {
+      url: pdpHit.url,
+      side: ctx.side,
+      viewport: ctx.viewport,
+      screenshotPath: screenshotPath(ctx, "pj-3-pdp")
+    });
+    pages.push(pdpCap);
+    const step3Status = pdpCap.status >= 200 && pdpCap.status < 400 ? "ok" : "failed";
+    steps.push({
+      step: 3,
+      name: "enter-pdp",
+      side: ctx.side,
+      viewport: ctx.viewport,
+      status: step3Status,
+      durationMs: Date.now() - t3,
+      url: pdpCap.finalUrl,
+      screenshotPath: pdpCap.screenshotPath,
+      selectorKey: "productCard",
       usedSelector: pdpHit.selector,
       recoveredByLlm: pdpRecoveredByLlm || undefined
     });
@@ -10665,7 +11740,7 @@ async function detectCartRevealMode(page, trigger, drawerAlreadyOpen, viewport)
   if (viewport === "desktop") {
     try {
       const observedHoverDrawer = await page.evaluate(async () => {
-        return await new Promise((resolve) => {
+        return await new Promise((resolve2) => {
           const selectorMatch = (el) => {
             if (!(el instanceof HTMLElement))
               return false;
@@ -10679,13 +11754,13 @@ async function detectCartRevealMode(page, trigger, drawerAlreadyOpen, viewport)
               for (const n of Array.from(m.addedNodes)) {
                 if (n instanceof Element && selectorMatch(n)) {
                   observer.disconnect();
-                  resolve(true);
+                  resolve2(true);
                   return;
                 }
               }
               if (m.type === "attributes" && m.target instanceof Element && selectorMatch(m.target)) {
                 observer.disconnect();
-                resolve(true);
+                resolve2(true);
                 return;
               }
             }
@@ -10698,7 +11773,7 @@ async function detectCartRevealMode(page, trigger, drawerAlreadyOpen, viewport)
           });
           setTimeout(() => {
             observer.disconnect();
-            resolve(false);
+            resolve2(false);
           }, 600);
         });
       });
@@ -11017,7 +12092,7 @@ async function detectEmptyCartBanner(page) {
 }
 
 // src/learned/platform.ts
-import * as cheerio6 from "cheerio";
+import * as cheerio7 from "cheerio";
 function detectPlatform(input) {
   const urlPlatform = detectFromUrl(input.url);
   if (urlPlatform !== "custom")
@@ -11066,7 +12141,7 @@ function detectFromHeaders(headers) {
 }
 function detectFromHtml(html) {
   try {
-    const $ = cheerio6.load(html);
+    const $ = cheerio7.load(html);
     const fsClasses = $('[class*="fs-"], [data-fs-]').length;
     if (fsClasses > 5)
       return "vtex-fs";
@@ -11142,9 +12217,9 @@ function isAlreadyDeprecated(lib, platform, key, selector) {
 }
 
 // src/llm/discover-selectors.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join9 } from "node:path";
-import * as cheerio7 from "cheerio";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+import * as cheerio8 from "cheerio";
 var CACHE_DIR = ".parity-cache";
 var DISCOVER_SELECTORS_TOOL = {
   name: "report_selectors",
@@ -11188,7 +12263,7 @@ var DISCOVER_SELECTORS_TOOL = {
     required: ["category_link", "product_card", "buy_button", "minicart_trigger"]
   }
 };
-var SYSTEM_PROMPT2 = `
+var SYSTEM_PROMPT3 = `
 Você é um especialista em CSS selectors para crawlers/E2E de sites de e-commerce
 (VTEX, Shopify, Wake, Nuvemshop, custom).
 
@@ -11238,7 +12313,7 @@ Responda SEMPRE via tool_use report_selectors. Não escreva texto livre fora da
 `.trim();
 function compactHtmlForSelectors(html, maxChars = 30000) {
   try {
-    const $ = cheerio7.load(html);
+    const $ = cheerio8.load(html);
     $("script, style, noscript, svg, picture source, link[rel='stylesheet']").remove();
     $("[type='application/ld+json']").remove();
     const sections = [];
@@ -11272,16 +12347,16 @@ function compactHtmlForSelectors(html, maxChars = 30000) {
 async function discoverSelectorsFromUrl(url, html, opts = {}) {
   const host = safeHost(url);
   const cacheDir = opts.cacheDir ?? CACHE_DIR;
-  const cachePath = join9(cacheDir, `selectors-${host}.json`);
+  const cachePath = join10(cacheDir, `selectors-${host}.json`);
   if (!opts.noCache && existsSync7(cachePath)) {
     try {
-      const cached = JSON.parse(readFileSync8(cachePath, "utf8"));
+      const cached = JSON.parse(readFileSync10(cachePath, "utf8"));
       return cached;
     } catch {}
   }
   const compacted = compactHtmlForSelectors(html);
   const input = await callTool({
-    systemPrompt: SYSTEM_PROMPT2,
+    systemPrompt: SYSTEM_PROMPT3,
     userText: `URL: ${url}
 
 HTML compactado da home:
@@ -11311,8 +12386,8 @@ ${compacted}
     selectors.checkoutButton = undefined;
   }
   if (!existsSync7(cacheDir))
-    mkdirSync5(cacheDir, { recursive: true });
-  writeFileSync7(cachePath, `${JSON.stringify(selectors, null, 2)}
+    mkdirSync6(cacheDir, { recursive: true });
+  writeFileSync8(cachePath, `${JSON.stringify(selectors, null, 2)}
 `, "utf8");
   return selectors;
 }
@@ -11361,7 +12436,7 @@ var CRITICAL_STEPS2 = new Set([
 async function journeyCommand(opts) {
   const viewports = opts.viewports.split(",").map((s) => s.trim()).filter((s) => s === "mobile" || s === "desktop");
   if (viewports.length === 0) {
-    console.error(chalk10.red("Nenhum viewport válido (use mobile,desktop)"));
+    console.error(chalk11.red("Nenhum viewport válido (use mobile,desktop)"));
     return 2;
   }
   const rc = loadParityRc();
@@ -11371,13 +12446,13 @@ async function journeyCommand(opts) {
   const runId = newRunId();
   const paths = createRunDir(opts.output, runId);
   if (!opts.json) {
-    console.log(chalk10.bold(`
+    console.log(chalk11.bold(`
   parity journey ${runId}`));
-    console.log(chalk10.dim(`  prod: ${opts.prod}`));
-    console.log(chalk10.dim(`  cand: ${opts.cand}`));
-    console.log(chalk10.dim(`  viewports: ${viewports.join(", ")} · CEP: ${rc.cep}`));
+    console.log(chalk11.dim(`  prod: ${opts.prod}`));
+    console.log(chalk11.dim(`  cand: ${opts.cand}`));
+    console.log(chalk11.dim(`  viewports: ${viewports.join(", ")} · CEP: ${rc.cep}`));
     if (isLlmAvailable())
-      console.log(chalk10.dim(`  llm: ${providerLabel()}`));
+      console.log(chalk11.dim(`  llm: ${providerLabel()}`));
     console.log("");
   }
   let platform = "custom";
@@ -11421,20 +12496,20 @@ async function journeyCommand(opts) {
   const onStepFor = (viewport, side) => (event) => {
     if (opts.json)
       return;
-    const sideTag = side === "prod" ? chalk10.cyan("prod") : chalk10.magenta("cand");
-    const prefix = `  ${chalk10.dim(`[${viewport}/`)}${sideTag}${chalk10.dim("]")}`;
+    const sideTag = side === "prod" ? chalk11.cyan("prod") : chalk11.magenta("cand");
+    const prefix = `  ${chalk11.dim(`[${viewport}/`)}${sideTag}${chalk11.dim("]")}`;
     if (event.phase === "start") {
-      console.log(`${prefix} ${chalk10.dim(`${event.index}/${event.total}`)} ▶ ${chalk10.bold(stepLabel(event.name))}`);
+      console.log(`${prefix} ${chalk11.dim(`${event.index}/${event.total}`)} ▶ ${chalk11.bold(stepLabel(event.name))}`);
     } else {
-      const glyph = event.status === "ok" ? chalk10.green("✓") : event.status === "skipped" ? chalk10.yellow("○") : chalk10.red("✗");
-      const noteText = event.note ? chalk10.dim(` (${event.note})`) : "";
-      const time = chalk10.dim(`${(event.durationMs / 1000).toFixed(1)}s`);
-      console.log(`${prefix} ${chalk10.dim(`${event.index}/${event.total}`)} ${glyph} ${stepLabel(event.name)} ${time}${noteText}`);
+      const glyph = event.status === "ok" ? chalk11.green("✓") : event.status === "skipped" ? chalk11.yellow("○") : chalk11.red("✗");
+      const noteText = event.note ? chalk11.dim(` (${event.note})`) : "";
+      const time = chalk11.dim(`${(event.durationMs / 1000).toFixed(1)}s`);
+      console.log(`${prefix} ${chalk11.dim(`${event.index}/${event.total}`)} ${glyph} ${stepLabel(event.name)} ${time}${noteText}`);
     }
   };
   async function runOneSide(browserInstance, viewport, side) {
     const baseUrl = side === "prod" ? opts.prod : opts.cand;
-    const tracePath = join10(paths.tracesDir, `${viewport}-${side}.zip`);
+    const tracePath = join11(paths.tracesDir, `${viewport}-${side}.zip`);
     const ctx = await newContext(browserInstance, {
       viewport,
       tracesDir: paths.tracesDir,
@@ -11468,7 +12543,7 @@ async function journeyCommand(opts) {
     spinner?.succeed("Browser pronto");
     for (const viewport of viewports) {
       if (!opts.json)
-        console.log(chalk10.bold(`
+        console.log(chalk11.bold(`
   ── ${viewport} ─────────────────────────────────────────────`));
       const [prodCap, candCap] = await Promise.all([
         runOneSide(browser, viewport, "prod"),
@@ -11503,11 +12578,11 @@ async function journeyCommand(opts) {
           if (totalDeprecated > 0)
             bits.push(`${totalDeprecated} depreciado(s)`);
           if (bits.length > 0)
-            console.log(chalk10.dim(`  learned-selectors atualizado: ${bits.join(", ")}`));
+            console.log(chalk11.dim(`  learned-selectors atualizado: ${bits.join(", ")}`));
         }
       } catch (err) {
         if (!opts.json) {
-          console.warn(chalk10.yellow(`  warn: failed to persist learned-selectors: ${err.message}`));
+          console.warn(chalk11.yellow(`  warn: failed to persist learned-selectors: ${err.message}`));
         }
       }
     }
@@ -11526,9 +12601,9 @@ async function journeyCommand(opts) {
     if (opts.github)
       emitGithubAnnotations(failures);
     if (opts.junit) {
-      writeFileSync8(opts.junit, buildJUnit(rows, failures), "utf8");
+      writeFileSync9(opts.junit, buildJUnit(rows, failures), "utf8");
       if (!opts.json)
-        console.log(chalk10.dim(`  → JUnit XML: ${opts.junit}`));
+        console.log(chalk11.dim(`  → JUnit XML: ${opts.junit}`));
     }
     return failures.some((f) => f.critical) ? 1 : 0;
   } catch (err) {
@@ -11593,14 +12668,14 @@ function collectFailures(rows) {
 function printTable(viewports, rows) {
   console.log("");
   for (const viewport of viewports) {
-    console.log(chalk10.bold(`  [${viewport}]`));
+    console.log(chalk11.bold(`  [${viewport}]`));
     const vrows = rows.filter((r) => r.viewport === viewport);
     for (const r of vrows) {
       const label = STEP_LABELS2[r.name] ?? r.name;
       const p = statusGlyph(r.prod?.status);
       const c = statusGlyph(r.cand?.status);
-      const status = r.prod?.status === "ok" && r.cand?.status !== "ok" ? chalk10.red("FAILED") : "";
-      const note = r.cand?.status === "failed" || r.cand?.status === "skipped" ? chalk10.dim(`(${r.cand?.note ?? r.cand?.status})`) : "";
+      const status = r.prod?.status === "ok" && r.cand?.status !== "ok" ? chalk11.red("FAILED") : "";
+      const note = r.cand?.status === "failed" || r.cand?.status === "skipped" ? chalk11.dim(`(${r.cand?.note ?? r.cand?.status})`) : "";
       console.log(`    ${label.padEnd(24)}  prod ${p}   cand ${c}   ${status} ${note}`);
     }
     console.log("");
@@ -11608,12 +12683,12 @@ function printTable(viewports, rows) {
 }
 function statusGlyph(status) {
   if (!status)
-    return chalk10.dim("—");
+    return chalk11.dim("—");
   if (status === "ok")
-    return chalk10.green("✓");
+    return chalk11.green("✓");
   if (status === "skipped")
-    return chalk10.yellow("○");
-  return chalk10.red("✗");
+    return chalk11.yellow("○");
+  return chalk11.red("✗");
 }
 function printSummary3(rows, failures, htmlPath) {
   const byViewport = new Map;
@@ -11624,25 +12699,25 @@ function printSummary3(rows, failures, htmlPath) {
       v.passed++;
     byViewport.set(r.viewport, v);
   }
-  console.log(chalk10.bold("  Summary:"));
+  console.log(chalk11.bold("  Summary:"));
   for (const [vp, { passed, total }] of byViewport) {
-    const stat = passed === total ? chalk10.green("✓") : chalk10.yellow(`${passed}/${total}`);
+    const stat = passed === total ? chalk11.green("✓") : chalk11.yellow(`${passed}/${total}`);
     console.log(`    ${vp.padEnd(8)} ${stat} steps em cand`);
   }
   if (failures.length > 0) {
     const crit = failures.filter((f) => f.critical).length;
     console.log("");
-    console.log(chalk10.red(`  ✗ ${failures.length} step(s) divergent(es) (${crit} crítico)`));
+    console.log(chalk11.red(`  ✗ ${failures.length} step(s) divergent(es) (${crit} crítico)`));
     for (const f of failures) {
-      const tag = f.critical ? chalk10.red("[critical]") : chalk10.yellow("[warn]");
+      const tag = f.critical ? chalk11.red("[critical]") : chalk11.yellow("[warn]");
       console.log(`    ${tag} [${f.viewport}] ${f.step}: ${f.reason}`);
     }
   } else {
     console.log("");
-    console.log(chalk10.green("  ✓ jornada completa em cand"));
+    console.log(chalk11.green("  ✓ jornada completa em cand"));
   }
   console.log("");
-  console.log(chalk10.dim(`  → ${htmlPath}`));
+  console.log(chalk11.dim(`  → ${htmlPath}`));
   console.log("");
 }
 function emitGithubAnnotations(failures) {
@@ -11689,7 +12764,7 @@ function buildJourneyRun(opts, runId, flowCaptures, failures) {
   const totalDuration = flowCaptures.reduce((a, b) => a + b.totalDurationMs, 0);
   const critical = failures.filter((f) => f.critical).length;
   const others = failures.length - critical;
-  const verdict = {
+  const verdict2 = {
     status: critical > 0 ? "fail" : failures.length > 0 ? "warn" : "pass",
     score: Math.max(0, 100 - critical * 20 - others * 8),
     critical,
@@ -11711,7 +12786,7 @@ function buildJourneyRun(opts, runId, flowCaptures, failures) {
     viewports: opts.viewports.split(","),
     cep: opts.cep,
     durationMs: totalDuration,
-    verdict,
+    verdict: verdict2,
     topIssues: [],
     issues: [],
     checks: [],
@@ -11877,23 +12952,23 @@ function safeHost2(url) {
 }
 
 // src/commands/learned.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 function learnedStats() {
   const lib = loadLearned();
   const stats = statsFromLib(lib);
   if (stats.platforms.length === 0) {
-    console.log(chalk11.dim(`Biblioteca vazia: ${LEARNED_PATH}`));
-    console.log(chalk11.dim("Rode `parity run ...` em algum site para começar a popular."));
+    console.log(chalk12.dim(`Biblioteca vazia: ${LEARNED_PATH}`));
+    console.log(chalk12.dim("Rode `parity run ...` em algum site para começar a popular."));
     return 0;
   }
-  console.log(chalk11.bold(`
+  console.log(chalk12.bold(`
 learned-selectors stats (${LEARNED_PATH})
 `));
   for (const p of stats.platforms) {
-    console.log(`${chalk11.cyan(p.platform)}: ${p.activeSelectors} active · ${chalk11.dim(`${p.deprecatedSelectors} deprecated`)}`);
+    console.log(`${chalk12.cyan(p.platform)}: ${p.activeSelectors} active · ${chalk12.dim(`${p.deprecatedSelectors} deprecated`)}`);
     for (const top of p.topByKey) {
       const sr = `${(top.successRate * 100).toFixed(0)}%`;
-      console.log(`   ${chalk11.dim(top.key.padEnd(18))} ${chalk11.green(sr.padStart(4))}  ${chalk11.dim(`(${top.hosts} hosts)`)}  ${top.selector}`);
+      console.log(`   ${chalk12.dim(top.key.padEnd(18))} ${chalk12.green(sr.padStart(4))}  ${chalk12.dim(`(${top.hosts} hosts)`)}  ${top.selector}`);
     }
     console.log("");
   }
@@ -11901,9 +12976,9 @@ learned-selectors stats (${LEARNED_PATH})
 }
 
 // src/commands/vitals.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join11 } from "node:path";
-import chalk12 from "chalk";
+import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join12 } from "node:path";
+import chalk13 from "chalk";
 import ora4 from "ora";
 async function vitalsCommand(opts) {
   const viewports = opts.viewports.split(",").map((s) => s.trim()).filter((s) => s === "mobile" || s === "desktop");
@@ -11911,10 +12986,10 @@ async function vitalsCommand(opts) {
   const runId = newRunId();
   const paths = createRunDir(opts.output, runId);
   const t0 = Date.now();
-  console.log(chalk12.bold(`
+  console.log(chalk13.bold(`
   parity vitals ${runId}`));
-  console.log(chalk12.dim(`  prod: ${opts.prod}`));
-  console.log(chalk12.dim(`  cand: ${opts.cand}`));
+  console.log(chalk13.dim(`  prod: ${opts.prod}`));
+  console.log(chalk13.dim(`  cand: ${opts.cand}`));
   const discoverSpinner = ora4("Descobrindo páginas…").start();
   const pagePaths = await discoverPagePaths2(opts.prod, opts);
   if (pagePaths.length === 0) {
@@ -11946,7 +13021,7 @@ async function vitalsCommand(opts) {
         completed++;
         const elapsed = ((Date.now() - t0) / 1000).toFixed(0);
         const etaSec = completed > 0 ? Math.round((Date.now() - t0) / completed * (total - completed) / 1000) : 0;
-        progress.text = `${completed}/${total} · ${elapsed}s · ETA ${etaSec}s · ${task.side === "prod" ? chalk12.cyan("prod") : chalk12.magenta("cand")} ${task.path} (${task.viewport})`;
+        progress.text = `${completed}/${total} · ${elapsed}s · ETA ${etaSec}s · ${task.side === "prod" ? chalk13.cyan("prod") : chalk13.magenta("cand")} ${task.path} (${task.viewport})`;
       }
     });
     progress.succeed(`${total} capture(s) em ${((Date.now() - t0) / 1000).toFixed(1)}s`);
@@ -11988,7 +13063,7 @@ async function vitalsCommand(opts) {
     const cacheResult = cacheCoverage(checkCtx);
     const checks = [vitalsResult, cacheResult];
     const allIssues = checks.flatMap((c) => c.issues);
-    const verdict = computeVerdict2(checks, allIssues);
+    const verdict2 = computeVerdict2(checks, allIssues);
     const run = {
       schemaVersion: "0.1",
       id: runId,
@@ -11999,7 +13074,7 @@ async function vitalsCommand(opts) {
       viewports,
       cep: rc.cep,
       durationMs: Date.now() - t0,
-      verdict,
+      verdict: verdict2,
       topIssues: allIssues.slice(0, 10),
       issues: allIssues,
       checks,
@@ -12008,7 +13083,7 @@ async function vitalsCommand(opts) {
     writeRunReportJson(paths.runDir, run);
     const html = renderHtmlReport(run, paths.runDir);
     writeRunReportHtml(paths.runDir, html);
-    writeFileSync9(join11(paths.runDir, "vitals.json"), `${JSON.stringify({
+    writeFileSync10(join12(paths.runDir, "vitals.json"), `${JSON.stringify({
       schemaVersion: "0.1",
       prodUrl: opts.prod,
       candUrl: opts.cand,
@@ -12019,8 +13094,8 @@ async function vitalsCommand(opts) {
 `, "utf8");
     printSummary4(vitalsResult, cacheResult);
     console.log("");
-    console.log(chalk12.dim(`  → ${paths.reportHtml}`));
-    console.log(chalk12.dim(`  \uD83D\uDCA1 use 'parity serve ${runId}' pra preview iframe`));
+    console.log(chalk13.dim(`  → ${paths.reportHtml}`));
+    console.log(chalk13.dim(`  \uD83D\uDCA1 use 'parity serve ${runId}' pra preview iframe`));
     console.log("");
     if (opts.open) {
       const { default: open } = await import("open");
@@ -12107,7 +13182,7 @@ function parseUrlList(input) {
   if (input.startsWith("file:") || input.endsWith(".txt") || input.endsWith(".list")) {
     const path = input.replace(/^file:\/\//, "");
     if (existsSync8(path)) {
-      return readFileSync9(path, "utf8").split(/\r?\n/).map((s) => s.trim()).filter((s) => s && !s.startsWith("#")).map((s) => s.startsWith("/") ? s : `/${s}`);
+      return readFileSync11(path, "utf8").split(/\r?\n/).map((s) => s.trim()).filter((s) => s && !s.startsWith("#")).map((s) => s.startsWith("/") ? s : `/${s}`);
     }
   }
   return input.split(",").map((s) => s.trim()).filter(Boolean).map((s) => s.startsWith("/") || s.startsWith("http") ? s : `/${s}`);
@@ -12148,41 +13223,41 @@ function computeVerdict2(checks, issues) {
 }
 function printSummary4(vitals, cache) {
   console.log("");
-  console.log(chalk12.bold("  Summary:"));
+  console.log(chalk13.bold("  Summary:"));
   console.log(`    ${vitals.summary}`);
   console.log(`    ${cache.summary}`);
 }
 
 // src/commands/list.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function listCommand(output) {
   const runs = listRuns(output);
   if (runs.length === 0) {
-    console.log(chalk13.dim(`Nenhum run salvo em ${output}`));
+    console.log(chalk14.dim(`Nenhum run salvo em ${output}`));
     return 0;
   }
   for (const r of runs) {
     try {
       const run = loadRun(output, r.id);
       const v = run.verdict;
-      const status = v.status === "pass" ? chalk13.green(v.status) : v.status === "warn" ? chalk13.yellow(v.status) : chalk13.red(v.status);
-      console.log(`  ${chalk13.bold(r.id)}  ${status}  score=${v.score}  critical=${v.critical} high=${v.high}  ${chalk13.dim(r.timestamp)}`);
+      const status = v.status === "pass" ? chalk14.green(v.status) : v.status === "warn" ? chalk14.yellow(v.status) : chalk14.red(v.status);
+      console.log(`  ${chalk14.bold(r.id)}  ${status}  score=${v.score}  critical=${v.critical} high=${v.high}  ${chalk14.dim(r.timestamp)}`);
     } catch {
-      console.log(`  ${chalk13.bold(r.id)}  ${chalk13.dim("(report.json ausente)")}`);
+      console.log(`  ${chalk14.bold(r.id)}  ${chalk14.dim("(report.json ausente)")}`);
     }
   }
   return 0;
 }
 
 // src/commands/prompt.ts
-import { existsSync as existsSync9, writeFileSync as writeFileSync10 } from "node:fs";
-import chalk14 from "chalk";
+import { existsSync as existsSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import chalk15 from "chalk";
 function promptCommand(runId, opts) {
   let run;
   try {
     run = loadRun(opts.output, runId);
   } catch (err) {
-    console.error(chalk14.red(`✖ ${err.message}`));
+    console.error(chalk15.red(`✖ ${err.message}`));
     return 1;
   }
   const md = buildLlmPrompt(run, {
@@ -12190,11 +13265,11 @@ function promptCommand(runId, opts) {
     limit: opts.limit
   });
   if (opts.out) {
-    writeFileSync10(opts.out, md, "utf8");
-    console.log(chalk14.green(`✔ prompt salvo em ${opts.out}`));
+    writeFileSync11(opts.out, md, "utf8");
+    console.log(chalk15.green(`✔ prompt salvo em ${opts.out}`));
     if (existsSync9(opts.out)) {
       const sizeKb = (md.length / 1024).toFixed(1);
-      console.log(chalk14.dim(`  ${md.length} chars (${sizeKb} KB)`));
+      console.log(chalk15.dim(`  ${md.length} chars (${sizeKb} KB)`));
     }
   } else {
     process.stdout.write(md);
@@ -12203,20 +13278,20 @@ function promptCommand(runId, opts) {
 }
 
 // src/commands/report.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import open from "open";
 async function reportCommand(runId, output) {
   const paths = getRunPaths(output, runId);
-  console.log(chalk15.dim(`opening ${paths.reportHtml}`));
+  console.log(chalk16.dim(`opening ${paths.reportHtml}`));
   await open(paths.reportHtml).catch((err) => {
-    console.error(chalk15.red(`failed to open: ${err.message}`));
+    console.error(chalk16.red(`failed to open: ${err.message}`));
   });
   return 0;
 }
 
 // src/commands/run.ts
-import { join as join13 } from "node:path";
-import chalk17 from "chalk";
+import { join as join14 } from "node:path";
+import chalk18 from "chalk";
 import ora5 from "ora";
 
 // src/engine/sitemap-discover.ts
@@ -12435,12 +13510,12 @@ async function matchPdps(prod, cand) {
   if (sim >= 0.95)
     return "same";
   if (sim >= 0.8) {
-    const verdict = await llmMatch(prod, cand);
-    return verdict ?? "similar";
+    const verdict2 = await llmMatch(prod, cand);
+    return verdict2 ?? "similar";
   }
   if (sim >= 0.6) {
-    const verdict = await llmMatch(prod, cand);
-    return verdict ?? "different";
+    const verdict2 = await llmMatch(prod, cand);
+    return verdict2 ?? "different";
   }
   return "different";
 }
@@ -12501,21 +13576,21 @@ cand: ${JSON.stringify(cand)}`,
       }
     }
   });
-  const verdict = input?.verdict;
-  if (verdict === "same" || verdict === "similar" || verdict === "different") {
-    return verdict;
+  const verdict2 = input?.verdict;
+  if (verdict2 === "same" || verdict2 === "similar" || verdict2 === "different") {
+    return verdict2;
   }
   return null;
 }
 
 // src/commands/serve.ts
 import { existsSync as existsSync11 } from "node:fs";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 
 // src/server/proxy-server.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, statSync } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync12, statSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join as join12, normalize as normalize3, resolve, sep } from "node:path";
+import { extname, join as join13, normalize as normalize3, resolve as resolve2, sep } from "node:path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -12551,7 +13626,7 @@ var STRIPPED_REQUEST_HEADERS = new Set([
   "origin"
 ]);
 async function startProxyServer(runDir, opts = {}) {
-  const absRunDir = resolve(runDir);
+  const absRunDir = resolve2(runDir);
   if (!existsSync10(absRunDir)) {
     throw new Error(`Run directory not found: ${runDir}`);
   }
@@ -12563,9 +13638,9 @@ async function startProxyServer(runDir, opts = {}) {
       } catch {}
     });
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server.once("error", reject);
-    server.listen(opts.port ?? 0, opts.host ?? "127.0.0.1", () => resolve2());
+    server.listen(opts.port ?? 0, opts.host ?? "127.0.0.1", () => resolve3());
   });
   const addr = server.address();
   const port = typeof addr === "object" && addr ? addr.port : 0;
@@ -12573,13 +13648,13 @@ async function startProxyServer(runDir, opts = {}) {
   return {
     port,
     url: `http://${host}:${port}/`,
-    close: () => new Promise((resolve2) => {
+    close: () => new Promise((resolve3) => {
       try {
         server.closeAllConnections?.();
         server.closeIdleConnections?.();
       } catch {}
-      server.close(() => resolve2());
-      setTimeout(() => resolve2(), 1000);
+      server.close(() => resolve3());
+      setTimeout(() => resolve3(), 1000);
     })
   };
 }
@@ -12607,13 +13682,13 @@ async function handleRequest(req, res, runDir) {
   return serveStatic(res, runDir, path);
 }
 function serveReportHtml(res, runDir) {
-  const filePath = join12(runDir, "report.html");
+  const filePath = join13(runDir, "report.html");
   if (!existsSync10(filePath)) {
     res.statusCode = 404;
     res.end("report.html not found");
     return;
   }
-  const html = readFileSync10(filePath, "utf8");
+  const html = readFileSync12(filePath, "utf8");
   const inject = `<script>window.__parity_proxy = "/proxy?url=";</script>`;
   const out = html.includes("</head>") ? html.replace("</head>", `${inject}</head>`) : `${inject}${html}`;
   res.statusCode = 200;
@@ -12623,7 +13698,7 @@ function serveReportHtml(res, runDir) {
 }
 function serveStatic(res, runDir, path) {
   const safePath2 = normalize3(path).replace(/^[/\\]+/, "");
-  const filePath = resolve(runDir, safePath2);
+  const filePath = resolve2(runDir, safePath2);
   if (!filePath.startsWith(runDir + sep) && filePath !== runDir) {
     res.statusCode = 403;
     res.end("forbidden");
@@ -12644,7 +13719,7 @@ function serveStatic(res, runDir, path) {
   res.statusCode = 200;
   res.setHeader("content-type", MIME[ext] ?? "application/octet-stream");
   res.setHeader("cache-control", "no-store");
-  res.end(readFileSync10(filePath));
+  res.end(readFileSync12(filePath));
 }
 async function proxyRequest(req, res, targetUrl) {
   let target;
@@ -12730,16 +13805,16 @@ async function serveRunAndBlock(runDir, opts = {}) {
   try {
     handle = await startProxyServer(runDir, { port: opts.port });
   } catch (err) {
-    console.error(chalk16.red(`  ✖ Falha ao iniciar servidor: ${err.message}`));
+    console.error(chalk17.red(`  ✖ Falha ao iniciar servidor: ${err.message}`));
     return 2;
   }
   const label = opts.label ?? "parity serve";
   console.log("");
-  console.log(chalk16.bold(`  ${label}`));
-  console.log(`  ${chalk16.green("●")} ${handle.url}`);
-  console.log(chalk16.dim(`  Servindo: ${runDir}`));
-  console.log(chalk16.dim(`  Proxy de iframes: ${handle.url}proxy?url=<encoded>`));
-  console.log(chalk16.dim(`  Ctrl+C pra parar (2x pra forçar saída).
+  console.log(chalk17.bold(`  ${label}`));
+  console.log(`  ${chalk17.green("●")} ${handle.url}`);
+  console.log(chalk17.dim(`  Servindo: ${runDir}`));
+  console.log(chalk17.dim(`  Proxy de iframes: ${handle.url}proxy?url=<encoded>`));
+  console.log(chalk17.dim(`  Ctrl+C pra parar (2x pra forçar saída).
 `));
   if (opts.open !== false) {
     const { default: open2 } = await import("open");
@@ -12772,11 +13847,11 @@ async function serveRunAndBlock(runDir, opts = {}) {
 async function serveCommand(runId, opts) {
   const paths = getRunPaths(opts.output, runId);
   if (!existsSync11(paths.runDir)) {
-    console.error(chalk16.red(`✖ Run não encontrado: ${runId} (em ${opts.output})`));
+    console.error(chalk17.red(`✖ Run não encontrado: ${runId} (em ${opts.output})`));
     return 1;
   }
   if (!existsSync11(paths.reportHtml)) {
-    console.error(chalk16.red(`✖ report.html não existe em ${paths.runDir}`));
+    console.error(chalk17.red(`✖ report.html não existe em ${paths.runDir}`));
     return 1;
   }
   return serveRunAndBlock(paths.runDir, {
@@ -12836,7 +13911,7 @@ function applyPreset(opts) {
 async function runCommand(rawOpts) {
   const opts = applyPreset(rawOpts);
   if (rawOpts.preset) {
-    console.log(chalk17.dim(`  preset: ${rawOpts.preset}`));
+    console.log(chalk18.dim(`  preset: ${rawOpts.preset}`));
   }
   const flows = opts.flows.split(",").map((s) => s.trim());
   const viewports = opts.viewports.split(",").map((s) => s.trim());
@@ -12847,11 +13922,11 @@ async function runCommand(rawOpts) {
   const primaryViewport = viewports[0] ?? "mobile";
   const preflight = await preflightCheck(opts.prod, opts.cand, primaryViewport);
   if (!preflight.ok) {
-    console.error(chalk17.red(`
+    console.error(chalk18.red(`
   ✖ pre-flight falhou:`));
     for (const err of preflight.errors)
-      console.error(chalk17.red(`    - ${err}`));
-    console.error(chalk17.dim(`
+      console.error(chalk18.red(`    - ${err}`));
+    console.error(chalk18.dim(`
   dica: verifique se as URLs estão corretas e acessíveis`));
     return 2;
   }
@@ -12862,7 +13937,7 @@ async function runCommand(rawOpts) {
   if (prodHomeHtml) {
     platform = detectPlatform({ url: opts.prod, html: prodHomeHtml });
     if (platform !== "custom") {
-      console.log(chalk17.dim(`  Detected platform: ${platform}`));
+      console.log(chalk18.dim(`  Detected platform: ${platform}`));
     }
   }
   const prodHost = hostOf2(opts.prod);
@@ -12904,11 +13979,11 @@ async function runCommand(rawOpts) {
   const paths = createRunDir(opts.output, runId);
   const startedAt = Date.now();
   const timestamp = new Date().toISOString();
-  console.log(chalk17.bold(`
+  console.log(chalk18.bold(`
   parity run ${runId}`));
-  console.log(chalk17.dim(`  prod: ${opts.prod}`));
-  console.log(chalk17.dim(`  cand: ${opts.cand}`));
-  console.log(chalk17.dim(`  flows: ${flows.join(", ")} · viewports: ${viewports.join(", ")} · CEP: ${rc.cep}
+  console.log(chalk18.dim(`  prod: ${opts.prod}`));
+  console.log(chalk18.dim(`  cand: ${opts.cand}`));
+  console.log(chalk18.dim(`  flows: ${flows.join(", ")} · viewports: ${viewports.join(", ")} · CEP: ${rc.cep}
 `));
   const spinner = ora5("Launching browser…").start();
   let browser = null;
@@ -12937,8 +14012,8 @@ async function runCommand(rawOpts) {
       for (const side of ["prod", "cand"]) {
         const baseUrl = side === "prod" ? opts.prod : opts.cand;
         spinner.text = `[${viewport}/${side}] preparing context…`;
-        const harPath = join13(paths.harDir, `${viewport}-${side}.har`);
-        const tracePath = join13(paths.tracesDir, `${viewport}-${side}.zip`);
+        const harPath = join14(paths.harDir, `${viewport}-${side}.har`);
+        const tracePath = join14(paths.tracesDir, `${viewport}-${side}.zip`);
         const ctx = await newContext(browser, {
           viewport,
           harPath,
@@ -12983,9 +14058,9 @@ async function runCommand(rawOpts) {
       if (prodPdp && candPdp) {
         const fpProd = fingerprintPdp(prodPdp.html);
         const fpCand = fingerprintPdp(candPdp.html);
-        const verdict2 = await matchPdps(fpProd, fpCand);
-        if (verdict2 !== "same") {
-          spinner.warn(`PDP cross-site matcher: '${verdict2}' (prod="${fpProd.name ?? "?"}" cand="${fpCand.name ?? "?"}")`);
+        const verdict3 = await matchPdps(fpProd, fpCand);
+        if (verdict3 !== "same") {
+          spinner.warn(`PDP cross-site matcher: '${verdict3}' (prod="${fpProd.name ?? "?"}" cand="${fpCand.name ?? "?"}")`);
         }
       }
     }
@@ -13063,789 +14138,367 @@ async function runCommand(rawOpts) {
                 allFlowCaptures.push({
                   flow: "homepage",
                   side: task.side,
-                  viewport: task.viewport,
-                  pages: [cap],
-                  totalDurationMs: cap.durationMs
-                });
-              } finally {
-                await page.close().catch(() => {
-                  return;
-                });
-                await ctx.close().catch(() => {
-                  return;
-                });
-              }
-            } catch {} finally {
-              done++;
-              extraSpinner.text = `[vitals extras] ${done}/${tasks.length} (último: ${task.path})`;
-            }
-          });
-          extraSpinner.succeed(`+${extraPaths.length} página(s) com vitals`);
-        } else {
-          extraSpinner.warn("Nenhuma página extra encontrada no sitemap");
-        }
-      } catch (err) {
-        extraSpinner.warn(`vitals extras pulado: ${err.message}`);
-      }
-    }
-    const visualPagesLimit = opts.noVisualDiff ? 0 : opts.visualPages ?? 5;
-    if (browser && visualPagesLimit > 0) {
-      const visualSpinner = ora5("Descobrindo páginas pra visual diff…").start();
-      try {
-        const sample = await discoverPagesFromSitemap(opts.prod, { sampleSize: visualPagesLimit });
-        const visualPaths = sample.all.map((p) => p.path);
-        const alreadyCapturedKeys = new Set;
-        for (const p of allPageCaptures) {
-          try {
-            alreadyCapturedKeys.add(`${new URL(p.url).pathname}::${p.viewport}::${p.side}`);
-          } catch {}
-        }
-        const tasks = [];
-        for (const viewport of viewports) {
-          for (const path of visualPaths) {
-            for (const side of ["prod", "cand"]) {
-              if (alreadyCapturedKeys.has(`${path}::${viewport}::${side}`))
-                continue;
-              tasks.push({ path, viewport, side });
-            }
-          }
-        }
-        if (tasks.length === 0) {
-          visualSpinner.succeed(`Visual diff: páginas já capturadas em flows (${visualPaths.length} alvos)`);
-        } else {
-          visualSpinner.text = `Visual diff: capturando ${tasks.length} screenshot(s) (${visualPaths.length} páginas × ${viewports.length} viewport(s) × 2 sides)…`;
-          let done = 0;
-          await runWithConcurrency3(tasks, 4, async (task) => {
-            const baseUrl = task.side === "prod" ? opts.prod : opts.cand;
-            const fullUrl = new URL(task.path, baseUrl).toString();
-            const safePath2 = task.path.replace(/[/?&=]+/g, "_") || "_root";
-            const screenshotPath2 = `${paths.screenshotsDir}/visual-${safePath2}-${task.viewport}-${task.side}.png`;
-            try {
-              const ctx = await newContext(browser, { viewport: task.viewport, cohortCookieValue: "control", noCache: opts.bypassCache });
-              await installVitalsCollector(ctx);
-              const page = await ctx.newPage();
-              try {
-                const cap = await capturePage(page, {
-                  url: fullUrl,
-                  side: task.side,
-                  viewport: task.viewport,
-                  screenshotPath: screenshotPath2,
-                  settleMs: 1800,
-                  timeoutMs: 30000,
-                  scrollToLoad: true
-                });
-                allPageCaptures.push(cap);
-              } finally {
-                await page.close().catch(() => {
-                  return;
-                });
-                await ctx.close().catch(() => {
-                  return;
-                });
-              }
-            } catch {} finally {
-              done++;
-              visualSpinner.text = `[visual] ${done}/${tasks.length} (último: ${task.path})`;
-            }
-          });
-          visualSpinner.succeed(`Visual diff: ${tasks.length} screenshot(s) capturado(s)`);
-        }
-      } catch (err) {
-        visualSpinner.warn(`Visual diff descoberta pulada: ${err.message}`);
-      }
-    }
-    spinner.start("Rodando checks…");
-    const checkCtx = {
-      prodPages: allPageCaptures.filter((p) => p.side === "prod"),
-      candPages: allPageCaptures.filter((p) => p.side === "cand"),
-      prodFlows: allFlowCaptures.filter((f) => f.side === "prod"),
-      candFlows: allFlowCaptures.filter((f) => f.side === "cand"),
-      rc,
-      ignore,
-      outDir: paths.runDir,
-      viewports
-    };
-    const checks = await runAllChecks(checkCtx);
-    spinner.succeed(`Checks concluídos (${checks.length})`);
-    const allIssues = checks.flatMap((c) => c.issues);
-    spinner.start(isLlmAvailable() ? "Agregando issues via LLM (Sonnet 4.6)…" : "Agregando issues (modo offline)…");
-    const topIssues = await aggregateIssues({
-      runId,
-      prodUrl: opts.prod,
-      candUrl: opts.cand,
-      viewports,
-      flows,
-      checks
-    });
-    spinner.succeed(`${topIssues.length} issue(s) priorizada(s)`);
-    const verdict = computeVerdict3(checks, allIssues);
-    let baselineSection;
-    if (opts.baseline) {
-      try {
-        const bl = loadBaseline(opts.baseline);
-        const delta = compareToBaseline({
-          id: runId,
-          issues: allIssues
-        }, bl);
-        baselineSection = {
-          name: opts.baseline,
-          delta: {
-            resolved: bl.issues.filter((i) => delta.resolved.includes(i.id)),
-            new: allIssues.filter((i) => delta.new.includes(i.id)),
-            regressions: allIssues.filter((i) => delta.regressions.includes(i.id))
-          }
-        };
-      } catch (err) {
-        spinner.warn(`Baseline "${opts.baseline}" não carregou: ${err.message}`);
-      }
-    }
-    const visualCheck = checks.find((c) => c.name === "visual-regression-keyframes");
-    const visualDiff = visualCheck?.data?.visualDiff;
-    const seoCheck = checks.find((c) => c.name === "seo-deep-audit");
-    const seo = seoCheck?.data?.seo;
-    const run = {
-      schemaVersion: "0.1",
-      id: runId,
-      timestamp,
-      prodUrl: opts.prod,
-      candUrl: opts.cand,
-      flows,
-      viewports,
-      cep: rc.cep,
-      durationMs: Date.now() - startedAt,
-      verdict,
-      topIssues,
-      issues: allIssues,
-      checks,
-      flowCaptures: allFlowCaptures,
-      visualDiff,
-      seo,
-      baseline: baselineSection
-    };
-    writeRunReportJson(paths.runDir, run);
-    const html = renderHtmlReport(run, paths.runDir);
-    writeRunReportHtml(paths.runDir, html);
-    printSummary5(run, paths.reportHtml, { promotedCount, deprecatedCount, platform });
-    if (opts.ci) {
-      const blocking = allIssues.filter((i) => failOn.includes(i.severity));
-      if (blocking.length > 0) {
-        console.log(chalk17.red(`
-  ✖ ${blocking.length} issue(s) bloqueante(s) [${failOn.join(", ")}] — exit 1`));
-        return 1;
-      }
-    }
-    if (opts.open) {
-      if (browser) {
-        await browser.close().catch(() => {
-          return;
-        });
-        browser = null;
-      }
-      return await serveRunAndBlock(paths.runDir, { label: `parity run · ${runId}` });
-    }
-    return 0;
-  } catch (err) {
-    spinner.fail(`Erro: ${err.message}`);
-    console.error(err);
-    return 2;
-  } finally {
-    if (browser)
-      await browser.close().catch(() => {
-        return;
-      });
-  }
-}
-function computeVerdict3(checks, issues) {
-  const counts = { critical: 0, high: 0, medium: 0, low: 0 };
-  for (const i of issues)
-    counts[i.severity]++;
-  const checksPassed = checks.filter((c) => c.status === "pass").length;
-  const checksFailed = checks.filter((c) => c.status === "fail").length;
-  const checksSkipped = checks.filter((c) => c.status === "skipped").length;
-  const checksWarn = checks.filter((c) => c.status === "warn").length;
-  const score = Math.max(0, 100 - counts.critical * 20 - counts.high * 8 - counts.medium * 3 - counts.low * 1);
-  const status = counts.critical > 0 || checksFailed > 0 ? "fail" : counts.high > 0 || checksWarn > 0 ? "warn" : "pass";
-  return {
-    status,
-    score,
-    critical: counts.critical,
-    high: counts.high,
-    medium: counts.medium,
-    low: counts.low,
-    checksRun: checks.length,
-    checksPassed,
-    checksFailed,
-    checksSkipped
-  };
-}
-async function runWithConcurrency3(items, workers, fn) {
-  let next = 0;
-  await Promise.all(Array.from({ length: workers }, async () => {
-    while (true) {
-      const idx = next++;
-      if (idx >= items.length)
-        break;
-      await fn(items[idx]);
-    }
-  }));
-}
-async function preflightCheck(prodUrl, candUrl, viewport) {
-  const spinner = ora5("Pre-flight: verificando URLs…").start();
-  const errors = [];
-  const ua = userAgentFor(viewport);
-  async function probe(label, url) {
-    try {
-      new URL(url);
-    } catch {
-      errors.push(`${label}: URL inválida (${url})`);
-      return;
-    }
-    const controller = new AbortController;
-    const t = setTimeout(() => controller.abort(), 1e4);
-    try {
-      const res = await fetch(url, {
-        method: "GET",
-        redirect: "follow",
-        signal: controller.signal,
-        headers: {
-          "User-Agent": ua
+                  viewport: task.viewport,
+                  pages: [cap],
+                  totalDurationMs: cap.durationMs
+                });
+              } finally {
+                await page.close().catch(() => {
+                  return;
+                });
+                await ctx.close().catch(() => {
+                  return;
+                });
+              }
+            } catch {} finally {
+              done++;
+              extraSpinner.text = `[vitals extras] ${done}/${tasks.length} (último: ${task.path})`;
+            }
+          });
+          extraSpinner.succeed(`+${extraPaths.length} página(s) com vitals`);
+        } else {
+          extraSpinner.warn("Nenhuma página extra encontrada no sitemap");
         }
-      });
-      if (res.status >= 500)
-        errors.push(`${label}: HTTP ${res.status} ${res.statusText} (${url})`);
-      else if (res.status >= 400)
-        errors.push(`${label}: HTTP ${res.status} ${res.statusText} (${url})`);
-    } catch (err) {
-      const e = err;
-      const msg = e.name === "AbortError" ? "timeout (10s)" : e.message;
-      errors.push(`${label}: ${msg} (${url})`);
-    } finally {
-      clearTimeout(t);
-    }
-  }
-  await Promise.all([probe("prod", prodUrl), probe("cand", candUrl)]);
-  if (errors.length > 0) {
-    spinner.fail("Pre-flight falhou");
-    return { ok: false, errors };
-  }
-  spinner.succeed("Pre-flight OK");
-  return { ok: true, errors: [] };
-}
-function addCacheBuster(url) {
-  try {
-    const u = new URL(url);
-    u.searchParams.set("_pcb", String(Date.now()));
-    return u.toString();
-  } catch {
-    return url;
-  }
-}
-async function warmupTargets(opts) {
-  const headers = opts.bypassCache ? { "Cache-Control": "no-cache", Pragma: "no-cache" } : {};
-  const jobs = [];
-  for (const url of opts.urls) {
-    for (const viewport of opts.viewports) {
-      const ua = userAgentFor(viewport);
-      const target = addCacheBuster(url);
-      jobs.push(fetch(target, {
-        method: "GET",
-        redirect: "follow",
-        headers: { ...headers, "User-Agent": ua }
-      }).then((res) => res.ok || res.status >= 200 && res.status < 400 ? { ok: true } : { ok: false, url, viewport, reason: `HTTP ${res.status} ${res.statusText}` }).catch((err) => ({
-        ok: false,
-        url,
-        viewport,
-        reason: err.message ?? "fetch failed"
-      })));
+      } catch (err) {
+        extraSpinner.warn(`vitals extras pulado: ${err.message}`);
+      }
     }
-  }
-  const results = await Promise.all(jobs);
-  const succeeded = results.filter((r) => r.ok).length;
-  const failed = results.filter((r) => !r.ok).map(({ url, viewport, reason }) => ({ url, viewport, reason }));
-  return { attempted: results.length, succeeded, failed };
-}
-async function fetchHomeHtml(url, viewport = "desktop") {
-  try {
-    const res = await fetch(url, {
-      headers: {
-        "User-Agent": userAgentFor(viewport),
-        Accept: "text/html,application/xhtml+xml",
-        "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8"
-      },
-      redirect: "follow"
-    });
-    if (!res.ok)
-      return null;
-    return await res.text();
-  } catch {
-    return null;
-  }
-}
-function findPdpCapture(flows, side) {
-  for (const fc of flows) {
-    if (fc.side !== side)
-      continue;
-    if (fc.flow !== "purchase-journey" && fc.flow !== "pdp")
-      continue;
-    const last = fc.pages[fc.pages.length - 1];
-    if (last)
-      return last;
-  }
-  return;
-}
-function hostOf2(url) {
-  try {
-    return new URL(url).hostname;
-  } catch {
-    return url;
-  }
-}
-function printSummary5(run, htmlPath, meta) {
-  const { verdict } = run;
-  const emoji = verdict.status === "pass" ? chalk17.green("✔") : verdict.status === "warn" ? chalk17.yellow("⚠") : chalk17.red("✖");
-  const score = verdict.status === "pass" ? chalk17.green(verdict.score) : verdict.status === "warn" ? chalk17.yellow(verdict.score) : chalk17.red(verdict.score);
-  console.log("");
-  console.log(`  ${emoji}  parity ${verdict.status.toUpperCase()} · score ${score}/100`);
-  console.log(`     checks: ${chalk17.green(verdict.checksPassed)} pass · ${chalk17.red(verdict.checksFailed)} fail · ${chalk17.dim(`${verdict.checksSkipped} skipped`)}`);
-  console.log(`     issues: ${chalk17.red(verdict.critical)} critical · ${chalk17.yellow(verdict.high)} high · ${verdict.medium} medium · ${chalk17.dim(`${verdict.low} low`)}`);
-  if (run.topIssues.length > 0) {
-    console.log("");
-    console.log(chalk17.bold("  Top issues:"));
-    for (const i of run.topIssues.slice(0, 5)) {
-      const sev = i.severity === "critical" ? chalk17.red(`[${i.severity}]`) : i.severity === "high" ? chalk17.yellow(`[${i.severity}]`) : chalk17.dim(`[${i.severity}]`);
-      console.log(`     ${sev} ${i.summary}`);
+    const visualPagesLimit = opts.noVisualDiff ? 0 : opts.visualPages ?? 5;
+    if (browser && visualPagesLimit > 0) {
+      const visualSpinner = ora5("Descobrindo páginas pra visual diff…").start();
+      try {
+        const sample = await discoverPagesFromSitemap(opts.prod, { sampleSize: visualPagesLimit });
+        const visualPaths = sample.all.map((p) => p.path);
+        const alreadyCapturedKeys = new Set;
+        for (const p of allPageCaptures) {
+          try {
+            alreadyCapturedKeys.add(`${new URL(p.url).pathname}::${p.viewport}::${p.side}`);
+          } catch {}
+        }
+        const tasks = [];
+        for (const viewport of viewports) {
+          for (const path of visualPaths) {
+            for (const side of ["prod", "cand"]) {
+              if (alreadyCapturedKeys.has(`${path}::${viewport}::${side}`))
+                continue;
+              tasks.push({ path, viewport, side });
+            }
+          }
+        }
+        if (tasks.length === 0) {
+          visualSpinner.succeed(`Visual diff: páginas já capturadas em flows (${visualPaths.length} alvos)`);
+        } else {
+          visualSpinner.text = `Visual diff: capturando ${tasks.length} screenshot(s) (${visualPaths.length} páginas × ${viewports.length} viewport(s) × 2 sides)…`;
+          let done = 0;
+          await runWithConcurrency3(tasks, 4, async (task) => {
+            const baseUrl = task.side === "prod" ? opts.prod : opts.cand;
+            const fullUrl = new URL(task.path, baseUrl).toString();
+            const safePath2 = task.path.replace(/[/?&=]+/g, "_") || "_root";
+            const screenshotPath2 = `${paths.screenshotsDir}/visual-${safePath2}-${task.viewport}-${task.side}.png`;
+            try {
+              const ctx = await newContext(browser, { viewport: task.viewport, cohortCookieValue: "control", noCache: opts.bypassCache });
+              await installVitalsCollector(ctx);
+              const page = await ctx.newPage();
+              try {
+                const cap = await capturePage(page, {
+                  url: fullUrl,
+                  side: task.side,
+                  viewport: task.viewport,
+                  screenshotPath: screenshotPath2,
+                  settleMs: 1800,
+                  timeoutMs: 30000,
+                  scrollToLoad: true
+                });
+                allPageCaptures.push(cap);
+              } finally {
+                await page.close().catch(() => {
+                  return;
+                });
+                await ctx.close().catch(() => {
+                  return;
+                });
+              }
+            } catch {} finally {
+              done++;
+              visualSpinner.text = `[visual] ${done}/${tasks.length} (último: ${task.path})`;
+            }
+          });
+          visualSpinner.succeed(`Visual diff: ${tasks.length} screenshot(s) capturado(s)`);
+        }
+      } catch (err) {
+        visualSpinner.warn(`Visual diff descoberta pulada: ${err.message}`);
+      }
     }
-  }
-  if (meta.promotedCount > 0 || meta.deprecatedCount > 0) {
-    console.log("");
-    console.log(chalk17.dim(`  \uD83D\uDCDA learned-selectors [${meta.platform}]: ${chalk17.green(`+${meta.promotedCount}`)} promoted · ${chalk17.yellow(meta.deprecatedCount)} deprecated`));
-  }
-  console.log("");
-  console.log(chalk17.dim(`  → ${htmlPath}`));
-  console.log("");
-}
-
-// src/commands/section.ts
-import { mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
-import chalk18 from "chalk";
-import * as cheerio8 from "cheerio";
-import * as diff2 from "diff";
-import prettier2 from "prettier";
-
-// src/engine/computed-styles.ts
-var SECTION_STYLE_KEYS = [
-  "display",
-  "visibility",
-  "opacity",
-  "position",
-  "z-index",
-  "top",
-  "right",
-  "bottom",
-  "left",
-  "width",
-  "height",
-  "max-width",
-  "max-height",
-  "min-width",
-  "min-height",
-  "transform",
-  "clip-path",
-  "overflow",
-  "overflow-x",
-  "overflow-y",
-  "margin",
-  "padding",
-  "border",
-  "font-size",
-  "font-weight",
-  "color",
-  "background-color",
-  "background-image",
-  "flex-direction",
-  "justify-content",
-  "align-items",
-  "gap",
-  "grid-template-columns",
-  "grid-template-rows"
-];
-async function readComputedStyles(page, selector) {
-  const keys = SECTION_STYLE_KEYS;
-  let exists = false;
-  try {
-    exists = await page.locator(selector).count() > 0;
-  } catch (err) {
-    return { found: false, error: `seletor inválido: ${err.message}` };
-  }
-  if (!exists) {
-    return { found: false, error: `seletor '${selector}' não casou nenhum elemento` };
-  }
-  const hiddenByPlaywright = !await page.locator(selector).first().isVisible({ timeout: 1000 }).catch(() => false);
-  let got;
-  try {
-    got = await page.evaluate(({ sel, keys: keys2 }) => {
+    spinner.start("Rodando checks…");
+    const checkCtx = {
+      prodPages: allPageCaptures.filter((p) => p.side === "prod"),
+      candPages: allPageCaptures.filter((p) => p.side === "cand"),
+      prodFlows: allFlowCaptures.filter((f) => f.side === "prod"),
+      candFlows: allFlowCaptures.filter((f) => f.side === "cand"),
+      rc,
+      ignore,
+      outDir: paths.runDir,
+      viewports
+    };
+    const checks = await runAllChecks(checkCtx);
+    spinner.succeed(`Checks concluídos (${checks.length})`);
+    const allIssues = checks.flatMap((c) => c.issues);
+    spinner.start(isLlmAvailable() ? "Agregando issues via LLM (Sonnet 4.6)…" : "Agregando issues (modo offline)…");
+    const topIssues = await aggregateIssues({
+      runId,
+      prodUrl: opts.prod,
+      candUrl: opts.cand,
+      viewports,
+      flows,
+      checks
+    });
+    spinner.succeed(`${topIssues.length} issue(s) priorizada(s)`);
+    const verdict2 = computeVerdict3(checks, allIssues);
+    let baselineSection;
+    if (opts.baseline) {
       try {
-        const el = document.querySelector(sel);
-        if (!el || !(el instanceof HTMLElement)) {
-          return { ok: false, reason: "querySelector retornou null ou non-HTMLElement" };
-        }
-        const cs = window.getComputedStyle(el);
-        const out = {};
-        for (const k of keys2)
-          out[k] = cs.getPropertyValue(k) || "";
-        const r = el.getBoundingClientRect();
-        return {
-          ok: true,
-          styles: out,
-          rect: { x: r.x, y: r.y, width: r.width, height: r.height }
+        const bl = loadBaseline(opts.baseline);
+        const delta = compareToBaseline({
+          id: runId,
+          issues: allIssues
+        }, bl);
+        baselineSection = {
+          name: opts.baseline,
+          delta: {
+            resolved: bl.issues.filter((i) => delta.resolved.includes(i.id)),
+            new: allIssues.filter((i) => delta.new.includes(i.id)),
+            regressions: allIssues.filter((i) => delta.regressions.includes(i.id))
+          }
         };
       } catch (err) {
-        return {
-          ok: false,
-          reason: `document.querySelector inválido em '${sel}': ${err.message ?? "syntax error"}`
-        };
+        spinner.warn(`Baseline "${opts.baseline}" não carregou: ${err.message}`);
       }
-    }, { sel: selector, keys });
-  } catch (err) {
-    return {
-      found: false,
-      error: `falha no page.evaluate de '${selector}': ${err.message ?? "unknown"}. Se o seletor usa sintaxe Playwright-only (text=..., :visible, xpath=...), use um seletor CSS puro.`
+    }
+    const visualCheck = checks.find((c) => c.name === "visual-regression-keyframes");
+    const visualDiff = visualCheck?.data?.visualDiff;
+    const seoCheck = checks.find((c) => c.name === "seo-deep-audit");
+    const seo = seoCheck?.data?.seo;
+    const run = {
+      schemaVersion: "0.1",
+      id: runId,
+      timestamp,
+      prodUrl: opts.prod,
+      candUrl: opts.cand,
+      flows,
+      viewports,
+      cep: rc.cep,
+      durationMs: Date.now() - startedAt,
+      verdict: verdict2,
+      topIssues,
+      issues: allIssues,
+      checks,
+      flowCaptures: allFlowCaptures,
+      visualDiff,
+      seo,
+      baseline: baselineSection
     };
-  }
-  if (!got.ok) {
-    return { found: false, error: got.reason };
-  }
-  return { found: true, styles: got.styles, rect: got.rect, hiddenByPlaywright };
-}
-
-// src/commands/section.ts
-async function sectionCommand(opts) {
-  const viewport = parseViewport4(opts.viewport);
-  if (!viewport) {
-    console.error(chalk18.red(`viewport inválido: ${opts.viewport} (use mobile|desktop|tablet)`));
-    return 2;
-  }
-  const waitMs = Number.parseInt(opts.wait, 10);
-  if (!Number.isFinite(waitMs) || waitMs < 0) {
-    console.error(chalk18.red(`--wait inválido: ${opts.wait}`));
-    return 2;
-  }
-  if (!opts.selector || opts.selector.trim().length === 0) {
-    console.error(chalk18.red("--selector é obrigatório"));
-    return 2;
-  }
-  if (!isValidUrl2(opts.prod) || !isValidUrl2(opts.cand)) {
-    console.error(chalk18.red("--prod ou --cand inválido"));
-    return 2;
-  }
-  const facetsAsked = Boolean(opts.outputHtml) || Boolean(opts.screenshot) || Boolean(opts.computedStyles);
-  const want = {
-    html: facetsAsked ? Boolean(opts.outputHtml) : true,
-    screenshot: facetsAsked ? Boolean(opts.screenshot) : true,
-    styles: facetsAsked ? Boolean(opts.computedStyles) : true
-  };
-  mkdirSync6(opts.outDir, { recursive: true });
-  const hash2 = hashSelector(opts.selector);
-  const screenshotPaths = {
-    prod: resolve2(opts.outDir, `section-${hash2}-${viewport}-prod.png`),
-    cand: resolve2(opts.outDir, `section-${hash2}-${viewport}-cand.png`)
-  };
-  const browser = await launchBrowser({ headless: true });
-  try {
-    const [prodSide, candSide] = await Promise.all([
-      gatherSide(browser, {
-        url: opts.prod,
-        viewport,
-        waitMs,
-        selector: opts.selector,
-        wantScreenshot: want.screenshot,
-        wantStyles: want.styles,
-        wantHtml: want.html,
-        screenshotPath: screenshotPaths.prod
-      }),
-      gatherSide(browser, {
-        url: opts.cand,
-        viewport,
-        waitMs,
-        selector: opts.selector,
-        wantScreenshot: want.screenshot,
-        wantStyles: want.styles,
-        wantHtml: want.html,
-        screenshotPath: screenshotPaths.cand
-      })
-    ]);
-    if (opts.json) {
-      console.log(JSON.stringify({
-        prod: opts.prod,
-        cand: opts.cand,
-        selector: opts.selector,
-        viewport,
-        prodSide,
-        candSide,
-        screenshotPaths: want.screenshot ? screenshotPaths : null
-      }));
-      return verdict(prodSide, candSide);
+    writeRunReportJson(paths.runDir, run);
+    const html = renderHtmlReport(run, paths.runDir);
+    writeRunReportHtml(paths.runDir, html);
+    printSummary5(run, paths.reportHtml, { promotedCount, deprecatedCount, platform });
+    if (opts.ci) {
+      const blocking = allIssues.filter((i) => failOn.includes(i.severity));
+      if (blocking.length > 0) {
+        console.log(chalk18.red(`
+  ✖ ${blocking.length} issue(s) bloqueante(s) [${failOn.join(", ")}] — exit 1`));
+        return 1;
+      }
     }
-    await printResults2({ opts, viewport, prodSide, candSide, screenshotPaths, want });
-    return verdict(prodSide, candSide);
+    if (opts.open) {
+      if (browser) {
+        await browser.close().catch(() => {
+          return;
+        });
+        browser = null;
+      }
+      return await serveRunAndBlock(paths.runDir, { label: `parity run · ${runId}` });
+    }
+    return 0;
+  } catch (err) {
+    spinner.fail(`Erro: ${err.message}`);
+    console.error(err);
+    return 2;
   } finally {
-    await browser.close().catch(() => {
-      return;
-    });
+    if (browser)
+      await browser.close().catch(() => {
+        return;
+      });
   }
 }
-async function gatherSide(browser, opts) {
-  const ctx = await newContext(browser, { viewport: opts.viewport });
-  const page = await ctx.newPage();
-  const result = {
-    html: null,
-    styles: null,
-    screenshotTaken: false
+function computeVerdict3(checks, issues) {
+  const counts = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const i of issues)
+    counts[i.severity]++;
+  const checksPassed = checks.filter((c) => c.status === "pass").length;
+  const checksFailed = checks.filter((c) => c.status === "fail").length;
+  const checksSkipped = checks.filter((c) => c.status === "skipped").length;
+  const checksWarn = checks.filter((c) => c.status === "warn").length;
+  const score = Math.max(0, 100 - counts.critical * 20 - counts.high * 8 - counts.medium * 3 - counts.low * 1);
+  const status = counts.critical > 0 || checksFailed > 0 ? "fail" : counts.high > 0 || checksWarn > 0 ? "warn" : "pass";
+  return {
+    status,
+    score,
+    critical: counts.critical,
+    high: counts.high,
+    medium: counts.medium,
+    low: counts.low,
+    checksRun: checks.length,
+    checksPassed,
+    checksFailed,
+    checksSkipped
   };
-  try {
-    await page.goto(opts.url, { waitUntil: "domcontentloaded", timeout: 30000 });
-    await page.waitForLoadState("networkidle", { timeout: 8000 }).catch(() => {
-      return;
-    });
-    if (opts.waitMs > 0)
-      await page.waitForTimeout(opts.waitMs);
-    await Promise.race([
-      stabilizeCarousels(page).catch(() => {
-        return;
-      }),
-      new Promise((resolve3) => setTimeout(resolve3, 3000))
-    ]);
-    if (opts.wantHtml) {
-      try {
-        const fullHtml = await page.content();
-        const $ = cheerio8.load(fullHtml);
-        const matches = $(opts.selector);
-        if (matches.length === 0) {
-          result.htmlError = `seletor '${opts.selector}' não casou nenhum elemento`;
-        } else {
-          result.html = $.html(matches.first());
-        }
-      } catch (err) {
-        result.htmlError = `falha lendo HTML: ${err.message}`;
-      }
+}
+async function runWithConcurrency3(items, workers, fn) {
+  let next = 0;
+  await Promise.all(Array.from({ length: workers }, async () => {
+    while (true) {
+      const idx = next++;
+      if (idx >= items.length)
+        break;
+      await fn(items[idx]);
     }
-    if (opts.wantStyles) {
-      result.styles = await readComputedStyles(page, opts.selector);
+  }));
+}
+async function preflightCheck(prodUrl, candUrl, viewport) {
+  const spinner = ora5("Pre-flight: verificando URLs…").start();
+  const errors = [];
+  const ua = userAgentFor(viewport);
+  async function probe(label, url) {
+    try {
+      new URL(url);
+    } catch {
+      errors.push(`${label}: URL inválida (${url})`);
+      return;
     }
-    if (opts.wantScreenshot) {
-      await captureSectionScreenshot(page, opts.selector, opts.screenshotPath).then((err) => {
-        if (err)
-          result.screenshotError = err;
-        else
-          result.screenshotTaken = true;
+    const controller = new AbortController;
+    const t = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        redirect: "follow",
+        signal: controller.signal,
+        headers: {
+          "User-Agent": ua
+        }
       });
+      if (res.status >= 500)
+        errors.push(`${label}: HTTP ${res.status} ${res.statusText} (${url})`);
+      else if (res.status >= 400)
+        errors.push(`${label}: HTTP ${res.status} ${res.statusText} (${url})`);
+    } catch (err) {
+      const e = err;
+      const msg = e.name === "AbortError" ? "timeout (10s)" : e.message;
+      errors.push(`${label}: ${msg} (${url})`);
+    } finally {
+      clearTimeout(t);
     }
-  } finally {
-    await page.close().catch(() => {
-      return;
-    });
-    await ctx.close().catch(() => {
-      return;
-    });
   }
-  return result;
+  await Promise.all([probe("prod", prodUrl), probe("cand", candUrl)]);
+  if (errors.length > 0) {
+    spinner.fail("Pre-flight falhou");
+    return { ok: false, errors };
+  }
+  spinner.succeed("Pre-flight OK");
+  return { ok: true, errors: [] };
 }
-async function captureSectionScreenshot(page, selector, outPath) {
+function addCacheBuster(url) {
   try {
-    const loc = page.locator(selector).first();
-    if (await loc.count() === 0) {
-      return `seletor '${selector}' não casou nenhum elemento`;
+    const u = new URL(url);
+    u.searchParams.set("_pcb", String(Date.now()));
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+async function warmupTargets(opts) {
+  const headers = opts.bypassCache ? { "Cache-Control": "no-cache", Pragma: "no-cache" } : {};
+  const jobs = [];
+  for (const url of opts.urls) {
+    for (const viewport of opts.viewports) {
+      const ua = userAgentFor(viewport);
+      const target = addCacheBuster(url);
+      jobs.push(fetch(target, {
+        method: "GET",
+        redirect: "follow",
+        headers: { ...headers, "User-Agent": ua }
+      }).then((res) => res.ok || res.status >= 200 && res.status < 400 ? { ok: true } : { ok: false, url, viewport, reason: `HTTP ${res.status} ${res.statusText}` }).catch((err) => ({
+        ok: false,
+        url,
+        viewport,
+        reason: err.message ?? "fetch failed"
+      })));
     }
-    await loc.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {
-      return;
-    });
-    await loc.screenshot({ path: outPath, timeout: 8000 });
-    return null;
-  } catch (err) {
-    return `falha no screenshot: ${err.message}`;
   }
+  const results = await Promise.all(jobs);
+  const succeeded = results.filter((r) => r.ok).length;
+  const failed = results.filter((r) => !r.ok).map(({ url, viewport, reason }) => ({ url, viewport, reason }));
+  return { attempted: results.length, succeeded, failed };
 }
-function isValidUrl2(s) {
+async function fetchHomeHtml(url, viewport = "desktop") {
   try {
-    new URL(s);
-    return true;
+    const res = await fetch(url, {
+      headers: {
+        "User-Agent": userAgentFor(viewport),
+        Accept: "text/html,application/xhtml+xml",
+        "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8"
+      },
+      redirect: "follow"
+    });
+    if (!res.ok)
+      return null;
+    return await res.text();
   } catch {
-    return false;
+    return null;
   }
 }
-function parseViewport4(raw) {
-  if (raw === "mobile" || raw === "desktop" || raw === "tablet")
-    return raw;
-  return null;
-}
-function hashSelector(selector) {
-  let h = 0;
-  for (let i = 0;i < selector.length; i++) {
-    h = (h << 5) - h + selector.charCodeAt(i);
-    h |= 0;
+function findPdpCapture(flows, side) {
+  for (const fc of flows) {
+    if (fc.side !== side)
+      continue;
+    if (fc.flow !== "purchase-journey" && fc.flow !== "pdp")
+      continue;
+    const last = fc.pages[fc.pages.length - 1];
+    if (last)
+      return last;
   }
-  return (h >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+  return;
 }
-function verdict(prod, cand) {
-  if (prod.htmlError || cand.htmlError)
-    return 1;
-  if (prod.styles && "found" in prod.styles && cand.styles && "found" in cand.styles) {
-    if (prod.styles.found && cand.styles.found) {
-      for (const k of SECTION_STYLE_KEYS) {
-        if (prod.styles.styles[k] !== cand.styles.styles[k])
-          return 1;
-      }
-      if (prod.styles.hiddenByPlaywright !== cand.styles.hiddenByPlaywright)
-        return 1;
-      const pr = prod.styles.rect;
-      const cr = cand.styles.rect;
-      if (pr && cr && (pr.width !== cr.width || pr.height !== cr.height))
-        return 1;
-    } else if (prod.styles.found !== cand.styles.found) {
-      return 1;
-    }
-  }
-  if (prod.html && cand.html) {
-    if (prod.html !== cand.html)
-      return 1;
+function hostOf2(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
   }
-  return 0;
 }
-async function printResults2(args) {
-  const { opts, viewport, prodSide, candSide, screenshotPaths, want } = args;
-  console.log(chalk18.bold(`
-  parity section`));
-  console.log(chalk18.dim(`  selector: ${opts.selector}`));
-  console.log(chalk18.dim(`  viewport: ${viewport}`));
-  console.log(chalk18.dim(`  prod:     ${opts.prod}`));
-  console.log(chalk18.dim(`  cand:     ${opts.cand}`));
+function printSummary5(run, htmlPath, meta) {
+  const { verdict: verdict2 } = run;
+  const emoji = verdict2.status === "pass" ? chalk18.green("✔") : verdict2.status === "warn" ? chalk18.yellow("⚠") : chalk18.red("✖");
+  const score = verdict2.status === "pass" ? chalk18.green(verdict2.score) : verdict2.status === "warn" ? chalk18.yellow(verdict2.score) : chalk18.red(verdict2.score);
   console.log("");
-  if (want.html)
-    await printHtmlDiff(prodSide, candSide, opts.selector);
-  if (want.styles)
-    printStylesDiff(prodSide, candSide);
-  if (want.screenshot)
-    printScreenshotPaths(prodSide, candSide, screenshotPaths);
-}
-async function printHtmlDiff(prod, cand, selector) {
-  console.log(chalk18.bold("  HTML diff"));
-  if (prod.htmlError) {
-    console.log(chalk18.red(`    prod: ${prod.htmlError}`));
-    return;
-  }
-  if (cand.htmlError) {
-    console.log(chalk18.red(`    cand: ${cand.htmlError}`));
-    return;
-  }
-  if (!prod.html || !cand.html) {
-    console.log(chalk18.dim("    (nenhum lado tem HTML disponível)"));
-    return;
-  }
-  const [prodFmt, candFmt] = await Promise.all([formatHtml(prod.html), formatHtml(cand.html)]);
-  if (prodFmt === candFmt) {
-    console.log(chalk18.green("    ✓ idêntico após pretty-print"));
+  console.log(`  ${emoji}  parity ${verdict2.status.toUpperCase()} · score ${score}/100`);
+  console.log(`     checks: ${chalk18.green(verdict2.checksPassed)} pass · ${chalk18.red(verdict2.checksFailed)} fail · ${chalk18.dim(`${verdict2.checksSkipped} skipped`)}`);
+  console.log(`     issues: ${chalk18.red(verdict2.critical)} critical · ${chalk18.yellow(verdict2.high)} high · ${verdict2.medium} medium · ${chalk18.dim(`${verdict2.low} low`)}`);
+  if (run.topIssues.length > 0) {
     console.log("");
-    return;
-  }
-  const patch = diff2.createPatch(selector, prodFmt, candFmt, "prod", "cand");
-  console.log(colorPatch(patch));
-  console.log("");
-}
-function printStylesDiff(prod, cand) {
-  console.log(chalk18.bold("  Computed styles diff"));
-  if (!prod.styles || !cand.styles) {
-    console.log(chalk18.dim("    (styles não foram coletados)"));
-    return;
-  }
-  if (!prod.styles.found) {
-    console.log(chalk18.red(`    prod: ${prod.styles.error}`));
-    return;
-  }
-  if (!cand.styles.found) {
-    console.log(chalk18.red(`    cand: ${cand.styles.error}`));
-    return;
-  }
-  const rows = [];
-  for (const k of SECTION_STYLE_KEYS) {
-    const p = prod.styles.styles[k] ?? "";
-    const c = cand.styles.styles[k] ?? "";
-    if (p !== c)
-      rows.push({ key: k, prod: p, cand: c });
-  }
-  if (prod.styles.hiddenByPlaywright !== cand.styles.hiddenByPlaywright) {
-    rows.unshift({
-      key: "(playwright isVisible)",
-      prod: prod.styles.hiddenByPlaywright ? "hidden" : "visible",
-      cand: cand.styles.hiddenByPlaywright ? "hidden" : "visible"
-    });
-  }
-  const prodRect = prod.styles.rect;
-  const candRect = cand.styles.rect;
-  if (prodRect && candRect && (prodRect.width !== candRect.width || prodRect.height !== candRect.height)) {
-    rows.unshift({
-      key: "(boundingRect)",
-      prod: `${prodRect.width}×${prodRect.height} @ ${prodRect.x},${prodRect.y}`,
-      cand: `${candRect.width}×${candRect.height} @ ${candRect.x},${candRect.y}`
-    });
+    console.log(chalk18.bold("  Top issues:"));
+    for (const i of run.topIssues.slice(0, 5)) {
+      const sev = i.severity === "critical" ? chalk18.red(`[${i.severity}]`) : i.severity === "high" ? chalk18.yellow(`[${i.severity}]`) : chalk18.dim(`[${i.severity}]`);
+      console.log(`     ${sev} ${i.summary}`);
+    }
   }
-  if (rows.length === 0) {
-    console.log(chalk18.green("    ✓ todos os SECTION_STYLE_KEYS são iguais"));
+  if (meta.promotedCount > 0 || meta.deprecatedCount > 0) {
     console.log("");
-    return;
-  }
-  const keyWidth = Math.max(...rows.map((r) => r.key.length));
-  for (const r of rows) {
-    console.log(`    ${chalk18.cyan(r.key.padEnd(keyWidth))}  ${chalk18.red(`prod=${r.prod || "(vazio)"}`)}  ${chalk18.green(`cand=${r.cand || "(vazio)"}`)}`);
+    console.log(chalk18.dim(`  \uD83D\uDCDA learned-selectors [${meta.platform}]: ${chalk18.green(`+${meta.promotedCount}`)} promoted · ${chalk18.yellow(meta.deprecatedCount)} deprecated`));
   }
   console.log("");
-}
-function printScreenshotPaths(prod, cand, paths) {
-  console.log(chalk18.bold("  Screenshots"));
-  if (prod.screenshotError) {
-    console.log(chalk18.red(`    prod: ${prod.screenshotError}`));
-  } else if (prod.screenshotTaken) {
-    console.log(`    prod: ${chalk18.dim(paths.prod)}`);
-  }
-  if (cand.screenshotError) {
-    console.log(chalk18.red(`    cand: ${cand.screenshotError}`));
-  } else if (cand.screenshotTaken) {
-    console.log(`    cand: ${chalk18.dim(paths.cand)}`);
-  }
+  console.log(chalk18.dim(`  → ${htmlPath}`));
   console.log("");
 }
-async function formatHtml(raw) {
-  try {
-    return await prettier2.format(raw, {
-      parser: "html",
-      printWidth: 100,
-      htmlWhitespaceSensitivity: "ignore"
-    });
-  } catch {
-    return raw;
-  }
-}
-function colorPatch(patch) {
-  const lines = patch.split(`
-`);
-  const out = [];
-  for (const line of lines) {
-    if (line.startsWith("Index:") || line.startsWith("==="))
-      continue;
-    if (line.startsWith("---") || line.startsWith("+++"))
-      out.push(chalk18.dim(line));
-    else if (line.startsWith("@@"))
-      out.push(chalk18.cyan(line));
-    else if (line.startsWith("+"))
-      out.push(chalk18.green(line));
-    else if (line.startsWith("-"))
-      out.push(chalk18.red(line));
-    else
-      out.push(line);
-  }
-  return out.join(`
-`);
-}
 
 // src/cli.ts
 var program = new Command;
@@ -13924,7 +14577,7 @@ program.command("check").argument("<name>", "check name (kebab-case, e.g. consol
     json: opts.json
   }));
 });
-program.command("section").description("Focused prod×cand comparison of one section: HTML diff + screenshot + computed-styles diff. No flags = all 3 facets. Designed for the 'in DOM but invisible' debug loop (issue #31).").requiredOption("--prod <url>", "Production URL (base, e.g. https://www.example.com)").requiredOption("--cand <url>", "Candidate URL (base, e.g. https://example.deco-cx.workers.dev)").requiredOption("--selector <sel>", "CSS selector for the section to compare").option("--output-html", "Include the HTML diff facet (default: on if no facet flag passed)", false).option("--screenshot", "Include the screenshot facet (locator screenshot per side)", false).option("--computed-styles", "Include the computed-styles diff facet", false).option("--viewport <viewport>", "mobile | desktop | tablet", "mobile").option("--wait <ms>", "Extra ms after networkidle so hydration settles", "2000").option("--out-dir <dir>", "Where to write the screenshots", "./parity-output/sections").option("--json", "Emit one-line JSON instead of pretty text", false).action(async (opts) => {
+program.command("section").description("Focused prod×cand comparison of one section: HTML diff + screenshot + computed-styles diff. No flags = all 3 facets. Designed for the 'in DOM but invisible' debug loop (issue #31).").requiredOption("--prod <url>", "Production URL (base, e.g. https://www.example.com)").requiredOption("--cand <url>", "Candidate URL (base, e.g. https://example.deco-cx.workers.dev)").requiredOption("--selector <sel>", "CSS selector for the section to compare").option("--output-html", "Include the HTML diff facet (default: on if no facet flag passed)", false).option("--screenshot", "Include the screenshot facet (locator screenshot per side)", false).option("--computed-styles", "Include the computed-styles diff facet", false).option("--heatmap", "Run pixelmatch on the two screenshots and analyze diff regions (bounding box + hotspots). Implies --screenshot.", false).option("--css-source", "For each divergent computed-style property, resolve which CSS rule (stylesheet + selector) produced it via CDP. Useful when the LLM needs to know which file to edit.", false).option("--prompt", "Emit an LLM-ready bundle: <prefix>-bundle.json (machine-readable) + <prefix>-prompt.md (opinionated Markdown with embedded images). Implies all signals.", false).option("--llm-summary", "After building the bundle, invoke Claude (needs ANTHROPIC_API_KEY) and print a 1-paragraph 'what I understood' summary. Does NOT generate a patch. Implies --prompt.", false).option("--viewport <viewport>", "mobile | desktop | tablet", "mobile").option("--wait <ms>", "Extra ms after networkidle so hydration settles", "2000").option("--out-dir <dir>", "Where to write the screenshots", "./parity-output/sections").option("--json", "Emit one-line JSON instead of pretty text", false).action(async (opts) => {
   process.exit(await sectionCommand({
     prod: opts.prod,
     cand: opts.cand,
@@ -13932,12 +14585,28 @@ program.command("section").description("Focused prod×cand comparison of one sec
     outputHtml: opts.outputHtml,
     screenshot: opts.screenshot,
     computedStyles: opts.computedStyles,
+    heatmap: opts.heatmap,
+    cssSource: opts.cssSource,
+    prompt: opts.prompt,
+    llmSummary: opts.llmSummary,
     viewport: opts.viewport,
     wait: opts.wait,
     outDir: opts.outDir,
     json: opts.json
   }));
 });
+program.command("fix").description("Pixel-perfect debug shortcut: run `parity section` with ALL signals on (HTML + screenshot + computed-styles + heatmap + CSS source) and emit an LLM-ready Markdown bundle. When ANTHROPIC_API_KEY is set, also prints a 1-paragraph summary of what Claude understood from the signals — does NOT generate a patch (you ask for that in a follow-up turn).").requiredOption("--prod <url>", "Production URL (source of truth)").requiredOption("--cand <url>", "Candidate URL (migrated)").requiredOption("--selector <sel>", "CSS selector for the section to fix").option("--viewport <viewport>", "mobile | desktop | tablet", "mobile").option("--wait <ms>", "Extra ms after networkidle so hydration settles", "2000").option("--out-dir <dir>", "Where to write the bundle + screenshots", "./parity-output/sections").option("--json", "Emit one-line JSON instead of pretty text", false).option("--no-llm", "Skip the LLM call (still writes the markdown bundle). Use when offline or to avoid API costs.").action(async (opts) => {
+  process.exit(await fixCommand({
+    prod: opts.prod,
+    cand: opts.cand,
+    selector: opts.selector,
+    viewport: opts.viewport,
+    wait: opts.wait,
+    outDir: opts.outDir,
+    json: opts.json,
+    noLlm: !opts.llm
+  }));
+});
 program.command("learned").description("Inspect the learned-selectors library").addCommand(new Command("stats").description("Print learned-selectors stats per platform").action(() => {
   process.exit(learnedStats());
 }));