cdp-edge 1.19.0 → 1.20.0

package/dist/commands/setup.js

@@ -1,138 +1,353 @@
-/**
- * Setup Wizard - Wrapper para invocar CDP Edge Skill
+/**
+ * CDP Edge Setup Wizard — Guiado e não-técnico
  *
- * O CLI é apenas um disparador. A skill (Master Orchestrator) faz tudo.
+ * Coleta os dados do projeto do cliente e gera:
+ *  • Comandos wrangler secret put prontos para copiar
+ *  • URLs de webhook com domínio preenchido
+ *  • Checklist de próximos passos para o agente
  */
 
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
 
 function printBanner() {
   console.log('');
-  console.log(chalk.white.bold('  CDP Edge Setup Wizard'));
-  console.log('');
-  console.log(chalk.cyan(' ██████╗██████╗ ██████╗     ███████╗██████╗  ██████╗ ███████╗'));
-  console.log(chalk.cyan('██╔════╝██╔══██╗██╔══██╗    ██╔════╝██╔══██╗██╔════╝ ██╔════╝'));
-  console.log(chalk.cyan('██║     ██║  ██║██████╔╝    █████╗  ██║  ██║██║  ███╗█████╗  '));
-  console.log(chalk.cyan('██║     ██║  ██║██╔═══╝     ██╔══╝  ██║  ██║██║   ██║██╔══╝  '));
-  console.log(chalk.cyan('╚██████╗██████╔╝██║         ███████╗██████╔╝╚██████╔╝███████╗'));
-  console.log(chalk.cyan(' ╚═════╝╚═════╝ ╚═╝         ╚══════╝╚═════╝  ╚═════╝╚══════╝'));
-  console.log('');
-  console.log(chalk.gray('  Customer Data Platform on the Edge · Global Edge Tracking · v2.0.3'));
-  console.log('');
-  console.log(chalk.gray('═'.repeat(68)));
+  console.log(chalk.cyan('  ╔═══════════════════════════════════════╗'));
+  console.log(chalk.cyan('  ║') + chalk.white.bold('      CDP Edge — Setup Wizard          ') + chalk.cyan('║'));
+  console.log(chalk.cyan('  ║') + chalk.gray('   Configuração Guiada de Tracking     ') + chalk.cyan('║'));
+  console.log(chalk.cyan('  ╚═══════════════════════════════════════╝'));
   console.log('');
 }
 
