cdp-edge 1.27.0 → 1.28.0

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

@@ -0,0 +1,343 @@
+/**
+ * CDP Edge — Quiz Scoring Engine v2 (Fase 6)
+ *
+ * Análise Dimensional Automática via Workers AI (Granite 4.0 Micro):
+ *  1. Detecta o TIPO de cada pergunta (urgency, budget, timeline, fit, etc.)
+ *  2. Atribui peso automático por dimensão (budget/urgency > timeline > fit > awareness)
+ *  3. Pontua a resposta (0.0–1.0) dentro dessa dimensão
+ *  4. Calcula score ponderado final → qualification
+ *
+ * O front-end NÃO precisa declarar pesos — o engine infere tudo a partir
+ * do conteúdo da pergunta e da resposta.
+ */
+
+import { Env, TrackPayload } from '../../types.js';
+
+// ── Tipos públicos ─────────────────────────────────────────────────────────────
+
+export interface QuizAnswer {
+  question: string;
+  answer: string;
+  step?: number;
+}
+
+export type QuizQualification = 'comprador' | 'interessado' | 'curioso' | 'perdido';
+
+/** Dimensão detectada automaticamente pelo LLM para cada pergunta */
+export type QuizDimension =
+  | 'urgency'    // "preciso agora", "urgente" — peso 5
+  | 'budget'     // orçamento, financiamento, valor — peso 5
+  | 'timeline'   // prazo, quando, em quanto tempo — peso 3
+  | 'fit'        // perfil certo, problema real — peso 4
+  | 'engagement' // já pesquisou, visitou, comparou — peso 2
+  | 'awareness'  // conhece o produto/serviço — peso 1
+  | 'objection'  // dúvidas, barreiras, objeções — peso 3
+  | 'generic';   // pergunta sem dimensão clara — peso 1
+
+/** Análise por pergunta retornada pelo LLM */
+export interface QuizDimensionScore {
+  step: number;
+  dimension: QuizDimension;
+  score: number;      // 0.0–1.0 dentro da dimensão
+  weight: number;     // 1–5, inferido pelo LLM
+  signal: string;     // trecho ou palavra que motivou a nota
+}
+
+export interface QuizScoreResult {
+  qualification: QuizQualification;
+  intent_score: number;                     // 0.0–1.0 — compatível com resolveIntentScore()
+  weighted_score: number;                   // score ponderado bruto antes do mapeamento
+  confidence: number;                       // 0.0–1.0
+  reason: string;                           // frase curta em português para audit log
+  dominant_dimension: QuizDimension | null; // dimensão com maior impacto no score final
+  dimensions: QuizDimensionScore[];         // breakdown por pergunta (auditável)
+  source: 'ai' | 'heuristic';
+}
+
+// ── Prompt Granite — análise dimensional ──────────────────────────────────────
+// Instruções explícitas de formato para o modelo menor (Micro) respeitar o JSON.
+
+const QUIZ_DIMENSIONAL_PROMPT = `You are a lead qualification expert for the Brazilian digital marketing and sales funnel market.
+
+Your task: analyze each quiz question-answer pair and perform DIMENSIONAL SCORING.
+
+STEP 1 — For each Q&A pair, detect the DIMENSION:
+- "urgency":    question asks about timing urgency or immediate need ("agora", "urgente", "preciso já")
+- "budget":     question asks about money, price, investment, financing, credit approval
+- "timeline":   question asks about purchase timeframe (days/months/year)
+- "fit":        question checks if respondent matches the target profile or has the real problem
+- "engagement": question asks about prior research, visits, comparisons already done
+- "awareness":  question asks if they know the product/service/brand
+- "objection":  question surfaces doubts, barriers, or hesitations
+- "generic":    question has no clear commercial dimension
+
+STEP 2 — Score the ANSWER within that dimension (0.00 to 1.00):
+- 1.00 = strongest possible buying signal for this dimension
+- 0.50 = neutral or uncertain
+- 0.00 = negative signal (disqualifier)
+
+STEP 3 — Assign WEIGHT by dimension (do not change these mappings):
+- urgency: 5, budget: 5, fit: 4, timeline: 3, objection: 3, engagement: 2, awareness: 1, generic: 1
+
+STEP 4 — Compute weighted_score = SUM(score * weight) / SUM(weight) across all questions.
+
+STEP 5 — Map weighted_score to qualification:
+- 0.75–1.00 → "comprador"
+- 0.50–0.74 → "interessado"
+- 0.20–0.49 → "curioso"
+- 0.00–0.19 → "perdido"
+
+Reply ONLY with valid JSON. No markdown. No explanation outside the JSON:
+{
+  "dimensions": [
+    { "step": 1, "dimension": "<type>", "score": 0.00, "weight": 0, "signal": "<word or phrase>" }
+  ],
+  "weighted_score": 0.00,
+  "qualification": "<comprador|interessado|curioso|perdido>",
+  "confidence": 0.00,
+  "reason": "<one sentence in Portuguese>",
+  "dominant_dimension": "<dimension with highest score*weight product>"
+}`;
+
+// ── Pesos canônicos por dimensão (espelho do prompt — usado no fallback) ───────
+
+const DIMENSION_WEIGHTS: Record<QuizDimension, number> = {
+  urgency:    5,
+  budget:     5,
+  fit:        4,
+  timeline:   3,
+  objection:  3,
+  engagement: 2,
+  awareness:  1,
+  generic:    1,
+};
+
+// ── Mapeamento de score ponderado → intent_score suavizado ────────────────────
+// O weighted_score é uma média ponderada de scores por dimensão (0-1).
+// O intent_score preserva a mesma escala mas com limites por faixa.
+
+function _weightedToIntentScore(ws: number, qual: QuizQualification): number {
+  // Mantém o score contínuo dentro da faixa da qualificação para não perder granularidade
+  const ranges: Record<QuizQualification, [number, number]> = {
+    comprador:   [0.80, 1.00],
+    interessado: [0.50, 0.79],
+    curioso:     [0.20, 0.49],
+    perdido:     [0.00, 0.19],
+  };
+  const [lo, hi] = ranges[qual];
+  return _clamp(lo + (ws - lo) * ((hi - lo) / Math.max(hi - lo, 0.01)));
+}
+
+// ── scoreQuizAnswers — função principal ───────────────────────────────────────
+
+export async function scoreQuizAnswers(
+  env: Env,
+  answers: QuizAnswer[],
+  quizName?: string | null,
+): Promise<QuizScoreResult> {
+  if (!answers || answers.length === 0) {
+    return _fallback([], 'Nenhuma resposta recebida');
+  }
+
+  // Tenta via Workers AI
+  if (env.AI) {
+    try {
+      const answersText = answers
+        .map((a, i) => `P${a.step ?? i + 1}: "${a.question}" → "${a.answer}"`)
+        .join('\n');
+
+      const contextMsg = quizName
+        ? `Quiz: "${quizName}"\n\n${answersText}`
+        : answersText;
+
+      // max_tokens: ~80 por dimensão × N perguntas + ~120 para o envelope final
+      const maxTokens = Math.min(512, 120 + answers.length * 80);
+
+      const aiRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
+        messages: [
+          { role: 'system', content: QUIZ_DIMENSIONAL_PROMPT },
+          { role: 'user',   content: contextMsg },
+        ],
+        max_tokens: maxTokens,
+      });
+
+      const raw = (aiRes as any)?.response?.trim() ?? '';
+      const jsonMatch = raw.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) throw new Error('AI response has no JSON block');
+
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      // Valida e normaliza dimensions[]
+      const dimensions: QuizDimensionScore[] = Array.isArray(parsed.dimensions)
+        ? (parsed.dimensions as any[]).map((d, i) => ({
+            step:      typeof d.step === 'number' ? d.step : i + 1,
+            dimension: _validateDimension(d.dimension),
+            score:     _clamp(parseFloat(String(d.score ?? 0.5))),
+            weight:    typeof d.weight === 'number' ? Math.min(5, Math.max(1, d.weight)) : 1,
+            signal:    String(d.signal || '').slice(0, 100),
+          }))
+        : [];
+
+      // Recalcula weighted_score no servidor (não confia cegamente no modelo)
+      const weighted_score = _computeWeightedScore(dimensions);
+
+      const qualification     = _validateQualification(parsed.qualification);
+      const intent_score      = _weightedToIntentScore(weighted_score, qualification);
+      const confidence        = _clamp(parseFloat(String(parsed.confidence ?? 0.7)));
+      const reason            = String(parsed.reason || '').slice(0, 200);
+      const dominant_dimension = _validateDimension(parsed.dominant_dimension) as QuizDimension | null;
+
+      return {
+        qualification,
+        intent_score,
+        weighted_score,
+        confidence,
+        reason,
+        dominant_dimension,
+        dimensions,
+        source: 'ai',
+      };
+
+    } catch (err: any) {
+      console.warn('[QuizScoring] AI falhou, usando heurística:', err?.message || String(err));
+    }
+  }
+
+  return _fallback(answers, 'Workers AI indisponível');
+}
+
+// ── saveQuizSession — persiste no D1 em background ───────────────────────────
+
+export async function saveQuizSession(
+  env: Env,
+  userId: string | null | undefined,
+  payload: TrackPayload,
+  result: QuizScoreResult,
+): Promise<void> {
+  if (!env.DB) return;
+  try {
+    await env.DB.prepare(`
+      INSERT INTO quiz_sessions (
+        user_id, quiz_name, answers_json,
+        qualification, intent_score, weighted_score, confidence,
+        reason, dominant_dimension, dimensions_json, source, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    `).bind(
+      userId                               || null,
+      String(payload.quiz_name || ''),
+      JSON.stringify(payload.quiz_answers  || []),
+      result.qualification,
+      result.intent_score,
+      result.weighted_score,
+      result.confidence,
+      result.reason,
+      result.dominant_dimension            || null,
+      JSON.stringify(result.dimensions),
+      result.source,
+    ).run();
+  } catch (err: any) {
+    console.error('[QuizScoring] saveQuizSession error:', err?.message || String(err));
+  }
+}
+
+// ── Helpers internos ──────────────────────────────────────────────────────────
+
+function _clamp(n: number): number {
+  if (isNaN(n)) return 0;
+  return Math.min(1, Math.max(0, Math.round(n * 100) / 100));
+}
+
+function _validateQualification(val: unknown): QuizQualification {
+  const valid: QuizQualification[] = ['comprador', 'interessado', 'curioso', 'perdido'];
+  return valid.includes(val as QuizQualification) ? (val as QuizQualification) : 'curioso';
+}
+
+function _validateDimension(val: unknown): QuizDimension {
+  const valid: QuizDimension[] = ['urgency','budget','timeline','fit','engagement','awareness','objection','generic'];
+  return valid.includes(val as QuizDimension) ? (val as QuizDimension) : 'generic';
+}
+
+function _computeWeightedScore(dims: QuizDimensionScore[]): number {
+  if (!dims.length) return 0;
+  const sumWS  = dims.reduce((acc, d) => acc + d.score * d.weight, 0);
+  const sumW   = dims.reduce((acc, d) => acc + d.weight, 0);
+  return _clamp(sumW > 0 ? sumWS / sumW : 0);
+}
+
+// ── Fallback heurístico dimensional ──────────────────────────────────────────
+// Quando Workers AI está indisponível, classifica por padrões de texto
+// e gera um breakdown dimensional sintético para manter consistência de contrato.
+
+const HEURISTIC_DIMENSION_PATTERNS: Array<{
+  dimension: QuizDimension;
+  patterns: string[];
+}> = [
+  { dimension: 'urgency',    patterns: ['agora','hoje','urgente','imediato','já','preciso logo','não posso esperar'] },
+  { dimension: 'budget',     patterns: ['orçamento','budget','financiamento','aprovado','crédito','dinheiro','quanto custa','valor','posso pagar','tenho recurso'] },
+  { dimension: 'timeline',   patterns: ['mês','meses','semana','semanas','ano','prazo','quando','breve','futuramente','em quanto tempo'] },
+  { dimension: 'fit',        patterns: ['sim','é para mim','tenho esse problema','preciso disso','faz sentido','encaixa','me identifico'] },
+  { dimension: 'engagement', patterns: ['já pesquisei','comparei','visitei','já vi','pesquisando','avaliando','testei'] },
+  { dimension: 'awareness',  patterns: ['conheço','já ouvi','sabia','já usei','familiar'] },
+  { dimension: 'objection',  patterns: ['mas','porém','dúvida','não tenho certeza','talvez','depende','preciso pensar','não sei'] },
+];
+
+const HEURISTIC_QUAL_SCORE: Record<QuizQualification, number> = {
+  comprador: 0.87, interessado: 0.62, curioso: 0.30, perdido: 0.10,
+};
+
+function _fallback(answers: QuizAnswer[], note: string): QuizScoreResult {
+  // Gera breakdown dimensional sintético por pergunta
+  const dimensions: QuizDimensionScore[] = answers.map((a, i) => {
+    const text = `${a.question} ${a.answer}`.toLowerCase();
+
+    let bestDim: QuizDimension = 'generic';
+    let bestScore = 0.4; // neutro
+    let bestSignal = '';
+
+    for (const { dimension, patterns } of HEURISTIC_DIMENSION_PATTERNS) {
+      const matched = patterns.filter(p => text.includes(p));
+      if (matched.length > 0) {
+        // Score positivo se resposta tem sinal de compra, negativo se objeção
+        const baseScore = dimension === 'objection' ? 0.3 : 0.75;
+        if (baseScore > bestScore || (bestDim === 'generic' && matched.length > 0)) {
+          bestDim    = dimension;
+          bestScore  = baseScore;
+          bestSignal = matched[0];
+        }
+      }
+    }
+
+    return {
+      step:      a.step ?? i + 1,
+      dimension: bestDim,
+      score:     bestScore,
+      weight:    DIMENSION_WEIGHTS[bestDim],
+      signal:    bestSignal || a.answer.slice(0, 60),
+    };
+  });
+
+  const weighted_score = _computeWeightedScore(dimensions.length ? dimensions : [{ step:1, dimension:'generic', score:0.3, weight:1, signal:'' }]);
+
+  const qualification: QuizQualification =
+    weighted_score >= 0.75 ? 'comprador'   :
+    weighted_score >= 0.50 ? 'interessado' :
+    weighted_score >= 0.20 ? 'curioso'     : 'perdido';
+
+  // Dimensão dominante = maior produto score × weight
+  const dominant = dimensions.length
+    ? dimensions.reduce((best, d) =>
+        (d.score * d.weight > best.score * best.weight ? d : best)
+      ).dimension
+    : null;
+
+  return {
+    qualification,
+    intent_score:        _clamp(HEURISTIC_QUAL_SCORE[qualification]),
+    weighted_score,
+    confidence:          Math.min(0.6, 0.25 + dimensions.filter(d => d.signal).length * 0.07),
+    reason:              `${note}. Score ponderado heurístico: ${(weighted_score * 100).toFixed(0)}/100.`,
+    dominant_dimension:  dominant as QuizDimension | null,
+    dimensions,
+    source:              'heuristic',
+  };
+}

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));
+  }
+}