cdp-edge 2.3.8 → 2.5.1

package/server-edge-tracker/modules/ml/roas.ts

@@ -0,0 +1,255 @@
+/**
+ * CDP Edge — ROAS Feedback Loop (Fase 7)
+ *
+ * Cruza dados de leads (UTM) com compras confirmadas (Purchase events) no D1
+ * para calcular qualidade real de cada campanha:
+ *   → revenue_per_lead, conversion_rate, ltv_accuracy
+ *   → alimenta bidding.ts com dados reais de ROAS
+ *   → relatório semanal via CallMeBot
+ */
+
+import { Env } from '../../types.js';
+import { sendIntelligenceAlert } from '../intelligence.js';
+
+// ── Tipos ─────────────────────────────────────────────────────────────────────
+
+export interface CampaignRoas {
+  utm_source:       string;
+  utm_campaign:     string;
+  utm_content:      string;   // origem do lead: quiz_*, video_*, landing_*, ctwa_*
+  total_leads:      number;
+  confirmed_buyers: number;
+  conversion_rate:  number;   // 0.0–1.0
+  total_revenue:    number;   // soma de value dos Purchase events
+  revenue_per_lead: number;   // total_revenue / total_leads
+  avg_ltv_score:    number;   // média do ltvScore predito (valida accuracy do modelo)
+  ltv_accuracy:     number;   // % de leads com ltvClass=High que realmente compraram
+  top_qualification: string;  // qualificação quiz mais frequente nessa campanha
+  bid_recommendation: 'increase' | 'maintain' | 'decrease' | 'pause';
+}
+
+export interface RoasReport {
+  generated_at:    string;
+  period_days:     number;
+  campaigns:       CampaignRoas[];
+  total_revenue:   number;
+  total_leads:     number;
+  best_campaign:   string | null;
+  worst_campaign:  string | null;
+  model_accuracy:  number;   // % geral do modelo LTV
+}
+
+// ── computeRoasFeedback — calcula ROAS por campanha ───────────────────────────
+
+export async function computeRoasFeedback(
+  env: Env,
+  periodDays = 30,
+): Promise<RoasReport | null> {
+  if (!env.DB) return null;
+
+  try {
+    // Leads com UTM no período + seu LTV predito
+    const leadsRows = await env.DB.prepare(`
+      SELECT
+        COALESCE(l.utm_source,   'direct')   AS utm_source,
+        COALESCE(l.utm_campaign, 'unknown')  AS utm_campaign,
+        COALESCE(l.utm_content,  'unknown')  AS utm_content,
+        l.user_id,
+        l.value                              AS predicted_value,
+        l.intention_level,
+        up.predicted_ltv_class,
+        qs.qualification                     AS quiz_qualification
+      FROM leads l
+      LEFT JOIN user_profiles up ON up.user_id = l.user_id
+      LEFT JOIN quiz_sessions  qs ON qs.user_id = l.user_id
+      WHERE l.created_at >= datetime('now', '-' || ? || ' days')
+        AND l.event_name IN ('Lead','Contact','QuizComplete','CompleteRegistration')
+      ORDER BY l.created_at DESC
+    `).bind(periodDays).all();
+
+    // Compras confirmadas no mesmo período — JOIN por user_id
+    const purchaseRows = await env.DB.prepare(`
+      SELECT
+        l.utm_source,
+        l.utm_campaign,
+        l.utm_content,
+        l.user_id,
+        e.value  AS purchase_value
+      FROM events e
+      JOIN leads l ON l.user_id = e.user_id
+      WHERE e.event_name IN ('Purchase','purchase')
+        AND e.created_at >= datetime('now', '-' || ? || ' days')
+        AND l.event_name IN ('Lead','Contact','QuizComplete','CompleteRegistration')
+    `).bind(periodDays).all();
+
+    const leads    = (leadsRows.results    || []) as any[];
+    const purchases = (purchaseRows.results || []) as any[];
+
+    if (leads.length === 0) return null;
+
+    // Indexa compras por user_id para lookup O(1)
+    const buyerMap = new Map<string, number>(); // user_id → purchase_value
+    for (const p of purchases) {
+      const existing = buyerMap.get(p.user_id) || 0;
+      buyerMap.set(p.user_id, existing + (parseFloat(String(p.purchase_value || 0))));
+    }
+
+    // Agrupa por campanha
+    const campaignMap = new Map<string, {
+      leads: any[];
+      buyers: Set<string>;
+      revenue: number;
+      highLtvLeads: number;
+      highLtvBuyers: number;
+      qualifications: Record<string, number>;
+    }>();
+
+    for (const lead of leads) {
+      const key = `${lead.utm_source}|||${lead.utm_campaign}|||${lead.utm_content || 'unknown'}`;
+      if (!campaignMap.has(key)) {
+        campaignMap.set(key, {
+          leads: [], buyers: new Set(), revenue: 0,
+          highLtvLeads: 0, highLtvBuyers: 0,
+          qualifications: {},
+        });
+      }
+      const c = campaignMap.get(key)!;
+      c.leads.push(lead);
+
+      if (lead.predicted_ltv_class === 'High') c.highLtvLeads++;
+
+      const purchaseValue = buyerMap.get(lead.user_id);
+      if (purchaseValue !== undefined) {
+        c.buyers.add(lead.user_id);
+        c.revenue += purchaseValue;
+        if (lead.predicted_ltv_class === 'High') c.highLtvBuyers++;
+      }
+
+      const qual = lead.quiz_qualification || lead.intention_level || 'unknown';
+      c.qualifications[qual] = (c.qualifications[qual] || 0) + 1;
+    }
+
+    // Monta relatório por campanha
+    const campaigns: CampaignRoas[] = [];
+    for (const [key, c] of campaignMap.entries()) {
+      const [utm_source, utm_campaign, utm_content] = key.split('|||');
+      const total_leads      = c.leads.length;
+      const confirmed_buyers = c.buyers.size;
+      const conversion_rate  = total_leads > 0 ? confirmed_buyers / total_leads : 0;
+      const revenue_per_lead = total_leads > 0 ? c.revenue / total_leads : 0;
+      const avg_ltv_score    = c.leads.reduce((s: number, l: any) => s + parseFloat(String(l.predicted_value || 0)), 0) / total_leads;
+      const ltv_accuracy     = c.highLtvLeads > 0 ? c.highLtvBuyers / c.highLtvLeads : 0;
+
+      const top_qualification = Object.entries(c.qualifications)
+        .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+
+      // Recomendação de bid baseada em conversão + accuracy
+      let bid_recommendation: CampaignRoas['bid_recommendation'];
+      if (conversion_rate >= 0.15 && ltv_accuracy >= 0.6)      bid_recommendation = 'increase';
+      else if (conversion_rate >= 0.05 && ltv_accuracy >= 0.3)  bid_recommendation = 'maintain';
+      else if (conversion_rate > 0 && confirmed_buyers > 0)      bid_recommendation = 'decrease';
+      else                                                        bid_recommendation = 'pause';
+
+      campaigns.push({
+        utm_source, utm_campaign, utm_content,
+        total_leads, confirmed_buyers,
+        conversion_rate: Math.round(conversion_rate * 10000) / 10000,
+        total_revenue: Math.round(c.revenue * 100) / 100,
+        revenue_per_lead: Math.round(revenue_per_lead * 100) / 100,
+        avg_ltv_score: Math.round(avg_ltv_score * 100) / 100,
+        ltv_accuracy: Math.round(ltv_accuracy * 10000) / 10000,
+        top_qualification,
+        bid_recommendation,
+      });
+    }
+
+    // Ordena por revenue total desc
+    campaigns.sort((a, b) => b.total_revenue - a.total_revenue);
+
+    const total_revenue  = campaigns.reduce((s, c) => s + c.total_revenue, 0);
+    const total_leads    = campaigns.reduce((s, c) => s + c.total_leads, 0);
+    // model_accuracy: média ponderada de ltv_accuracy por campanha (High LTV que realmente compraram)
+    const model_accuracy = campaigns.length > 0
+      ? campaigns.reduce((s, c) => s + c.ltv_accuracy * c.total_leads, 0) / Math.max(total_leads, 1)
+      : 0;
+
+    const best_campaign  = campaigns.find(c => c.bid_recommendation === 'increase')
+      ? `${campaigns[0].utm_source} / ${campaigns[0].utm_campaign}`
+      : null;
+    const worst_campaign = campaigns.find(c => c.bid_recommendation === 'pause')
+      ? (() => { const w = campaigns.find(c => c.bid_recommendation === 'pause')!; return `${w.utm_source} / ${w.utm_campaign}`; })()
+      : null;
+
+    // Persiste no D1 para histórico
+    await _persistRoasReport(env, campaigns, periodDays);
+
+    return {
+      generated_at:   new Date().toISOString(),
+      period_days:    periodDays,
+      campaigns,
+      total_revenue:  Math.round(total_revenue * 100) / 100,
+      total_leads,
+      best_campaign,
+      worst_campaign,
+      model_accuracy: Math.round(model_accuracy * 10000) / 10000,
+    };
+
+  } catch (err: any) {
+    console.error('[ROAS] computeRoasFeedback error:', err?.message || String(err));
+    return null;
+  }
+}
+
+// ── sendRoasAlert — relatório via CallMeBot ───────────────────────────────────
+
+export async function sendRoasAlert(env: Env, report: RoasReport): Promise<void> {
+  const top3 = report.campaigns.slice(0, 3);
+  const lines = top3.map(c =>
+    `• ${c.utm_source}/${c.utm_campaign}/${c.utm_content}: ${c.confirmed_buyers} compradores, R$${c.total_revenue.toLocaleString('pt-BR')} (${(c.conversion_rate * 100).toFixed(1)}% conv) → ${c.bid_recommendation.toUpperCase()}`
+  ).join('\n');
+
+  const pauseCount   = report.campaigns.filter(c => c.bid_recommendation === 'pause').length;
+  const increaseCount = report.campaigns.filter(c => c.bid_recommendation === 'increase').length;
+
+  const details = [
+    `📅 Período: últimos ${report.period_days} dias`,
+    `💰 Receita total: R$${report.total_revenue.toLocaleString('pt-BR')}`,
+    `👥 Total leads: ${report.total_leads}`,
+    `📈 Top campanhas por receita:\n${lines}`,
+    increaseCount > 0 ? `✅ ${increaseCount} campanha(s) recomendada(s) para AUMENTAR bid` : '',
+    pauseCount > 0    ? `⛔ ${pauseCount} campanha(s) recomendada(s) para PAUSAR` : '',
+    report.best_campaign  ? `🏆 Melhor: ${report.best_campaign}` : '',
+    report.worst_campaign ? `🔻 Pior:   ${report.worst_campaign}` : '',
+  ].filter(Boolean).join('\n');
+
+  await sendIntelligenceAlert(env, 'info', 'ROAS Feedback Semanal', details);
+}
+
+// ── _persistRoasReport — salva snapshot no D1 ────────────────────────────────
+
+async function _persistRoasReport(
+  env: Env,
+  campaigns: CampaignRoas[],
+  periodDays: number,
+): Promise<void> {
+  if (!env.DB) return;
+  try {
+    for (const c of campaigns) {
+      await env.DB.prepare(`
+        INSERT INTO roas_reports (
+          utm_source, utm_campaign, utm_content, period_days,
+          total_leads, confirmed_buyers, conversion_rate,
+          total_revenue, revenue_per_lead, ltv_accuracy,
+          top_qualification, bid_recommendation, created_at
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,datetime('now'))
+      `).bind(
+        c.utm_source, c.utm_campaign, c.utm_content, periodDays,
+        c.total_leads, c.confirmed_buyers, c.conversion_rate,
+        c.total_revenue, c.revenue_per_lead, c.ltv_accuracy,
+        c.top_qualification, c.bid_recommendation,
+      ).run();
+    }
+  } catch (err: any) {
+    console.error('[ROAS] persist error:', err?.message || String(err));
+  }
+}