+function sep(label = '') {
+  if (label) {
+    console.log('\n' + chalk.gray('── ') + chalk.cyan.bold(label) + chalk.gray(' ' + '─'.repeat(Math.max(0, 40 - label.length))));
+  } else {
+    console.log(chalk.gray('─'.repeat(50)));
+  }
+}
+
 export async function runSetupWizard(dir = '.') {
   printBanner();
 
-  // === MENSAGEM INICIAL ===
+  console.log(chalk.cyan('  Vou te fazer algumas perguntas simples.'));
+  console.log(chalk.cyan('  Não precisa saber programar — é só preencher os dados.\n'));
+  console.log(chalk.gray('  Ao final, vou gerar todos os comandos prontos para instalar.\n'));
 
-  console.log(chalk.gray('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-  console.log(chalk.green.bold('  ✅ CDP Edge INSTALADO COM SUCESSO!'));
-  console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+  // ── PASSO 1: Dados do projeto ──────────────────────────────────────────────
+  sep('1. Dados do Projeto');
 
-  console.log(chalk.cyan('🎯 O Master Orchestrator controla todo o processo de criação.'));
-  console.log(chalk.cyan('   Ele vai:\n'));
-  console.log(chalk.cyan('   • Fazer as perguntas necessárias'));
-  console.log(chalk.cyan('   • Analisar suas páginas automaticamente'));
-  console.log(chalk.cyan('   • Chamar os agentes especialistas'));
-  console.log(chalk.cyan('   • Gerar todos os arquivos de tracking'));
-  console.log(chalk.cyan('   • Validar o código gerado\n'));
+  const projeto = await inquirer.prompt([
+    {
+      type:     'input',
+      name:     'domain',
+      message:  'Qual o domínio do site? (ex: meusite.com.br)',
+      validate: v => v.trim() ? true : 'Domínio é obrigatório',
+      filter:   v => v.trim().replace(/^https?:\/\//, '').replace(/\/$/, ''),
+    },
+    {
+      type:    'input',
+      name:    'projectName',
+      message: 'Nome do projeto (para identificação):',
+      default: answers => answers.domain.split('.')[0],
+    },
+    {
+      type:    'list',
+      name:    'productType',
+      message: 'Que tipo de produto você vende?',
+      choices: [
+        { name: 'Infoproduto / Curso Online',       value: 'infoproduto' },
+        { name: 'E-commerce físico',                value: 'ecommerce' },
+        { name: 'SaaS / Assinatura',                value: 'saas' },
+        { name: 'Serviço / Consultoria',            value: 'servico' },
+        { name: 'Lead Generation (captação)',       value: 'leadgen' },
+      ],
+    },
+  ]);
 
-  // === MENU DE OPÇÃO ===
+  // ── PASSO 2: Plataforma de vendas ──────────────────────────────────────────
+  sep('2. Plataforma de Vendas / Checkout');
 
-  const menu = await inquirer.prompt([
+  const { plataformas } = await inquirer.prompt([
     {
-      type: 'list',
-      name: 'action',
-      message: 'O que você deseja fazer?',
+      type:    'checkbox',
+      name:    'plataformas',
+      message: 'Quais plataformas de checkout você usa? (espaço para marcar)',
       choices: [
-        { name: '🚀 Iniciar Master Orchestrator (Configuração Completa)', value: 'start' },
-        { name: '📖 Ver documentação', value: 'docs' },
-        { name: '❌ Sair', value: 'exit' }
-      ]
-    }
+        { name: 'Hotmart',  value: 'hotmart',  checked: false },
+        { name: 'Kiwify',   value: 'kiwify',   checked: false },
+        { name: 'Ticto',    value: 'ticto',    checked: false },
+        { name: 'Eduzz',    value: 'eduzz',    checked: false },
+        { name: 'Stripe',   value: 'stripe',   checked: false },
+        { name: 'Nenhuma (apenas formulário de captação)', value: 'none', checked: false },
+      ],
+      validate: v => v.length > 0 ? true : 'Selecione pelo menos uma opção',
+    },
+  ]);
+
+  // ── PASSO 3: Plataformas de anúncios ───────────────────────────────────────
+  sep('3. Plataformas de Anúncios');
+
+  const { adsPlataformas } = await inquirer.prompt([
+    {
+      type:    'checkbox',
+      name:    'adsPlataformas',
+      message: 'Onde você faz anúncios? (espaço para marcar)',
+      choices: [
+        { name: 'Meta Ads (Facebook / Instagram)', value: 'meta',      checked: true },
+        { name: 'Google Ads / YouTube',            value: 'google',    checked: false },
+        { name: 'TikTok Ads',                      value: 'tiktok',    checked: false },
+        { name: 'Pinterest Ads',                   value: 'pinterest', checked: false },
+        { name: 'LinkedIn Ads',                    value: 'linkedin',  checked: false },
+      ],
+      validate: v => v.length > 0 ? true : 'Selecione pelo menos uma plataforma',
+    },
   ]);
 
-  if (menu.action === 'exit') {
-    console.log(chalk.yellow('\n👋 Até logo!\n'));
-    process.exit(0);
-  }
-
-  if (menu.action === 'docs') {
-    console.log(chalk.cyan('\n📚 Documentação:'));
-    console.log('   Acesse: ' + chalk.underline('docs/guia-cloudflare-iniciante.md'));
-    console.log('   Ou visite: ' + chalk.underline('github.com/ricardosoli777/CDP-Edge-Premium'));
-    return;
-  }
-
-  if (menu.action === 'start') {
-    const spinner = ora('Iniciando Master Orchestrator...').start();
-    await sleep(800);
-    spinner.succeed(chalk.green('Master Orchestrator iniciado!'));
-
-    console.log(chalk.gray('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    console.log(chalk.cyan.bold('  ' + chalk.bold('🧠 MASTER ORCHESTRATOR ATIVO')));
-    console.log(chalk.cyan('  Controlando todo o fluxo de criação...'));
-    console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-
-    // === AQUI INVOCARIA A SKILL ===
-    //
-    // Em produção, aqui seria:
-    //
-    // import { spawnMasterOrchestrator } from '../skill-wrapper';
-    // await spawnMasterOrchestrator({ dir, platforms: [] });
-    //
-    // A skill faria:
-    // - Perguntar modo (guiado/livre)
-    // - Perguntar plataformas
-    // - Acessar projeto
-    // - Spawnar Page Analyzer Agent
-    // - Spawnar Browser Agent
-    // - Spawnar Meta Agent, Google Agent, TikTok Agent
-    // - Spawnar Server Agent
-    // - Gerar todos os arquivos
-    // - Validar
-
-    // === DEMONSTRAÇÃO DO QUE ACONTECE ===
-
-    console.log(chalk.yellow.bold('\n🔄 MODO DEMONSTRAÇÃO\n'));
-    console.log(chalk.gray('   Nesta versão, veja o fluxo que a skill executaria:\n'));
-
-    const demoFlow = [
-      '  [1] Perguntar: Como prefere configurar?',
-      '       → Guiado ou Livre',
-      '  [2] Perguntar: Quais plataformas de ads usa?',
-      '       → Meta, Google, TikTok, LinkedIn, Spotify...',
-      '  [3] Acessar: Seu projeto (GitHub ou local)',
-      '  [4] Page Analyzer: Analisar páginas',
-      '       → Detecta tipo de produto, nicho, formulários',
-      '  [5] Browser Agent: Gerar cdpTrack.js',
-      '       → Tracking SDK + micro-events',
-      '  [6] Meta Agent: Gerar Pixel + CAPI',
-      '  [7] Google Agent: Gerar GA4 + Google Ads',
-      '  [8] TikTok Agent: Gerar Pixel + Events API',
-      '  [9] Server Agent: Gerar Worker + D1',
-      '  [10] Validator: Auditar código gerado',
-      '  [11] Entregar: Arquivos no seu projeto',
-      '       → tracking.config.js, cdpTrack.js, worker.js, schema.sql'
-    ];
-
-    demoFlow.forEach(line => console.log(chalk.cyan(line)));
-
-    console.log(chalk.gray('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    console.log(chalk.green.bold('  ✅ SETUP CONCLUÍDO!'));
-    console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-
-    console.log(chalk.cyan('📁 Arquivos gerados: ' + chalk.underline(dir || '.')));
-    console.log(chalk.gray('\nPróximos passos:'));
-    console.log('  1. Configure seus API tokens no Wrangler');
-    console.log('  2. Faça o deploy: ' + chalk.bold('wrangler deploy'));
-    console.log('  3. Configure o domínio no Cloudflare Dashboard');
+  // ── PASSO 4: Credenciais Meta ──────────────────────────────────────────────
+  const creds = {};
+
+  if (adsPlataformas.includes('meta')) {
+    sep('4a. Credenciais — Meta Ads');
+    console.log(chalk.gray('   Onde encontrar: Meta Events Manager → Configurações → Pixel\n'));
+
+    const meta = await inquirer.prompt([
+      {
+        type:     'input',
+        name:     'pixelId',
+        message:  'Meta Pixel ID:',
+        validate: v => v.trim() ? true : 'Pixel ID é obrigatório',
+        filter:   v => v.trim(),
+      },
+      {
+        type:     'password',
+        name:     'accessToken',
+        message:  'Meta Access Token (CAPI):',
+        mask:     '*',
+        validate: v => v.trim() ? true : 'Access Token é obrigatório',
+      },
+      {
+        type:    'input',
+        name:    'testCode',
+        message: 'Meta Test Event Code (opcional, para homologação):',
+        default: '',
+        filter:  v => v.trim(),
+      },
+    ]);
+    creds.meta = meta;
+  }
+
+  if (adsPlataformas.includes('google')) {
+    sep('4b. Credenciais — Google Analytics 4');
+    console.log(chalk.gray('   Onde encontrar: GA4 → Admin → Data Streams → Measurement Protocol\n'));
+
+    const google = await inquirer.prompt([
+      {
+        type:     'input',
+        name:     'measurementId',
+        message:  'GA4 Measurement ID (G-XXXXXXXX):',
+        validate: v => /^G-[A-Z0-9]+$/i.test(v.trim()) ? true : 'Formato: G-XXXXXXXX',
+        filter:   v => v.trim().toUpperCase(),
+      },
+      {
+        type:     'password',
+        name:     'apiSecret',
+        message:  'GA4 API Secret:',
+        mask:     '*',
+        validate: v => v.trim() ? true : 'API Secret é obrigatório',
+      },
+    ]);
+    creds.google = google;
+  }
+
+  if (adsPlataformas.includes('tiktok')) {
+    sep('4c. Credenciais — TikTok');
+    console.log(chalk.gray('   Onde encontrar: TikTok Events Manager → Pixel → Detalhes\n'));
+
+    const tiktok = await inquirer.prompt([
+      {
+        type:     'input',
+        name:     'pixelId',
+        message:  'TikTok Pixel ID:',
+        validate: v => v.trim() ? true : 'Pixel ID é obrigatório',
+        filter:   v => v.trim(),
+      },
+      {
+        type:     'password',
+        name:     'accessToken',
+        message:  'TikTok Access Token:',
+        mask:     '*',
+        validate: v => v.trim() ? true : 'Access Token é obrigatório',
+      },
+    ]);
+    creds.tiktok = tiktok;
+  }
+
+  // ── PASSO 5: Alertas WhatsApp ──────────────────────────────────────────────
+  sep('5. Alertas WhatsApp (opcional)');
+  console.log(chalk.gray('   Receba alertas de erros e match quality direto no WhatsApp.\n'));
+
+  const { wantsWhatsapp } = await inquirer.prompt([
+    {
+      type:    'confirm',
+      name:    'wantsWhatsapp',
+      message: 'Deseja ativar alertas via WhatsApp?',
+      default: true,
+    },
+  ]);
+
+  let whatsapp = {};
+  if (wantsWhatsapp) {
+    console.log(chalk.gray('\n   Como configurar: acesse callmebot.com e adicione o bot no WhatsApp.'));
+    console.log(chalk.gray('   Envie "I allow callmebot to send me messages" para +34 644 35 78 48\n'));
+
+    whatsapp = await inquirer.prompt([
+      {
+        type:     'input',
+        name:     'phone',
+        message:  'Seu número com DDI (ex: +5511999999999):',
+        validate: v => /^\+\d{10,15}$/.test(v.trim()) ? true : 'Formato: +5511999999999',
+        filter:   v => v.trim(),
+      },
+      {
+        type:     'password',
+        name:     'apiKey',
+        message:  'CallMeBot API Key:',
+        mask:     '*',
+        validate: v => v.trim() ? true : 'API Key é obrigatória',
+      },
+    ]);
+  }
+
+  // ── GERAÇÃO DOS OUTPUTS ────────────────────────────────────────────────────
+  const spinner = ora('Gerando configurações...').start();
+  await sleep(600);
+  spinner.succeed('Configurações geradas!');
+
+  const domain = projeto.domain;
+
+  // Monta lista de secrets
+  const secrets = [];
+
+  if (creds.meta) {
+    secrets.push({ key: 'META_PIXEL_ID',      value: creds.meta.pixelId,      platform: 'Meta' });
+    secrets.push({ key: 'META_ACCESS_TOKEN',  value: creds.meta.accessToken,  platform: 'Meta' });
+    if (creds.meta.testCode) {
+      secrets.push({ key: 'META_TEST_CODE',   value: creds.meta.testCode,     platform: 'Meta (homologação)' });
+    }
+  }
+
+  if (creds.google) {
+    secrets.push({ key: 'GA4_MEASUREMENT_ID', value: creds.google.measurementId, platform: 'Google' });
+    secrets.push({ key: 'GA4_API_SECRET',     value: creds.google.apiSecret,     platform: 'Google' });
+  }
+
+  if (creds.tiktok) {
+    secrets.push({ key: 'TIKTOK_PIXEL_ID',      value: creds.tiktok.pixelId,     platform: 'TikTok' });
+    secrets.push({ key: 'TIKTOK_ACCESS_TOKEN',  value: creds.tiktok.accessToken, platform: 'TikTok' });
   }
+
+  if (whatsapp.phone) {
+    secrets.push({ key: 'CALLMEBOT_PHONE',   value: whatsapp.phone,  platform: 'WhatsApp' });
+    secrets.push({ key: 'CALLMEBOT_API_KEY', value: whatsapp.apiKey, platform: 'WhatsApp' });
+  }
+
+  secrets.push({ key: 'SITE_DOMAIN', value: domain, platform: 'Worker' });
+
+  // Webhooks
+  const webhookUrls = {};
+  const webhookSecrets = [];
+  if (plataformas.includes('hotmart')) {
+    webhookUrls.hotmart = `https://${domain}/webhook/hotmart`;
+    webhookSecrets.push({ key: 'WEBHOOK_SECRET_HOTMART', platform: 'Hotmart', note: 'Gere uma senha forte qualquer' });
+  }
+  if (plataformas.includes('kiwify')) {
+    webhookUrls.kiwify = `https://${domain}/webhook/kiwify`;
+    webhookSecrets.push({ key: 'WEBHOOK_SECRET_KIWIFY', platform: 'Kiwify', note: 'Gere uma senha forte qualquer' });
+  }
+  if (plataformas.includes('ticto')) {
+    webhookUrls.ticto = `https://${domain}/webhook/ticto`;
+    webhookSecrets.push({ key: 'WEBHOOK_SECRET_TICTO', platform: 'Ticto', note: 'Chave HMAC configurada no painel Ticto' });
+  }
+
+  // ── EXIBIR RESULTADO ───────────────────────────────────────────────────────
+  console.log('\n');
+  sep('CONFIGURAÇÃO PRONTA');
+
+  console.log(chalk.green.bold('\n  Projeto: ') + chalk.white(projeto.projectName));
+  console.log(chalk.green.bold('  Domínio: ') + chalk.white(domain));
+  console.log(chalk.green.bold('  Produto: ') + chalk.white(projeto.productType));
+  console.log(chalk.green.bold('  Ads:     ') + chalk.white(adsPlataformas.join(', ')));
+
+  // Comandos de secrets
+  sep('Comandos para configurar os secrets');
+  console.log(chalk.gray('  Execute dentro da pasta server-edge-tracker:\n'));
+
+  for (const s of secrets) {
+    const masked = s.value.length > 4 ? s.value.slice(0, 4) + '*'.repeat(Math.min(s.value.length - 4, 8)) : '****';
+    console.log(chalk.cyan(`  wrangler secret put ${s.key}`));
+    console.log(chalk.gray(`  # ${s.platform} — valor: ${masked}\n`));
+  }
+
+  if (webhookSecrets.length > 0) {
+    console.log(chalk.yellow('  # Secrets de webhook (gere senhas e configure abaixo + no painel da plataforma):'));
+    for (const ws of webhookSecrets) {
+      console.log(chalk.cyan(`  wrangler secret put ${ws.key}`));
+      console.log(chalk.gray(`  # ${ws.platform}: ${ws.note}\n`));
+    }
+  }
+
+  // URLs de webhook
+  if (Object.keys(webhookUrls).length > 0) {
+    sep('URLs de Webhook para configurar nas plataformas');
+    for (const [plat, url] of Object.entries(webhookUrls)) {
+      console.log(chalk.green.bold(`  ${plat.charAt(0).toUpperCase() + plat.slice(1)}:`));
+      console.log(chalk.white(`    ${url}\n`));
+    }
+  }
+
+  // Checklist
+  sep('Próximos passos');
+  const steps = [
+    'Executar todos os wrangler secret put acima',
+    'Executar as migrations D1 (schema.sql → migrate-v7.sql)',
+    'Executar: wrangler deploy',
+    ...(Object.keys(webhookUrls).length > 0 ? ['Configurar as URLs de webhook nas plataformas de venda'] : []),
+    'Configurar Worker Route no Cloudflare: ' + domain + '/*',
+    'Testar o endpoint: https://' + domain + '/health',
+    ...(adsPlataformas.includes('meta') && creds.meta?.testCode ? ['Testar eventos no Meta Events Manager com o Test Event Code'] : []),
+  ];
+
+  steps.forEach((step, i) => {
+    console.log(chalk.cyan(`  [${i + 1}] `) + chalk.white(step));
+  });
+
+  // Salvar config (sem tokens reais)
+  const configOutput = {
+    generatedAt:  new Date().toISOString(),
+    domain,
+    projectName:  projeto.projectName,
+    productType:  projeto.productType,
+    adsPlataformas,
+    checkoutPlataformas: plataformas,
+    webhookUrls,
+    secretKeys:   secrets.map(s => s.key),
+    whatsappAlertsEnabled: !!whatsapp.phone,
+  };
+
+  const outputPath = join(dir, 'cdp-edge-setup.json');
+  try {
+    writeFileSync(outputPath, JSON.stringify(configOutput, null, 2), 'utf8');
+    console.log(chalk.gray(`\n  Configuração salva em: ${outputPath} (sem tokens)\n`));
+  } catch {
+    // não crítico se não conseguir salvar
+  }
+
+  sep();
+  console.log(chalk.green.bold('\n  Setup concluído! Passe os comandos acima para o agente instalar.\n'));
 }
 
 function sleep(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-edge",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "CDP Edge - Quantum Tracking - Sistema multi-agente para tracking digital Cloudflare Native (Workers + D1)",
   "main": "dist/index.js",
   "type": "module",

package/server-edge-tracker/migrate-v7.sql

@@ -0,0 +1,64 @@
+-- CDP Edge — Migration v7
+-- Tabelas para: LTV Model (regressão logística) + Match Quality Log
+-- Idempotente: todos os CREATE usam IF NOT EXISTS
+
+-- ── LTV Model Weights ─────────────────────────────────────────────────────────
+-- Armazena os pesos treinados pelo cron semanal de regressão logística.
+-- O Worker carrega via KV (TTL 7 dias) — query D1 apenas se KV miss.
+CREATE TABLE IF NOT EXISTS ltv_model_weights (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  trained_at   TEXT    NOT NULL DEFAULT (datetime('now')),
+  version      INTEGER NOT NULL DEFAULT 1,
+  is_active    INTEGER NOT NULL DEFAULT 0,
+  sample_size  INTEGER NOT NULL DEFAULT 0,
+  positive_rate REAL,           -- % de samples com label=1 (compra)
+  accuracy     REAL,            -- acurácia no conjunto de treino
+  weights_json TEXT    NOT NULL  -- JSON: {"bias": n, "features": {"utm_fb": w, ...}}
+);
+
+CREATE INDEX IF NOT EXISTS idx_ltv_weights_active  ON ltv_model_weights(is_active);
+CREATE INDEX IF NOT EXISTS idx_ltv_weights_trained ON ltv_model_weights(trained_at DESC);
+
+-- ── Match Quality Log ─────────────────────────────────────────────────────────
+-- Registra a qualidade dos dados enviados ao Meta CAPI por evento.
+-- Sem PII — apenas flags booleanos.
+CREATE TABLE IF NOT EXISTS match_quality_log (
+  id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+  logged_at            TEXT    NOT NULL DEFAULT (datetime('now')),
+  event_name           TEXT    NOT NULL,
+  has_email            INTEGER NOT NULL DEFAULT 0,
+  has_phone            INTEGER NOT NULL DEFAULT 0,
+  has_fbp              INTEGER NOT NULL DEFAULT 0,
+  has_fbc              INTEGER NOT NULL DEFAULT 0,
+  has_external_id      INTEGER NOT NULL DEFAULT 0,
+  was_email_recovered  INTEGER NOT NULL DEFAULT 0,  -- recuperado do Identity Graph
+  was_utm_restored     INTEGER NOT NULL DEFAULT 0   -- via UTM Resurrection
+);
+
+CREATE INDEX IF NOT EXISTS idx_mq_logged ON match_quality_log(logged_at DESC);
+CREATE INDEX IF NOT EXISTS idx_mq_event  ON match_quality_log(event_name, logged_at DESC);
+
+-- ── View: Match Quality Dashboard (últimas 24h) ───────────────────────────────
+CREATE VIEW IF NOT EXISTS v_match_quality_24h AS
+SELECT
+  COUNT(*)                                                          AS total_events,
+  ROUND(AVG(has_email)       * 100, 1)                             AS email_rate_pct,
+  ROUND(AVG(has_phone)       * 100, 1)                             AS phone_rate_pct,
+  ROUND(AVG(has_fbp)         * 100, 1)                             AS fbp_rate_pct,
+  ROUND(AVG(has_fbc)         * 100, 1)                             AS fbc_rate_pct,
+  ROUND(AVG(has_external_id) * 100, 1)                             AS ext_id_rate_pct,
+  ROUND(AVG(was_email_recovered) * 100, 1)                         AS email_recovered_pct,
+  ROUND(AVG(was_utm_restored) * 100, 1)                            AS utm_restored_pct,
+  -- Score composto: email(40%) + fbp(30%) + phone(20%) + fbc(10%)
+  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_pct
+FROM match_quality_log
+WHERE logged_at >= datetime('now', '-24 hours');
+
+-- ── ALTER: colunas de auditoria em ltv_ab_tests ───────────────────────────────
+-- Adiciona auto_decided_at se ainda não existir (SQLite não tem IF NOT EXISTS em ALTER)
+-- Protegido por trigger-style: INSERT OR IGNORE não se aplica a ALTER, então usamos
+-- um approach de criação de tabela auxiliar que faz nada se a coluna já existir.
+-- A abordagem mais segura no Cloudflare D1 é tentar e ignorar o erro no app.
+-- Aqui deixamos comentado — o worker.js já lida com campos opcionais:
+-- ALTER TABLE ltv_ab_tests ADD COLUMN auto_decided_at TEXT;
+-- ALTER TABLE ltv_ab_tests ADD COLUMN auto_decided_reason TEXT;

package/server-edge-tracker/modules/dispatch/meta.js

@@ -5,8 +5,17 @@
 
 import { sha256, normalizePhone, normalizeCity } from '../utils.js';
 import { logApiFailure } from '../db.js';
+import { logMatchQuality, autoEnrichPayload } from '../ml/matchquality.js';
 
 export async function sendMetaCapi(env, eventName, payload, request, ctx) {
+  // Auto-enriquecer payload com dados do Identity Graph antes do envio
+  let recovered = { email: false, utm: false };
+  if (env.DB && payload) {
+    const enriched  = await autoEnrichPayload(env, payload);
+    payload         = enriched.payload;
+    recovered       = enriched.recovered;
+  }
+
   const {
     email, phone, firstName, lastName,
     city, state, country,
@@ -69,6 +78,13 @@ export async function sendMetaCapi(env, eventName, payload, request, ctx) {
     requestBody.test_event_code = env.META_TEST_CODE;
   }
 
+  // Logar match quality em background (não bloqueia dispatch)
+  if (env.DB && ctx) {
+    ctx.waitUntil(logMatchQuality(env.DB, eventName, payload, recovered));
+  } else if (env.DB) {
+    logMatchQuality(env.DB, eventName, payload, recovered).catch(() => {});
+  }
+
   const endpoint = `https://graph.facebook.com/v22.0/${env.META_PIXEL_ID}/events`;
 
   try {

package/server-edge-tracker/modules/intelligence.js

@@ -6,6 +6,9 @@
 import { sha256 } from './utils.js';
 import { getHealthMetrics, generateDailyReport, logIntelligence } from './db.js';
 import { sendCallMeBot } from './dispatch/whatsapp.js';
+import { autoDecideAbWinner } from './ml/ltv.js';
+import { analyzeMatchQuality, alertMatchQuality, purgeOldMatchQualityLogs } from './ml/matchquality.js';
+import { trainLogisticRegression, extractFeatures, saveWeights, LTV_WEIGHTS_KV_KEY } from './ml/logistic.js';
 
 // ── Versões esperadas das APIs ────────────────────────────────────────────────
 const EXPECTED_API_VERSIONS = {
@@ -77,6 +80,62 @@ export async function auditErrorRates(env, runType) {
   return alerts;
 }
 
+// ── Treinar modelo LTV (regressão logística com dados reais do D1) ────────────
+export async function trainLtvModel(env) {
+  if (!env.DB) return { skipped: 'DB não disponível' };
+
+  try {
+    // Busca leads com informação de conversão (compra confirmada)
+    const rows = await env.DB.prepare(`
+      SELECT
+        l.utm_source,
+        l.utm_medium,
+        l.engagement_score,
+        l.intention_level,
+        CAST(julianday('now') - julianday(l.created_at) AS INTEGER) AS days_since_lead,
+        CASE WHEN l.email IS NOT NULL AND l.email != '' THEN 1 ELSE 0 END AS has_email,
+        CASE WHEN l.phone IS NOT NULL AND l.phone != '' THEN 1 ELSE 0 END AS has_phone,
+        CASE WHEN (l.country = 'br' OR l.country = 'BR' OR l.country IS NULL) THEN 1 ELSE 0 END AS is_br,
+        CAST(strftime('%H', l.created_at) AS INTEGER) AS hour,
+        CASE WHEN EXISTS (
+          SELECT 1 FROM events e
+          WHERE e.user_id = l.user_id
+            AND e.event_name IN ('Purchase', 'purchase', 'PURCHASE')
+            AND e.created_at > l.created_at
+        ) THEN 1 ELSE 0 END AS label
+      FROM leads l
+      WHERE l.created_at >= datetime('now', '-90 days')
+      LIMIT 5000
+    `).all();
+
+    const dataset = (rows.results || []).map(row => ({
+      features: extractFeatures(row),
+      label:    row.label || 0,
+    }));
+
+    const model = trainLogisticRegression(dataset);
+
+    if (!model) {
+      console.log('[LTV Train] Dados insuficientes para treinar modelo');
+      return { skipped: 'dados insuficientes', samples: dataset.length };
+    }
+
+    await saveWeights(env.DB, model);
+
+    // Invalidar cache KV para que próximas requests carreguem o modelo novo
+    if (env.GEO_CACHE) {
+      env.GEO_CACHE.delete(LTV_WEIGHTS_KV_KEY).catch(() => {});
+    }
+
+    console.log(`[LTV Train] Modelo treinado: ${dataset.length} samples, accuracy=${(model.accuracy * 100).toFixed(1)}%, positive_rate=${(model.positiveRate * 100).toFixed(1)}%`);
+    return { trained: true, samples: dataset.length, accuracy: model.accuracy, positiveRate: model.positiveRate };
+
+  } catch (err) {
+    console.error('[LTV Train] Erro:', err.message);
+    return { error: err.message };
+  }
+}
+
 // ── Runner principal do Intelligence Agent ────────────────────────────────────
 export async function runIntelligenceAgent(env, runType) {
   console.log(`[Intelligence Agent] Iniciando ${runType}`);
@@ -97,7 +156,61 @@ export async function runIntelligenceAgent(env, runType) {
     console.warn(`[Intelligence Agent] ${errorAlerts.length} alertas de taxa de erro enviados`);
   }
 
-  // 4. Auditoria mensal adicional
+  // 4. Treinar modelo LTV (toda semana)
+  const ltvTrainResult = await trainLtvModel(env);
+  if (ltvTrainResult.trained) {
+    console.log(`[Intelligence Agent] LTV model treinado: accuracy=${(ltvTrainResult.accuracy * 100).toFixed(1)}%`);
+    if (env.DB) {
+      await logIntelligence(env.DB, runType, 'ltv', 'model_training', 'ok',
+        `accuracy=${(ltvTrainResult.accuracy * 100).toFixed(1)}%`, null,
+        `Modelo LTV re-treinado com ${ltvTrainResult.samples} amostras`
+      ).catch(() => {});
+    }
+  } else {
+    console.log(`[Intelligence Agent] LTV model: ${ltvTrainResult.skipped || ltvTrainResult.error || 'sem dados'}`);
+  }
+
+  // 5. Auto-decisão de winner no A/B LTV Test
+  try {
+    const abResult = await autoDecideAbWinner(env);
+    if (abResult?.decided) {
+      console.log(`[Intelligence Agent] A/B LTV winner auto-decidido: test_id=${abResult.test_id}, winner=${abResult.winner_name}`);
+
+      await sendIntelligenceAlert(env, 'info',
+        `A/B LTV Test — Winner Declarado Automaticamente`,
+        `🏆 Vencedor: ${abResult.winner_name}\n📈 Melhoria: +${abResult.improvement?.toFixed(1) ?? '?'}pp vs controle\n🆔 Test ID: ${abResult.test_id}\n\n✅ Prompt vencedor ativado automaticamente`
+      );
+
+      if (env.DB) {
+        await logIntelligence(env.DB, runType, 'ltv', 'ab_auto_winner', 'ok',
+          abResult.winner_name, null,
+          `A/B winner auto-decidido: test ${abResult.test_id}, melhoria ${abResult.improvement?.toFixed(1)}pp`
+        ).catch(() => {});
+      }
+    }
+  } catch (err) {
+    console.error('[Intelligence Agent] A/B auto-decide error:', err.message);
+  }
+
+  // 6. Match Quality — análise + alertas
+  try {
+    const mqAnalysis = await analyzeMatchQuality(env);
+    if (mqAnalysis) {
+      console.log(`[Intelligence Agent] Match Quality: score=${mqAnalysis.composite_score ?? 0}%, alerts=${mqAnalysis.alerts?.length ?? 0}`);
+      await alertMatchQuality(env, mqAnalysis);
+
+      if (env.DB && mqAnalysis.total > 0) {
+        await logIntelligence(env.DB, runType, 'meta', 'match_quality', mqAnalysis.alerts?.length > 0 ? 'warning' : 'ok',
+          `${mqAnalysis.composite_score ?? 0}%`, '45%',
+          `Match quality 2h: email=${mqAnalysis.email_rate ?? 0}%, fbp=${mqAnalysis.fbp_rate ?? 0}%, score=${mqAnalysis.composite_score ?? 0}%`
+        ).catch(() => {});
+      }
+    }
+  } catch (err) {
+    console.error('[Intelligence Agent] Match quality analysis error:', err.message);
+  }
+
+  // 7. Auditoria mensal adicional
   if (runType === 'monthly_audit') {
     if (env.DB) {
       try {
@@ -115,14 +228,18 @@ export async function runIntelligenceAgent(env, runType) {
       } catch (err) {
         console.error('LTV audit error:', err.message);
       }
+
+      // Purge de logs antigos de match quality (> 30 dias)
+      await purgeOldMatchQualityLogs(env.DB);
+      console.log('[Intelligence Agent] Match quality logs antigos purgados');
     }
   }
 
-  // 5. Customer Match sync semanal
+  // 8. Customer Match sync semanal
   const cmResult = await syncMetaCustomAudience(env);
   console.log(`[Intelligence Agent] Customer Match Meta: sent=${cmResult?.sent ?? 0}, received=${cmResult?.num_received ?? 0}`);
 
-  console.log(`[Intelligence Agent] ${runType} concluído`);
+  console.log(`[Intelligence Agent] ${runType} concluído — LTV model, A/B auto-decide, match quality, customer match`);
 }
 
 // ── syncMetaCustomAudience — D1 → Meta Custom Audiences ─────────────────────

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

@@ -0,0 +1,195 @@
+/**
+ * CDP Edge — Logistic Regression (pure JS, sem deps externas)
+ * Treina modelo de predição de conversão com dados reais do D1.
+ *
+ * Features usadas (todas normalizadas 0-1):
+ *   utm_source, engagement_score, intention_level, recency,
+ *   has_email, has_phone, is_br, hour_normalized
+ */
+
+// ── Feature Engineering ───────────────────────────────────────────────────────
+
+const UTM_SCORES = {
+  facebook: 0.90, instagram: 0.90, meta: 0.90,
+  google:   0.82, youtube:   0.82,
+  tiktok:   0.75,
+  email:    0.68, sms: 0.68,
+  organic:  0.30,
+  direct:   0.20,
+};
+
+const INTENTION_SCORES = {
+  comprador:   1.00, high_intent: 1.00,
+  interessado: 0.60,
+  nurture:     0.30,
+  curioso:     0.15,
+};
+
+export function extractFeatures(row) {
+  const src       = (row.utm_source || '').toLowerCase().trim();
+  const intention = (row.intention_level || '').toLowerCase().trim();
+  const daysSince = row.days_since_lead || 0;
+
+  return [
+    UTM_SCORES[src] ?? (src ? 0.10 : 0.05),                    // utm_score
+    Math.min((row.engagement_score || 0) / 5, 1),               // engagement (0-5 → 0-1)
+    INTENTION_SCORES[intention] ?? 0,                           // intention
+    Math.max(0, 1 - daysSince / 90),                            // recency (0=90 dias, 1=hoje)
+    row.has_email    ? 1 : 0,                                   // has_email
+    row.has_phone    ? 1 : 0,                                   // has_phone
+    row.is_br        ? 1 : 0,                                   // is_br
+    ((row.hour || 12) / 23),                                    // hour normalized
+  ];
+}
+
+// ── Sigmoid ───────────────────────────────────────────────────────────────────
+
+function sigmoid(z) {
+  if (z > 20)  return 1;
+  if (z < -20) return 0;
+  return 1 / (1 + Math.exp(-z));
+}
+
+function dot(weights, features) {
+  return features.reduce((sum, f, i) => sum + (weights[i] || 0) * f, 0);
+}
+
+// ── Treinamento ───────────────────────────────────────────────────────────────
+
+/**
+ * Treina regressão logística com gradiente descendente.
+ * @param {Array<{features: number[], label: number}>} dataset
+ * @param {{ iterations?, learningRate?, lambda? }} opts
+ * @returns {{ bias, weights, accuracy, positiveRate }}
+ */
+export function trainLogisticRegression(dataset, opts = {}) {
+  if (!dataset || dataset.length < 50) {
+    return null; // dados insuficientes
+  }
+
+  const iterations   = opts.iterations   || 200;
+  const learningRate = opts.learningRate  || 0.1;
+  const lambda       = opts.lambda        || 0.01; // L2 regularization
+  const nFeatures    = dataset[0].features.length;
+
+  let bias    = 0;
+  let weights = new Array(nFeatures).fill(0);
+
+  const positives = dataset.filter(d => d.label === 1).length;
+  const positiveRate = positives / dataset.length;
+
+  // Se menos de 5% positivos, não treina (dados de compra insuficientes)
+  if (positiveRate < 0.03) return null;
+
+  for (let iter = 0; iter < iterations; iter++) {
+    let dBias    = 0;
+    const dWeights = new Array(nFeatures).fill(0);
+
+    for (const { features, label } of dataset) {
+      const z     = dot(weights, features) + bias;
+      const pred  = sigmoid(z);
+      const error = pred - label;
+
+      dBias += error;
+      for (let j = 0; j < nFeatures; j++) {
+        dWeights[j] += error * features[j];
+      }
+    }
+
+    const n = dataset.length;
+    bias -= learningRate * (dBias / n);
+    for (let j = 0; j < nFeatures; j++) {
+      // L2: penaliza pesos grandes para evitar overfitting
+      weights[j] -= learningRate * ((dWeights[j] / n) + lambda * weights[j]);
+    }
+  }
+
+  // Calcular acurácia no conjunto de treino
+  let correct = 0;
+  const threshold = positiveRate > 0.3 ? 0.5 : Math.max(0.3, positiveRate * 1.5);
+
+  for (const { features, label } of dataset) {
+    const z    = dot(weights, features) + bias;
+    const pred = sigmoid(z) >= threshold ? 1 : 0;
+    if (pred === label) correct++;
+  }
+
+  const accuracy = correct / dataset.length;
+
+  return {
+    bias,
+    weights,
+    accuracy,
+    positiveRate,
+    sampleSize: dataset.length,
+    threshold,
+    featureNames: ['utm_score', 'engagement', 'intention', 'recency', 'has_email', 'has_phone', 'is_br', 'hour'],
+    trainedAt: new Date().toISOString(),
+  };
+}
+
+// ── Inferência ────────────────────────────────────────────────────────────────
+
+/**
+ * Prediz score de conversão (0-100) usando pesos treinados.
+ * @param {{ bias, weights, threshold }} model
+ * @param {number[]} features
+ * @returns {number} score 0-100
+ */
+export function predictWithWeights(model, features) {
+  const z    = dot(model.weights, features) + model.bias;
+  const prob = sigmoid(z);
+  return Math.round(prob * 100);
+}
+
+// ── Helpers de persistência ───────────────────────────────────────────────────
+
+export const LTV_WEIGHTS_KV_KEY = 'ltv_weights_active';
+
+export async function loadActiveWeights(env) {
+  // 1. Tentar KV (cache ~7 dias)
+  if (env.GEO_CACHE) {
+    try {
+      const cached = await env.GEO_CACHE.get(LTV_WEIGHTS_KV_KEY, 'json');
+      if (cached?.weights?.length) return cached;
+    } catch {}
+  }
+
+  // 2. Fallback: D1
+  if (!env.DB) return null;
+  try {
+    const row = await env.DB.prepare(
+      `SELECT weights_json FROM ltv_model_weights WHERE is_active = 1 ORDER BY trained_at DESC LIMIT 1`
+    ).first();
+    if (!row?.weights_json) return null;
+    const model = JSON.parse(row.weights_json);
+
+    // Popular KV para próximas requests
+    if (env.GEO_CACHE && model?.weights?.length) {
+      env.GEO_CACHE.put(LTV_WEIGHTS_KV_KEY, JSON.stringify(model), { expirationTtl: 604800 }).catch(() => {});
+    }
+    return model;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveWeights(DB, model) {
+  if (!DB || !model) return;
+  const now = new Date().toISOString();
+
+  // Desativar modelo anterior
+  await DB.prepare(`UPDATE ltv_model_weights SET is_active = 0 WHERE is_active = 1`).run();
+
+  // Inserir novo como ativo
+  await DB.prepare(`
+    INSERT INTO ltv_model_weights (trained_at, is_active, sample_size, positive_rate, accuracy, weights_json)
+    VALUES (?, 1, ?, ?, ?, ?)
+  `).bind(
+    now,
+    model.sampleSize,
+    model.positiveRate,
+    model.accuracy,
+    JSON.stringify(model),
+  ).run();
+}

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

@@ -3,11 +3,43 @@
  * 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)
@@ -318,3 +350,71 @@ export async function handleLtvAbTestWinner(env, request, headers) {
     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 {}
+}