cdp-edge 1.18.3 → 1.20.0

package/server-edge-tracker/modules/ml/ltv.js

@@ -0,0 +1,420 @@
+/**
+ * CDP Edge — LTV Prediction + A/B Testing de Prompts (Fases 3 e 4)
+ * predictLtv, getLtvAbVariation, recordAbAssignment, handlers /api/ltv/*
+ */
+
+import { extractFeatures, predictWithWeights, loadActiveWeights } from './logistic.js';
+
+// Cache key para o teste ativo (KV — evita hit no D1 a cada request /track)
+const AB_LTV_CACHE_KEY = 'ab_ltv_active_test';
+
+// ── predictLtv — Heurística em 5 dimensões (0-100 pts) ───────────────────────
+export async function predictLtv(env, payload, request, customSystemPrompt = null) {
+  // ── Tentar modelo treinado (regressão logística real) ─────────────────────
+  // Se existir modelo ativo no KV/D1, usa-o em vez da heurística manual.
+  // Fallback automático para heurística se modelo não disponível.
+  try {
+    const model = await loadActiveWeights(env);
+    if (model?.weights?.length) {
+      const hour    = new Date().getUTCHours();
+      const country = (payload.country || request?.cf?.country || '').toUpperCase();
+      const features = extractFeatures({
+        utm_source:      payload.utmSource,
+        engagement_score: parseFloat(payload.engagementScore || 0),
+        intention_level: payload.intentionLevel,
+        days_since_lead: 0,  // evento atual = recência máxima
+        has_email:       !!payload.email,
+        has_phone:       !!payload.phone,
+        is_br:           country === 'BR',
+        hour,
+      });
+
+      const score100 = predictWithWeights(model, features);
+      const ltvClass    = score100 >= 70 ? 'High' : score100 >= 40 ? 'Medium' : 'Low';
+      const ltvMultiplier = score100 >= 70 ? 3.5 : score100 >= 40 ? 1.8 : 0.8;
+      const productValue  = payload.value ? parseFloat(payload.value) : 0;
+      const baseValue     = productValue > 0 ? productValue : 197;
+      const predictedValue = Math.round(baseValue * ltvMultiplier * 100) / 100;
+
+      return { score: score100, class: ltvClass, value: predictedValue, source: 'model' };
+    }
+  } catch { /* fallback para heurística */ }
+
+  let score = 0;
+
+  // 1. Engajamento browser (0–30)
+  const engScore  = parseFloat(payload.engagementScore || 0);
+  const userScore = parseFloat(payload.userScore || 0);
+  score += Math.min(15, Math.round((engScore / 5) * 15));
+  score += Math.min(15, Math.round((userScore / 100) * 15));
+
+  // 2. Origem de tráfego (0–25)
+  const src = (payload.utmSource || '').toLowerCase();
+  const utm_score_map = {
+    facebook: 25, instagram: 25, meta: 25,
+    google: 22, youtube: 22, tiktok: 20,
+    email: 18, sms: 18,
+    organic: 10, direct: 5,
+  };
+  score += utm_score_map[src] ?? (src ? 8 : 3);
+
+  // 3. Contexto de rede (0–15)
+  const hour    = new Date().getUTCHours();
+  const country = (payload.country || request.cf?.country || '').toUpperCase();
+  const org     = String(request.cf?.asOrganization || '').toLowerCase();
+
+  const isHighConvTime = hour >= 21 || hour <= 2;
+  score += isHighConvTime ? 8 : (hour >= 12 && hour <= 20 ? 4 : 1);
+
+  const latam = ['AR', 'CL', 'CO', 'MX', 'PE', 'UY', 'PY', 'BO'];
+  score += country === 'BR' ? 5 : (latam.includes(country) ? 3 : 1);
+
+  const isCorp = /ltda|s\.a\.|corp|telecom|fibra|claro|vivo|tim|oi/.test(org);
+  score += isCorp ? 2 : 0;
+
+  // 4. Contexto do evento (0–20)
+  const intentionLevel = (payload.intentionLevel || '').toLowerCase();
+  if (intentionLevel === 'comprador' || intentionLevel === 'high_intent') score += 20;
+  else if (intentionLevel === 'interessado') score += 12;
+  else if (intentionLevel === 'nurture') score += 6;
+
+  // 5. Dados PII disponíveis (0–10)
+  if (payload.email) score += 4;
+  if (payload.phone) score += 4;
+  if (payload.firstName) score += 2;
+
+  score = Math.min(100, score);
+
+  let ltvClass, ltvMultiplier;
+  if (score >= 70) {
+    ltvClass = 'High';   ltvMultiplier = 3.5;
+  } else if (score >= 40) {
+    ltvClass = 'Medium'; ltvMultiplier = 1.8;
+  } else {
+    ltvClass = 'Low';    ltvMultiplier = 0.8;
+  }
+
+  const productValue   = payload.value ? parseFloat(payload.value) : 0;
+  const baseValue      = productValue > 0 ? productValue : 197;
+  const predictedValue = Math.round(baseValue * ltvMultiplier * 100) / 100;
+
+  // Enriquecimento opcional via Workers AI
+  let aiAdjustment = 0;
+  if (env.AI && score >= 40) {
+    try {
+      const systemContent = customSystemPrompt ||
+        'You are a conversion rate expert. Reply ONLY with a JSON object {"adjustment": <number between -10 and 10>} based on the lead data provided. No explanation.';
+      const prompt = [
+        { role: 'system', content: systemContent },
+        { role: 'user', content: JSON.stringify({
+          utm_source:  payload.utmSource,
+          intention:   intentionLevel,
+          engagement:  engScore,
+          hour_utc:    hour,
+          country,
+          has_email:   !!payload.email,
+          has_phone:   !!payload.phone,
+        })},
+      ];
+      const aiRes = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', { messages: prompt, max_tokens: 32 });
+      const parsed = JSON.parse(aiRes.response.trim());
+      if (typeof parsed.adjustment === 'number') {
+        aiAdjustment = Math.max(-10, Math.min(10, parsed.adjustment));
+      }
+    } catch { /* graceful fallback */ }
+  }
+
+  return {
+    score: Math.min(100, Math.max(0, score + aiAdjustment)),
+    class: ltvClass,
+    value: predictedValue,
+  };
+}
+
+// ── getLtvAbVariation — busca variação ativa do A/B test ─────────────────────
+export async function getLtvAbVariation(env) {
+  if (!env.DB) return null;
+
+  try {
+    let testData = null;
+    if (env.GEO_CACHE) {
+      const cached = await env.GEO_CACHE.get(AB_LTV_CACHE_KEY, 'json');
+      if (cached) testData = cached;
+    }
+
+    if (!testData) {
+      const test = await env.DB.prepare(`
+        SELECT t.id AS test_id, v.id AS variation_id,
+               v.name, v.system_prompt, v.weight, v.is_control
+        FROM ltv_ab_tests t
+        JOIN ltv_ab_variations v ON v.test_id = t.id
+        WHERE t.status = 'running'
+        ORDER BY t.id DESC
+      `).all();
+
+      if (!test.results || test.results.length === 0) {
+        if (env.GEO_CACHE) await env.GEO_CACHE.put(AB_LTV_CACHE_KEY, JSON.stringify(null), { expirationTtl: 300 });
+        return null;
+      }
+
+      testData = test.results;
+      if (env.GEO_CACHE) await env.GEO_CACHE.put(AB_LTV_CACHE_KEY, JSON.stringify(testData), { expirationTtl: 300 });
+    }
+
+    if (!testData || testData.length === 0) return null;
+
+    const totalWeight = testData.reduce((s, v) => s + (v.weight || 0.5), 0);
+    let rand = Math.random() * totalWeight;
+    for (const variation of testData) {
+      rand -= (variation.weight || 0.5);
+      if (rand <= 0) return variation;
+    }
+    return testData[testData.length - 1];
+
+  } catch (err) {
+    console.error('[AB-LTV] getLtvAbVariation error:', err.message);
+    return null;
+  }
+}
+
+// ── recordAbAssignment — registra variação usada para um lead ─────────────────
+export async function recordAbAssignment(env, userId, variationId, testId, predictedLtv, predictedClass, emailHash) {
+  if (!env.DB) return;
+  try {
+    await env.DB.prepare(`
+      INSERT INTO ltv_ab_assignments (test_id, variation_id, user_id, email_hash, predicted_ltv, predicted_class, assigned_at)
+      VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+    `).bind(testId, variationId, userId, emailHash || null, predictedLtv || null, predictedClass || null).run();
+
+    await env.DB.prepare(`UPDATE ltv_ab_variations SET total_assigned = total_assigned + 1 WHERE id = ?`).bind(variationId).run();
+  } catch (err) {
+    console.error('[AB-LTV] recordAbAssignment error:', err.message);
+  }
+}
+
+// ── POST /api/ltv/ab-test/create ─────────────────────────────────────────────
+export async function handleLtvAbTestCreate(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  let body;
+  try { body = await request.json(); }
+  catch { return new Response(JSON.stringify({ error: 'JSON inválido no body' }), { status: 400, headers }); }
+
+  const { name, description, min_sample = 100, variations } = body;
+  if (!name) return new Response(JSON.stringify({ error: 'name é obrigatório' }), { status: 400, headers });
+  if (!Array.isArray(variations) || variations.length < 2) {
+    return new Response(JSON.stringify({ error: 'Mínimo 2 variações são necessárias' }), { status: 400, headers });
+  }
+
+  const running = await env.DB.prepare(`SELECT id FROM ltv_ab_tests WHERE status = 'running' LIMIT 1`).first();
+  if (running) {
+    return new Response(JSON.stringify({ error: 'Já existe um teste em andamento.', running_test_id: running.id }), { status: 409, headers });
+  }
+
+  try {
+    const now = new Date().toISOString();
+    const totalWeight = variations.reduce((s, v) => s + (v.weight || 0.5), 0);
+    if (Math.abs(totalWeight - 1.0) > 0.05) {
+      return new Response(JSON.stringify({ error: `A soma dos weights deve ser 1.0. Recebido: ${totalWeight.toFixed(3)}` }), { status: 400, headers });
+    }
+    if (!variations.some(v => v.is_control)) {
+      return new Response(JSON.stringify({ error: 'Pelo menos uma variação deve ter is_control: true' }), { status: 400, headers });
+    }
+
+    const testRes = await env.DB.prepare(`
+      INSERT INTO ltv_ab_tests (name, description, status, min_sample, created_at) VALUES (?, ?, 'running', ?, ?)
+    `).bind(name, description || null, min_sample, now).run();
+
+    const testId = testRes.meta?.last_row_id;
+    if (!testId) throw new Error('Falha ao criar o teste no D1');
+
+    const createdVariations = [];
+    for (const v of variations) {
+      const vRes = await env.DB.prepare(`
+        INSERT INTO ltv_ab_variations (test_id, name, system_prompt, weight, is_control, created_at) VALUES (?, ?, ?, ?, ?, ?)
+      `).bind(testId, v.name, v.system_prompt, v.weight || 0.5, v.is_control ? 1 : 0, now).run();
+      createdVariations.push({ id: vRes.meta?.last_row_id, name: v.name, weight: v.weight, is_control: !!v.is_control });
+    }
+
+    if (env.GEO_CACHE) await env.GEO_CACHE.delete(AB_LTV_CACHE_KEY);
+
+    return new Response(JSON.stringify({ success: true, test_id: testId, name, status: 'running', min_sample, variations: createdVariations, started_at: now }), { status: 201, headers });
+  } catch (err) {
+    console.error('[AB-LTV] create error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}
+
+// ── GET /api/ltv/ab-test/list ─────────────────────────────────────────────────
+export async function handleLtvAbTestList(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  const url    = new URL(request.url);
+  const status = url.searchParams.get('status') || null;
+  const limit  = Math.min(parseInt(url.searchParams.get('limit') || '20'), 50);
+
+  try {
+    const cond     = status ? 'WHERE t.status = ?' : '';
+    const bindings = status ? [status, limit] : [limit];
+
+    const tests = await env.DB.prepare(`
+      SELECT t.id, t.name, t.description, t.status, t.winner_id,
+             t.started_at, t.completed_at, t.created_at, t.min_sample,
+             COUNT(DISTINCT v.id) AS variation_count,
+             SUM(v.total_assigned) AS total_assigned
+      FROM ltv_ab_tests t
+      LEFT JOIN ltv_ab_variations v ON v.test_id = t.id
+      ${cond}
+      GROUP BY t.id
+      ORDER BY t.created_at DESC
+      LIMIT ?
+    `).bind(...bindings).all();
+
+    return new Response(JSON.stringify({ success: true, total: (tests.results || []).length, tests: tests.results || [] }), { status: 200, headers });
+  } catch (err) {
+    console.error('[AB-LTV] list error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}
+
+// ── GET /api/ltv/ab-test/results ─────────────────────────────────────────────
+export async function handleLtvAbTestResults(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  const url    = new URL(request.url);
+  const testId = url.searchParams.get('test_id') || null;
+
+  try {
+    const cond    = testId ? 'WHERE test_id = ?' : 'WHERE status = \'running\'';
+    const testBind = testId ? [parseInt(testId)] : [];
+
+    const testRes = await env.DB.prepare(`SELECT id, name, status, min_sample, winner_id, started_at FROM ltv_ab_tests ${cond} LIMIT 1`).bind(...testBind).first();
+    if (!testRes) return new Response(JSON.stringify({ error: 'Nenhum teste encontrado' }), { status: 404, headers });
+
+    const perf = await env.DB.prepare(`SELECT * FROM v_ab_test_performance WHERE test_id = ?`).bind(testRes.id).all();
+    const variations = perf.results || [];
+    const ready      = variations.every(v => (v.total_assigned || 0) >= testRes.min_sample);
+    let recommendation = null;
+
+    if (ready && variations.length > 0) {
+      const best = variations.reduce((a, b) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a);
+      const control = variations.find(v => v.is_control);
+      const improvement = control ? ((best.accuracy_score || 0) - (control.accuracy_score || 0)) * 100 : null;
+      recommendation = {
+        winner_variation_id: best.variation_id, winner_variation_name: best.variation_name,
+        accuracy_score: best.accuracy_score, improvement_vs_control: improvement ? `+${improvement.toFixed(1)}%` : null,
+        ready_to_declare: true,
+      };
+    }
+
+    return new Response(JSON.stringify({
+      success: true,
+      test: { id: testRes.id, name: testRes.name, status: testRes.status, min_sample: testRes.min_sample, started_at: testRes.started_at, is_ready: ready },
+      variations, recommendation,
+    }), { status: 200, headers });
+  } catch (err) {
+    console.error('[AB-LTV] results error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}
+
+// ── POST /api/ltv/ab-test/winner ──────────────────────────────────────────────
+export async function handleLtvAbTestWinner(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  let body;
+  try { body = await request.json(); }
+  catch { return new Response(JSON.stringify({ error: 'JSON inválido' }), { status: 400, headers }); }
+
+  const { test_id, variation_id } = body;
+  if (!test_id || !variation_id) {
+    return new Response(JSON.stringify({ error: 'test_id e variation_id são obrigatórios' }), { status: 400, headers });
+  }
+
+  try {
+    const variation = await env.DB.prepare(`SELECT id, name, system_prompt, is_control FROM ltv_ab_variations WHERE id = ? AND test_id = ?`).bind(variation_id, test_id).first();
+    if (!variation) return new Response(JSON.stringify({ error: 'Variação não encontrada para este teste' }), { status: 404, headers });
+
+    await env.DB.prepare(`UPDATE ltv_ab_tests SET winner_id = ?, status = 'completed', completed_at = datetime('now') WHERE id = ?`).bind(variation_id, test_id).run();
+    if (env.GEO_CACHE) await env.GEO_CACHE.delete(AB_LTV_CACHE_KEY);
+
+    return new Response(JSON.stringify({
+      success: true, test_id, winner_variation_id: variation_id, winner_name: variation.name,
+      is_control: variation.is_control === 1, winning_prompt: variation.system_prompt,
+      message: variation.is_control === 1
+        ? 'O prompt original (controle) venceu. Nenhuma alteração necessária.'
+        : 'Novo prompt vencedor identificado. Copie o campo winning_prompt e aplique ao predictLtv() como novo default.',
+    }), { status: 200, headers });
+  } catch (err) {
+    console.error('[AB-LTV] winner error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}
+
+// ── autoDecideAbWinner — declara winner automaticamente via cron ──────────────
+// Critério: todas as variações com amostra >= min_sample
+//           E diferença de accuracy_score >= 5pp entre melhor e controle
+export async function autoDecideAbWinner(env) {
+  if (!env.DB) return { decided: false, reason: 'no_db' };
+
+  try {
+    // Buscar teste ativo
+    const test = await env.DB.prepare(
+      `SELECT id, name, min_sample, status FROM ltv_ab_tests WHERE status = 'running' ORDER BY id DESC LIMIT 1`
+    ).first();
+
+    if (!test) return { decided: false, reason: 'no_running_test' };
+
+    // Buscar performance das variações
+    const perf = await env.DB.prepare(
+      `SELECT * FROM v_ab_test_performance WHERE test_id = ?`
+    ).bind(test.id).all();
+
+    const variations = perf.results || [];
+    if (variations.length < 2) return { decided: false, reason: 'insufficient_variations' };
+
+    // Verificar se todas têm amostra suficiente
+    const allReady = variations.every(v => (v.total_assigned || 0) >= test.min_sample);
+    if (!allReady) {
+      const minAssigned = Math.min(...variations.map(v => v.total_assigned || 0));
+      return { decided: false, reason: `sample_insufficient (${minAssigned}/${test.min_sample})` };
+    }
+
+    // Encontrar melhor e controle
+    const best    = variations.reduce((a, b) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a);
+    const control = variations.find(v => v.is_control) || variations[0];
+
+    const bestScore    = parseFloat(best.accuracy_score    || 0);
+    const controlScore = parseFloat(control.accuracy_score || 0);
+    const diff         = bestScore - controlScore;
+
+    // Empate técnico → controle vence (determinístico)
+    if (diff < 0.05) {
+      return { decided: false, reason: `difference_too_small (${(diff * 100).toFixed(1)}pp < 5pp)` };
+    }
+
+    // Declarar winner
+    await env.DB.prepare(
+      `UPDATE ltv_ab_tests SET winner_id = ?, status = 'completed', completed_at = datetime('now') WHERE id = ?`
+    ).bind(best.variation_id, test.id).run();
+
+    if (env.GEO_CACHE) await env.GEO_CACHE.delete(AB_LTV_CACHE_KEY);
+
+    console.log(`[AB-LTV] Winner auto-declarado: teste ${test.id}, variação "${best.variation_name}" (+${(diff * 100).toFixed(1)}pp)`);
+
+    return {
+      decided:       true,
+      test_id:       test.id,
+      test_name:     test.name,
+      winner_id:     best.variation_id,
+      winner_name:   best.variation_name,
+      improvement:   `+${(diff * 100).toFixed(1)}pp`,
+      is_control_winner: best.variation_id === control.variation_id,
+      winning_prompt: best.system_prompt || null,
+    };
+
+  } catch (err) {
+    console.error('[AB-LTV] autoDecide error:', err.message);
+    return { decided: false, reason: err.message };
+  }
+}

package/server-edge-tracker/modules/ml/matchquality.js

@@ -0,0 +1,176 @@
+/**
+ * CDP Edge — Match Quality (Fase 5)
+ * Rastreia qualidade dos dados enviados ao Meta CAPI.
+ * Detecta degradação e alerta via CallMeBot.
+ * Tenta auto-correção onde possível.
+ */
+
+import { sendCallMeBot } from '../dispatch/whatsapp.js';
+
+// ── Thresholds de alerta ──────────────────────────────────────────────────────
+const THRESHOLDS = {
+  email_rate_min:   0.40,  // < 40% dos eventos com email → alerta
+  fbp_rate_min:     0.30,  // < 30% com fbp cookie → alerta
+  composite_min:    0.45,  // < 45% score composto → alerta crítico
+  min_events_alert: 10,    // mínimo de eventos nas últimas 2h para disparar alerta
+};
+
+// ── Log de qualidade (chamado em meta.js a cada dispatch) ─────────────────────
+
+/**
+ * Registra flags de qualidade de um evento no D1 (background, não bloqueia).
+ */
+export async function logMatchQuality(DB, eventName, payload, recovered = {}) {
+  if (!DB) return;
+  try {
+    await DB.prepare(`
+      INSERT INTO match_quality_log (
+        event_name, has_email, has_phone, has_fbp, has_fbc, has_external_id,
+        was_email_recovered, was_utm_restored
+      ) VALUES (?,?,?,?,?,?,?,?)
+    `).bind(
+      eventName,
+      payload.email    ? 1 : 0,
+      payload.phone    ? 1 : 0,
+      payload.fbp      ? 1 : 0,
+      payload.fbc      ? 1 : 0,
+      payload.userId   ? 1 : 0,
+      recovered.email  ? 1 : 0,
+      recovered.utm    ? 1 : 0,
+    ).run();
+  } catch { /* não bloquear dispatch */ }
+}
+
+// ── Auto-correção de payload ───────────────────────────────────────────────────
+
+/**
+ * Tenta enriquecer o payload com dados do Identity Graph antes do envio ao Meta.
+ * Retorna { payload enriquecido, flags de recuperação }.
+ */
+export async function autoEnrichPayload(env, payload) {
+  const recovered = { email: false, utm: false };
+  if (!env.DB) return { payload, recovered };
+
+  // 1. Tentar recuperar email/fbp/fbc do perfil pelo userId
+  if (!payload.email && payload.userId) {
+    try {
+      const profile = await env.DB.prepare(
+        `SELECT email, fbp, fbc, phone FROM user_profiles WHERE user_id = ? LIMIT 1`
+      ).bind(payload.userId).first();
+
+      if (profile) {
+        if (profile.email && !payload.email) {
+          payload.email   = profile.email;
+          recovered.email = true;
+        }
+        if (profile.fbp && !payload.fbp)  payload.fbp = profile.fbp;
+        if (profile.fbc && !payload.fbc)  payload.fbc = profile.fbc;
+        if (profile.phone && !payload.phone) payload.phone = profile.phone;
+      }
+    } catch {}
+  }
+
+  // 2. UTM Resurrection já foi tentada no /track handler (payload.utmRestored)
+  if (payload.utmRestored) recovered.utm = true;
+
+  return { payload, recovered };
+}
+
+// ── Análise de qualidade (chamada pelo cron) ─────────────────────────────────
+
+/**
+ * Analisa a qualidade das últimas 2h e retorna métricas + alertas.
+ */
+export async function analyzeMatchQuality(env) {
+  if (!env.DB) return null;
+
+  try {
+    const row = await env.DB.prepare(`
+      SELECT
+        COUNT(*)                             AS total,
+        ROUND(AVG(has_email)       * 100, 1) AS email_rate,
+        ROUND(AVG(has_phone)       * 100, 1) AS phone_rate,
+        ROUND(AVG(has_fbp)         * 100, 1) AS fbp_rate,
+        ROUND(AVG(has_fbc)         * 100, 1) AS fbc_rate,
+        ROUND(AVG(has_external_id) * 100, 1) AS ext_id_rate,
+        ROUND(AVG(was_email_recovered) * 100, 1) AS email_recovered_rate,
+        ROUND((AVG(has_email)*0.4 + AVG(has_fbp)*0.3 + AVG(has_phone)*0.2 + AVG(has_fbc)*0.1) * 100, 1) AS composite_score
+      FROM match_quality_log
+      WHERE logged_at >= datetime('now', '-2 hours')
+    `).first();
+
+    if (!row || row.total < THRESHOLDS.min_events_alert) return { total: row?.total || 0, alerts: [] };
+
+    const alerts = [];
+
+    if ((row.email_rate || 0) < THRESHOLDS.email_rate_min * 100) {
+      alerts.push({
+        type:    'email_low',
+        metric:  `email_rate: ${row.email_rate}%`,
+        message: `Taxa de email baixa: ${row.email_rate}% (mínimo: ${THRESHOLDS.email_rate_min * 100}%)`,
+      });
+    }
+
+    if ((row.fbp_rate || 0) < THRESHOLDS.fbp_rate_min * 100) {
+      alerts.push({
+        type:    'fbp_low',
+        metric:  `fbp_rate: ${row.fbp_rate}%`,
+        message: `Cookie fbp ausente em ${100 - row.fbp_rate}% dos eventos — verificar cdpTrack.js`,
+      });
+    }
+
+    if ((row.composite_score || 0) < THRESHOLDS.composite_min * 100) {
+      alerts.push({
+        type:    'composite_critical',
+        metric:  `composite: ${row.composite_score}%`,
+        message: `Score composto de match quality crítico: ${row.composite_score}%`,
+        severity: 'critical',
+      });
+    }
+
+    return { ...row, alerts };
+  } catch (err) {
+    console.error('[MatchQuality] analyze error:', err.message);
+    return null;
+  }
+}
+
+// ── Alerta via CallMeBot ──────────────────────────────────────────────────────
+
+export async function alertMatchQuality(env, analysis) {
+  if (!analysis || analysis.alerts.length === 0) return;
+
+  const hasCritical = analysis.alerts.some(a => a.severity === 'critical');
+  const icon        = hasCritical ? '🚨' : '⚠️';
+
+  const lines = [
+    `${icon} CDP Edge — Match Quality Alert`,
+    ``,
+    `📊 Últimas 2h (${analysis.total} eventos):`,
+    `  Email:     ${analysis.email_rate ?? 0}% ${(analysis.email_rate ?? 0) < 40 ? '❌' : '✅'}`,
+    `  fbp:       ${analysis.fbp_rate   ?? 0}% ${(analysis.fbp_rate   ?? 0) < 30 ? '❌' : '✅'}`,
+    `  Score:     ${analysis.composite_score ?? 0}%`,
+    ``,
+    `🔍 Problemas:`,
+    ...analysis.alerts.map(a => `  · ${a.message}`),
+    ``,
+    `🛠 Ações automáticas já ativas:`,
+    `  · Identity Graph recovery: ${analysis.email_recovered_rate ?? 0}% emails recuperados`,
+    `  · UTM Resurrection ativa`,
+    ``,
+    new Date().toLocaleString('pt-BR', { timeZone: 'America/Sao_Paulo' }),
+  ];
+
+  await sendCallMeBot(env, lines.join('\n'));
+}
+
+// ── Purge periódico (mensal) ──────────────────────────────────────────────────
+
+export async function purgeOldMatchQualityLogs(DB) {
+  if (!DB) return;
+  try {
+    await DB.prepare(
+      `DELETE FROM match_quality_log WHERE logged_at < datetime('now', '-30 days')`
+    ).run();
+  } catch {}
+}