package/server-edge-tracker/modules/nurture.ts

@@ -0,0 +1,257 @@
+/**
+ * CDP Edge — Nurture Engine (Fase 7)
+ *
+ * Sequências de follow-up automáticas baseadas na qualificação do quiz:
+ *   comprador  → contato imediato (já tratado pelo hot lead)
+ *   interessado → D+1, D+3, D+7 (WhatsApp ou email)
+ *   curioso     → D+2, D+5 (conteúdo/isca)
+ *   perdido     → exclusão do remarketing (cohort_label = excluded)
+ *
+ * Arquitetura:
+ *   1. scheduleNurture()  — chamado no QuizComplete, insere sequência no D1
+ *   2. runNurtureQueue()  — chamado pelo Intelligence Agent (cron diário)
+ *                          envia as mensagens com send_at <= now()
+ */
+
+import { Env, TrackPayload } from '../types.js';
+
+// ── Tipos ─────────────────────────────────────────────────────────────────────
+
+export type NurtureQualification = 'comprador' | 'interessado' | 'curioso' | 'perdido';
+
+export interface NurtureStep {
+  delay_days: number;
+  channel:    'whatsapp' | 'email';
+  message:    string;     // suporta {{name}}, {{quiz_name}}, {{qualification}}
+  subject?:   string;     // apenas email
+}
+
+export interface NurtureResult {
+  scheduled: number;
+  skipped:   string | null;
+}
+
+export interface NurtureRunResult {
+  processed: number;
+  sent:      number;
+  failed:    number;
+  excluded:  number;
+}
+
+// ── Sequências por qualificação ───────────────────────────────────────────────
+// Mensagens genéricas — o cliente personaliza via automation_rules no D1.
+// O Nurture Engine usa estas como fallback quando não há regra cadastrada.
+
+const NURTURE_SEQUENCES: Record<NurtureQualification, NurtureStep[]> = {
+  comprador: [
+    // comprador já dispara hot lead imediato no /track — sem sequência adicional aqui
+  ],
+  interessado: [
+    {
+      delay_days: 1,
+      channel:    'whatsapp',
+      message:    'Olá {{name}}! Vi que você completou nosso diagnóstico e ficou entre os mais qualificados. Posso te enviar mais detalhes sobre como podemos ajudar?',
+    },
+    {
+      delay_days: 3,
+      channel:    'whatsapp',
+      message:    'Oi {{name}}, tudo bem? Separei um conteúdo exclusivo baseado nas suas respostas no quiz "{{quiz_name}}". Posso compartilhar?',
+    },
+    {
+      delay_days: 7,
+      channel:    'whatsapp',
+      message:    '{{name}}, última oportunidade esta semana! Muitos que fizeram o mesmo diagnóstico que você já estão obtendo resultados. Que tal conversarmos 15 minutos?',
+    },
+  ],
+  curioso: [
+    {
+      delay_days: 2,
+      channel:    'whatsapp',
+      message:    'Olá {{name}}! Você completou nosso diagnóstico. Preparei um material gratuito baseado no seu perfil. Posso enviar?',
+    },
+    {
+      delay_days: 5,
+      channel:    'whatsapp',
+      message:    'Oi {{name}}! Vi que você está pesquisando sobre o assunto. Tenho uma aula gratuita que pode te ajudar muito. Interesse?',
+    },
+  ],
+  perdido: [
+    // perdido não recebe mensagens — apenas é excluído do remarketing
+  ],
+};
+
+// ── scheduleNurture — agenda sequência após QuizComplete ─────────────────────
+
+export async function scheduleNurture(
+  env: Env,
+  payload: TrackPayload,
+  qualification: NurtureQualification,
+): Promise<NurtureResult> {
+  if (!env.DB) return { scheduled: 0, skipped: 'DB não disponível' };
+
+  // perdido → só atualiza cohort_label para excluir do remarketing
+  if (qualification === 'perdido') {
+    if (payload.userId) {
+      try {
+        await env.DB.prepare(`
+          UPDATE user_profiles
+          SET cohort_label = 'excluded', updated_at = datetime('now')
+          WHERE user_id = ?
+        `).bind(payload.userId).run();
+      } catch { /* não-crítico */ }
+    }
+    return { scheduled: 0, skipped: 'perdido — excluído do remarketing' };
+  }
+
+  // comprador → contato imediato já gerenciado pelo hot lead em index.ts
+  if (qualification === 'comprador') {
+    return { scheduled: 0, skipped: 'comprador — contato imediato via hot lead' };
+  }
+
+  const steps = NURTURE_SEQUENCES[qualification];
+  if (!steps || steps.length === 0) {
+    return { scheduled: 0, skipped: `sem sequência para ${qualification}` };
+  }
+
+  // Verifica se já tem sequência ativa para este usuário (evita duplicar)
+  if (payload.userId) {
+    try {
+      const existing = await env.DB.prepare(`
+        SELECT id FROM nurture_sequences
+        WHERE user_id = ? AND status = 'pending'
+        LIMIT 1
+      `).bind(payload.userId).first();
+      if (existing) return { scheduled: 0, skipped: 'sequência já existe para este usuário' };
+    } catch { /* continua */ }
+  }
+
+  let scheduled = 0;
+  for (const step of steps) {
+    try {
+      const sendAt = new Date();
+      sendAt.setDate(sendAt.getDate() + step.delay_days);
+
+      await env.DB.prepare(`
+        INSERT INTO nurture_sequences (
+          user_id, qualification, delay_days, channel,
+          message, subject, send_at, status,
+          quiz_name, phone, email, first_name, created_at
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,datetime('now'))
+      `).bind(
+        payload.userId                         || null,
+        qualification,
+        step.delay_days,
+        step.channel,
+        step.message,
+        step.subject                           || null,
+        sendAt.toISOString().slice(0, 19).replace('T', ' '),
+        'pending',
+        String((payload as any).quiz_name      || ''),
+        payload.phone                          || null,
+        payload.email                          || null,
+        payload.firstName                      || null,
+      ).run();
+
+      scheduled++;
+    } catch (err: any) {
+      console.error('[Nurture] scheduleNurture insert error:', err?.message || String(err));
+    }
+  }
+
+  return { scheduled, skipped: null };
+}
+
+// ── runNurtureQueue — processa mensagens pendentes (chamado pelo cron) ────────
+
+export async function runNurtureQueue(env: Env): Promise<NurtureRunResult> {
+  if (!env.DB) return { processed: 0, sent: 0, failed: 0, excluded: 0 };
+
+  const result: NurtureRunResult = { processed: 0, sent: 0, failed: 0, excluded: 0 };
+
+  try {
+    // Busca até 50 mensagens pendentes com send_at <= agora
+    const pending = await env.DB.prepare(`
+      SELECT * FROM nurture_sequences
+      WHERE status = 'pending'
+        AND send_at <= datetime('now')
+      ORDER BY send_at ASC
+      LIMIT 50
+    `).all();
+
+    const rows = (pending.results || []) as any[];
+    if (rows.length === 0) return result;
+
+    for (const row of rows) {
+      result.processed++;
+
+      // Interpola variáveis na mensagem
+      const vars: Record<string, string> = {
+        name:          String(row.first_name || 'você'),
+        quiz_name:     String(row.quiz_name  || 'diagnóstico'),
+        qualification: String(row.qualification || ''),
+      };
+      const message = String(row.message || '').replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? '');
+      const subject = row.subject ? String(row.subject).replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? '') : null;
+
+      let success = false;
+
+      try {
+        if (row.channel === 'whatsapp' && row.phone && env.WHATSAPP_ACCESS_TOKEN && env.WHATSAPP_PHONE_NUMBER_ID) {
+          const digits = String(row.phone).replace(/\D/g, '');
+          const e164   = digits.startsWith('55') ? `+${digits}` : `+55${digits}`;
+
+          const res = await fetch(
+            `https://graph.facebook.com/v22.0/${env.WHATSAPP_PHONE_NUMBER_ID}/messages`,
+            {
+              method:  'POST',
+              headers: { 'Authorization': `Bearer ${env.WHATSAPP_ACCESS_TOKEN}`, 'Content-Type': 'application/json' },
+              body:    JSON.stringify({
+                messaging_product: 'whatsapp',
+                recipient_type:    'individual',
+                to:                e164,
+                type:              'text',
+                text:              { body: message },
+              }),
+            }
+          );
+          success = res.ok;
+
+        } else if (row.channel === 'email' && row.email && env.RESEND_API_KEY) {
+          const res = await fetch('https://api.resend.com/emails', {
+            method:  'POST',
+            headers: { 'Authorization': `Bearer ${env.RESEND_API_KEY}`, 'Content-Type': 'application/json' },
+            body:    JSON.stringify({
+              from:    env.RESEND_FROM_EMAIL || 'noreply@cdp-edge.app',
+              to:      [row.email],
+              subject: subject || `Olá, ${vars.name}!`,
+              html:    `<p>${message.replace(/\n/g, '<br>')}</p>`,
+            }),
+          });
+          success = res.ok;
+        }
+      } catch (err: any) {
+        console.error(`[Nurture] dispatch error (row ${row.id}):`, err?.message || String(err));
+      }
+
+      // Atualiza status no D1
+      const newStatus = success ? 'sent' : 'failed';
+      const sentAt    = success ? `datetime('now')` : 'NULL';
+      try {
+        await env.DB.prepare(`
+          UPDATE nurture_sequences
+          SET status = ?, sent_at = ${success ? "datetime('now')" : 'NULL'},
+              updated_at = datetime('now')
+          WHERE id = ?
+        `).bind(newStatus, row.id).run();
+      } catch { /* não-crítico */ }
+
+      if (success) result.sent++;
+      else          result.failed++;
+    }
+
+  } catch (err: any) {
+    console.error('[Nurture] runNurtureQueue error:', err?.message || String(err));
+  }
+
+  return result;
+}

package/server-edge-tracker/modules/utils.ts

@@ -106,6 +106,8 @@ export const VALID_EVENT_NAMES = new Set([
   'video_start','video_25','video_50','video_75','video_complete',
   // Imóveis — intenção de visita física, financiamento e favoritar
   'FindLocation','CustomizeProduct','AddToWishlist',
+  // Quiz Funnel (Fase 6)
+  'QuizStart','QuizAnswer','QuizComplete',
 ]);
 
 // ── Taxonomia de funil (funnel_stage → profundidade semântica) ────────────────

package/server-edge-tracker/schema-quiz.sql

@@ -0,0 +1,52 @@
+-- CDP Edge — Schema Quiz Sessions (Fase 6 v2)
+-- Análise Dimensional Automática por Workers AI
+-- Executar: wrangler d1 execute cdp-edge-db --file=schema-quiz.sql --remote
+
+CREATE TABLE IF NOT EXISTS quiz_sessions (
+  id                 INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id            TEXT,                   -- _cdp_uid (FK lógica → user_profiles)
+  quiz_name          TEXT,                   -- nome do quiz (ex: "Diagnóstico Imóvel")
+  answers_json       TEXT    NOT NULL,       -- JSON: [{question, answer, step}]
+  qualification      TEXT    NOT NULL,       -- comprador | interessado | curioso | perdido
+  intent_score       REAL    NOT NULL,       -- 0.0–1.0 (propagado ao pipeline CDP)
+  weighted_score     REAL    NOT NULL,       -- score ponderado bruto Σ(score×weight)/Σ(weight)
+  confidence         REAL    NOT NULL DEFAULT 0.7,
+  reason             TEXT,                   -- frase explicativa em português (audit)
+  dominant_dimension TEXT,                   -- dimensão com maior impacto: budget|urgency|etc.
+  dimensions_json    TEXT,                   -- JSON: [{step, dimension, score, weight, signal}]
+  source             TEXT    DEFAULT 'ai',   -- ai | heuristic
+  created_at         TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_quiz_user_id       ON quiz_sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_quiz_qualification ON quiz_sessions(qualification);
+CREATE INDEX IF NOT EXISTS idx_quiz_created_at    ON quiz_sessions(created_at);
+CREATE INDEX IF NOT EXISTS idx_quiz_dominant_dim  ON quiz_sessions(dominant_dimension);
+
+-- VIEW: distribuição de qualificações por quiz + score médio
+CREATE VIEW IF NOT EXISTS v_quiz_qualification_summary AS
+SELECT
+  quiz_name,
+  qualification,
+  COUNT(*)                                          AS total,
+  ROUND(AVG(intent_score)   * 100, 1)              AS avg_intent_pct,
+  ROUND(AVG(weighted_score) * 100, 1)              AS avg_weighted_pct,
+  ROUND(AVG(confidence)     * 100, 1)              AS avg_confidence_pct,
+  COUNT(CASE WHEN source = 'ai' THEN 1 END)        AS ai_scored,
+  COUNT(CASE WHEN source = 'heuristic' THEN 1 END) AS heuristic_scored
+FROM quiz_sessions
+GROUP BY quiz_name, qualification
+ORDER BY quiz_name, avg_intent_pct DESC;
+
+-- VIEW: qual dimensão mais penaliza/beneficia cada quiz
+CREATE VIEW IF NOT EXISTS v_quiz_dimension_impact AS
+SELECT
+  quiz_name,
+  dominant_dimension,
+  COUNT(*)                             AS total_sessions,
+  ROUND(AVG(weighted_score) * 100, 1) AS avg_weighted_pct,
+  qualification
+FROM quiz_sessions
+WHERE dominant_dimension IS NOT NULL
+GROUP BY quiz_name, dominant_dimension, qualification
+ORDER BY quiz_name, total_sessions DESC;

package/server-edge-tracker/schema-sales-engine.sql

@@ -0,0 +1,113 @@
+-- CDP Edge — Schema Sales Engine (Fase 7)
+-- ROAS Feedback Loop + Nurture Engine + Lookalike Dinâmico
+-- Executar: wrangler d1 execute cdp-edge-db --file=schema-sales-engine.sql --remote
+
+-- ── ROAS Reports — histórico de performance por campanha ──────────────────────
+CREATE TABLE IF NOT EXISTS roas_reports (
+  id                 INTEGER PRIMARY KEY AUTOINCREMENT,
+  utm_source         TEXT    NOT NULL,
+  utm_campaign       TEXT    NOT NULL,
+  utm_content        TEXT    NOT NULL DEFAULT 'unknown', -- origem: quiz_*, video_*, landing_*, ctwa_*
+  period_days        INTEGER NOT NULL DEFAULT 30,
+  total_leads        INTEGER NOT NULL DEFAULT 0,
+  confirmed_buyers   INTEGER NOT NULL DEFAULT 0,
+  conversion_rate    REAL    NOT NULL DEFAULT 0,     -- 0.0–1.0
+  total_revenue      REAL    NOT NULL DEFAULT 0,     -- BRL
+  revenue_per_lead   REAL    NOT NULL DEFAULT 0,
+  ltv_accuracy       REAL    NOT NULL DEFAULT 0,     -- % leads High LTV que realmente compraram
+  top_qualification  TEXT,                           -- qualificação quiz dominante
+  bid_recommendation TEXT    NOT NULL DEFAULT 'maintain', -- increase|maintain|decrease|pause
+  created_at         TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Migração para instâncias existentes (idempotente via IF NOT EXISTS não funciona em ALTER TABLE —
+-- execute manualmente se a tabela já existir):
+-- ALTER TABLE roas_reports ADD COLUMN utm_content TEXT NOT NULL DEFAULT 'unknown';
+
+CREATE INDEX IF NOT EXISTS idx_roas_source_campaign ON roas_reports(utm_source, utm_campaign);
+CREATE INDEX IF NOT EXISTS idx_roas_content         ON roas_reports(utm_content);
+CREATE INDEX IF NOT EXISTS idx_roas_created_at      ON roas_reports(created_at);
+CREATE INDEX IF NOT EXISTS idx_roas_bid_rec         ON roas_reports(bid_recommendation);
+
+-- VIEW: últimos relatórios por campanha com evolução
+CREATE VIEW IF NOT EXISTS v_roas_latest AS
+SELECT
+  utm_source,
+  utm_campaign,
+  conversion_rate,
+  total_revenue,
+  revenue_per_lead,
+  ltv_accuracy,
+  top_qualification,
+  bid_recommendation,
+  created_at
+FROM roas_reports r1
+WHERE created_at = (
+  SELECT MAX(r2.created_at)
+  FROM roas_reports r2
+  WHERE r2.utm_source = r1.utm_source
+    AND r2.utm_campaign = r1.utm_campaign
+)
+ORDER BY total_revenue DESC;
+
+-- ── Nurture Sequences — filas de mensagens por qualificação ──────────────────
+CREATE TABLE IF NOT EXISTS nurture_sequences (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id        TEXT,                     -- _cdp_uid
+  qualification  TEXT    NOT NULL,         -- interessado | curioso
+  delay_days     INTEGER NOT NULL,         -- D+N após o quiz
+  channel        TEXT    NOT NULL,         -- whatsapp | email
+  message        TEXT    NOT NULL,         -- mensagem interpolada
+  subject        TEXT,                     -- assunto (email only)
+  send_at        TEXT    NOT NULL,         -- datetime de envio agendado
+  status         TEXT    NOT NULL DEFAULT 'pending',  -- pending | sent | failed | cancelled
+  sent_at        TEXT,                     -- quando foi realmente enviado
+  quiz_name      TEXT,                     -- nome do quiz (para interpolação)
+  phone          TEXT,                     -- telefone do lead
+  email          TEXT,                     -- email do lead
+  first_name     TEXT,                     -- nome (para personalização)
+  created_at     TEXT    NOT NULL DEFAULT (datetime('now')),
+  updated_at     TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_nurture_user_id   ON nurture_sequences(user_id);
+CREATE INDEX IF NOT EXISTS idx_nurture_status    ON nurture_sequences(status);
+CREATE INDEX IF NOT EXISTS idx_nurture_send_at   ON nurture_sequences(send_at);
+CREATE INDEX IF NOT EXISTS idx_nurture_qual      ON nurture_sequences(qualification);
+
+-- VIEW: fila de envio pendente
+CREATE VIEW IF NOT EXISTS v_nurture_pending AS
+SELECT
+  id, user_id, qualification, delay_days, channel,
+  message, send_at, phone, email, first_name, quiz_name
+FROM nurture_sequences
+WHERE status = 'pending'
+  AND send_at <= datetime('now')
+ORDER BY send_at ASC;
+
+-- VIEW: taxa de envio por qualificação
+CREATE VIEW IF NOT EXISTS v_nurture_stats AS
+SELECT
+  qualification,
+  channel,
+  COUNT(*)                                       AS total,
+  COUNT(CASE WHEN status = 'sent'    THEN 1 END) AS sent,
+  COUNT(CASE WHEN status = 'failed'  THEN 1 END) AS failed,
+  COUNT(CASE WHEN status = 'pending' THEN 1 END) AS pending,
+  ROUND(COUNT(CASE WHEN status = 'sent' THEN 1 END) * 100.0 / COUNT(*), 1) AS delivery_rate_pct
+FROM nurture_sequences
+GROUP BY qualification, channel;
+
+-- ── Lookalike Seeds — histórico de audiences enviadas ao Meta ─────────────────
+CREATE TABLE IF NOT EXISTS lookalike_seeds (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  audience_id     TEXT    NOT NULL,    -- META_AUDIENCE_ID
+  seed_type       TEXT    NOT NULL,    -- 'buyer_confirmed' | 'high_intent' | 'quiz_comprador'
+  profiles_sent   INTEGER NOT NULL DEFAULT 0,
+  profiles_received INTEGER,           -- confirmado pela API Meta
+  period_days     INTEGER NOT NULL DEFAULT 30,
+  created_at      TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_lookalike_seed_type  ON lookalike_seeds(seed_type);
+CREATE INDEX IF NOT EXISTS idx_lookalike_created_at ON lookalike_seeds(created_at);