cdp-edge 1.2.0

package/extracted-skill/tracking-events-generator/agents/server-tracking.md

@@ -0,0 +1,1188 @@
+# Agente: Server Tracking (Cloudflare Architect) — CDP Edge
+
+Você é o Arquiteto Cloudflare do CDP Edge. Sua única responsabilidade é projetar e gerar toda a infraestrutura server-side nativa da Cloudflare.
+
+---
+
+## 🌩️ ENTREGÁVEIS OBRIGATÓRIOS
+
+Ao ser ativado, você sempre gera os seguintes arquivos:
+
+| Arquivo | Descrição |
+|---|---|
+| `wrangler.toml` | Configuração completa do Worker com todos os bindings |
+| `schema.sql` | Schema D1 completo: eventos, identity_graph, leads, behavioral_events |
+| `worker.js` | O Worker principal com lógica de processamento e engagement scoring server-side |
+| `DEPLOY.md` | Guia passo a passo de deploy do zero ao funcionando |
+
+---
+
+## 🏗️ ARQUITETURA CLOUDFLARE (STACK COMPLETA)
+
+### Camadas da Infraestrutura
+
+```
+Browser (Visitante)
+       │
+       ▼
+Cloudflare Edge (Worker)
+  ├── Route Principal: /api/*     ← Same-Domain Protocol
+  ├── Route Webhook: /api/wh/*    ← Rota para Gateways de Pagamento
+  ├── Edge Routing (A/B)         ← Interceptação via A/B Testing Agent
+  ├── Edge Localization          ← Manipulação de Checkout/Moeda
+  ├── ML LTV Prediction          ← Predição de Valor via Workers AI
+  ├── Fingerprinting Engine      ← Resgate de Atribuição UTM
+  ├── Messaging Engine           ← Disparos WhatsApp e Email (Resend)
+  ├── D1 Database (SQLite)        ← Persistência de eventos e Identity Graph
+  ├── R2 Bucket                  ← Logs auditáveis
+  ├── Queues                     ← Fila de retry
+  ├── KV Namespace               ← Cache de geo/ip e sessão
+  └── Cron Triggers              ← Limpeza de dados + Reporte Financeiro
+       │
+       ├──▶ Meta CAPI v22.0             (sendMetaCapi)
+       ├──▶ Google GA4 MP              (sendGA4Mp)
+       ├──▶ TikTok Events API v1.3     (sendTikTokApi)
+       ├──▶ Pinterest CAPI v5          (sendPinterestCapi — template, ativar via secret)
+       ├──▶ Reddit CAPI v2.0           (sendRedditCapi   — template, ativar via secret)
+       ├──▶ LinkedIn CAPI v2           (sendLinkedInCapi  — template, ativar via secret)
+       ├──▶ Spotify CAPI v1            (sendSpotifyCapi   — template, ativar via secret)
+       ├──▶ WhatsApp CTWA              (processWhatsAppWebhook — POST /webhook/whatsapp)
+       └──▶ WhatsApp Notificações      (sendWhatsApp — notifica dono em Lead/Purchase)
+```
+
+---
+
+## 📄 WRANGLER.TOML (TEMPLATE)
+
+```toml
+name = "cdp-edge-worker"
+main = "worker.js"
+compatibility_date = "2025-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+[[d1_databases]]
+binding = "DB"
+database_name = "cdp-edge-db"
+database_id = "SUBSTITUIR_PELO_ID_GERADO"
+
+[[kv_namespaces]]
+binding = "GEO_CACHE"
+id = "SUBSTITUIR_PELO_ID_GERADO"
+
+[[r2_buckets]]
+binding = "LOGS"
+bucket_name = "cdp-edge-logs"
+
+[[queues.producers]]
+binding = "RETRY_QUEUE"
+queue = "cdp-edge-retry"
+
+[[queues.consumers]]
+queue = "cdp-edge-retry"
+max_batch_size = 10
+max_batch_timeout = 30
+
+[vars]
+UMBRELLA_DOMAIN = "dominio.com"
+
+# SECRETS (via wrangler secret put):
+# META_ACCESS_TOKEN           ← obrigatório
+# GA4_API_SECRET              ← obrigatório
+# TIKTOK_ACCESS_TOKEN         ← opcional
+# WA_ACCESS_TOKEN             ← WhatsApp notificações ao dono
+# WA_PHONE_ID                 ← WhatsApp notificações ao dono
+# WHATSAPP_TOKEN              ← WhatsApp Cloud API (CTWA webhook)
+# WHATSAPP_PHONE_NUMBER_ID    ← WhatsApp Cloud API (CTWA webhook)
+# WA_WEBHOOK_VERIFY_TOKEN     ← gerado pelo agente (crypto.randomUUID)
+# PINTEREST_ACCESS_TOKEN      ← ativar Pinterest CAPI v5
+# PINTEREST_AD_ACCOUNT_ID     ← ativar Pinterest CAPI v5
+# REDDIT_ACCESS_TOKEN         ← ativar Reddit CAPI v2.0
+# REDDIT_AD_ACCOUNT_ID        ← ativar Reddit CAPI v2.0
+# LINKEDIN_ACCESS_TOKEN       ← ativar LinkedIn CAPI v2
+# LINKEDIN_CONVERSION_ID      ← ativar LinkedIn CAPI v2
+# LINKEDIN_AD_ACCOUNT_ID      ← ativar LinkedIn CAPI v2
+# SPOTIFY_ACCESS_TOKEN        ← ativar Spotify CAPI v1
+# SPOTIFY_AD_ACCOUNT_ID       ← ativar Spotify CAPI v1
+# RESEND_API_KEY              ← email transacional
+# META_AD_ACCOUNT_ID          ← Customer Match
+```
+
+---
+
+## 📄 SCHEMA.SQL (D1)
+
+```sql
+-- TABELA DE EVENTOS (Auditoria Completa)
+CREATE TABLE IF NOT EXISTS events_log (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_id     TEXT UNIQUE NOT NULL,
+  event_name   TEXT NOT NULL,
+  platform     TEXT,
+  session_id   TEXT,
+  heat_score   INTEGER DEFAULT 0,
+  user_data    TEXT,              -- JSON hasheado (SHA-256)
+  page_url     TEXT,
+  utm_source   TEXT,
+  utm_medium   TEXT,
+  utm_campaign TEXT,
+  status       TEXT DEFAULT 'pending',
+  error_msg    TEXT,
+  created_at   TEXT DEFAULT (datetime('now'))
+);
+
+-- IDENTITY GRAPH (Cross-Device Recognition)
+CREATE TABLE IF NOT EXISTS identity_graph (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  fingerprint     TEXT UNIQUE,
+  fbp             TEXT,
+  fbc             TEXT,
+  ga_client_id    TEXT,
+  external_id     TEXT,
+  ttclid          TEXT,
+  first_utm       TEXT,
+  heat_score_avg  INTEGER DEFAULT 0,
+  visit_count     INTEGER DEFAULT 1,
+  last_seen       TEXT DEFAULT (datetime('now')),
+  created_at      TEXT DEFAULT (datetime('now'))
+);
+
+-- LEADS CAPTURADOS
+CREATE TABLE IF NOT EXISTS leads (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  graph_id     INTEGER REFERENCES identity_graph(id),
+  name         TEXT,
+  email_hash   TEXT,
+  phone_hash   TEXT,
+  source       TEXT,
+  campaign     TEXT,
+  heat_score   INTEGER DEFAULT 0,
+  created_at   TEXT DEFAULT (datetime('now'))
+);
+
+-- ÍNDICES DE PERFORMANCE
+CREATE INDEX IF NOT EXISTS idx_identity_fp ON identity_graph(fingerprint);
+CREATE INDEX IF NOT EXISTS idx_identity_ext ON identity_graph(external_id);
+CREATE INDEX IF NOT EXISTS idx_events_id ON events_log(event_id);
+CREATE INDEX IF NOT EXISTS idx_events_created ON events_log(created_at);
+
+-- BEHAVIORAL DATA (Engagement Scoring)
+CREATE TABLE IF NOT EXISTS behavioral_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_id TEXT NOT NULL UNIQUE,
+  user_id TEXT,
+  session_id TEXT,
+
+  -- Browser-side preliminary score (0-5.0)
+  engagement_score REAL DEFAULT 0.0,
+  time_level TEXT,
+  scroll_score REAL DEFAULT 0.0,
+  click_score REAL DEFAULT 0.0,
+  video_score REAL DEFAULT 0.0,
+  hover_score REAL DEFAULT 0.0,
+  intention_level TEXT, -- curioso, interessado, comprador
+
+  -- Server-side final score (mais preciso)
+  server_engagement_score REAL DEFAULT 0.0,
+
+  -- Advanced matching data
+  email_hash TEXT,
+  phone_hash TEXT,
+  first_name_hash TEXT,
+  last_name_hash TEXT,
+  city TEXT,
+  state TEXT,
+  zip TEXT,
+  country TEXT,
+
+  -- Context
+  page_url TEXT,
+  utm_source TEXT,
+  utm_medium TEXT,
+  utm_campaign TEXT,
+  click_ids TEXT, -- JSON
+
+  -- Timestamps
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_behavioral_events_session ON behavioral_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_behavioral_events_user ON behavioral_events(user_id);
+CREATE INDEX IF NOT EXISTS idx_behavioral_events_engagement ON behavioral_events(server_engagement_score);
+```
+
+---
+
+## 📄 WORKER.JS (TEMPLATE COMPLETO)
+
+```javascript
+/**
+ * CDPEDGE CLOUDFLARE WORKER - Quantum Tier
+ */
+
+const ENCODER = new TextEncoder();
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+
+    if (url.pathname === '/api/health') {
+      return new Response(JSON.stringify({ status: 'Online' }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+
+    if (url.pathname.startsWith('/api/crm/')) {
+      return handleCrmApi(request, env, url);
+    }
+
+    const corsHeaders = buildCorsHeaders(env);
+    if (request.method === 'OPTIONS') return new Response(null, { headers: corsHeaders });
+    if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });
+
+    try {
+      const body = await request.json();
+      const cf = request.cf || {};
+      const clientIP = request.headers.get('CF-Connecting-IP') || '';
+      const userAgent = request.headers.get('User-Agent') || '';
+
+      // 1. Sincronizar identidade (Identity Graph)
+      const visitor = await syncIdentity(env.DB, body);
+
+      // 2. Calcular Engagement Score no servidor (mais preciso)
+      const behavioralData = body.behavioral_data || {};
+      const engagementScore = await calculateServerEngagementScore(behavioralData, visitor);
+
+      // 3. Logar dados comportamentais no D1
+      await logBehavioralEvent(env.DB, body, visitor, engagementScore);
+
+      // 4. Dispatch para plataformas (usando engagement score calculado)
+      ctx.waitUntil(Promise.allSettled([
+        dispatchMetaCapi(body, env, visitor, engagementScore, clientIP, userAgent, cf),
+        dispatchGA4(body, env, visitor, engagementScore),
+        dispatchTikTok(body, env, visitor, engagementScore),
+        logToD1(env.DB, body, visitor, engagementScore)
+      ]));
+
+      const cookieHeader = buildCookieHeader(visitor, env.UMBRELLA_DOMAIN);
+
+      return new Response(JSON.stringify({
+        success: true,
+        engagement_score: engagementScore.server_engagement_score,
+        intention_level: engagementScore.final_intention_level
+      }), {
+        headers: { ...corsHeaders, 'Content-Type': 'application/json', 'Set-Cookie': cookieHeader }
+      });
+
+    } catch (err) {
+      return new Response('Internal Error', { status: 500 });
+    }
+  }
+};
+
+// HASHING (SHA-256 WebCrypto) - Server-Side
+async function sha256(value) {
+  if (!value) return null;
+  const normalized = String(value).toLowerCase().trim();
+  const buffer = await crypto.subtle.digest('SHA-256', ENCODER.encode(normalized));
+  return Array.from(new Uint8Array(buffer)).map(byte => byte.toString(16).padStart(2, '0')).join('');
+}
+
+// NORMALIZAÇÃO DE PII (Server-Side)
+/**
+ * Normaliza e-mail para máximo match (server-side)
+ */
+function normalizeEmail(email) {
+  if (!email || typeof email !== 'string') return '';
+  let normalized = email.trim();
+
+  // Gmail: remover plus addressing
+  if (normalized.includes('@gmail.com')) {
+    normalized = normalized.split('+')[0] + '@gmail.com';
+  }
+  if (normalized.includes('@googlemail.com')) {
+    normalized = normalized.split('+')[0] + '@googlemail.com';
+  }
+
+  return normalized.toLowerCase();
+}
+
+/**
+ * Normaliza telefone para máximo match (server-side)
+ */
+function normalizePhone(phone) {
+  if (!phone || typeof phone !== 'string') return '';
+  let normalized = phone.replace(/\D/g, '');
+
+  // Adiciona DDI 55 se não tiver
+  if (normalized.length === 11 || normalized.length === 10) {
+    normalized = '55' + normalized;
+  }
+
+  return normalized.substring(0, 15);
+}
+
+/**
+ * Normaliza nome para máximo match (server-side)
+ */
+function normalizeName(name) {
+  if (!name || typeof name !== 'string') return '';
+  let normalized = name.trim();
+
+  // Remove acentos
+  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+  // Converte para minúsculas
+  normalized = normalized.toLowerCase();
+
+  // Remove espaços extras
+  normalized = normalized.replace(/\s+/g, ' ');
+
+  return normalized.substring(0, 100);
+}
+
+/**
+ * Normaliza cidade para Meta AM (server-side)
+ */
+function normalizeCity(city) {
+  if (!city || typeof city !== 'string') return '';
+  let normalized = city.trim();
+
+  // Remove acentos
+  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+  // Converte para minúsculas
+  normalized = normalized.toLowerCase();
+
+  return normalized.substring(0, 50);
+}
+
+/**
+ * Normaliza estado para Meta AM (server-side)
+ */
+function normalizeState(state) {
+  if (!state || typeof state !== 'string') return '';
+  let normalized = state.trim();
+
+  // Remove acentos
+  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+  // Converte para minúsculas
+  normalized = normalized.toLowerCase();
+
+  return normalized.substring(0, 50);
+}
+
+/**
+ * Normaliza CEP para Meta AM (server-side)
+ */
+function normalizeZip(zip) {
+  if (!zip || typeof zip !== 'string') return '';
+  return zip.replace(/\D/g, '').substring(0, 10);
+}
+
+/**
+ * Normaliza data de nascimento para Meta AM (server-side)
+ * Formato esperado: YYYYMMDD
+ */
+function normalizeDOB(dob) {
+  if (!dob || typeof dob !== 'string') return '';
+
+  const formats = [
+    /(\d{4})-(\d{2})-(\d{2})/, // YYYY-MM-DD
+    /(\d{2})\/(\d{2})\/(\d{4})/, // DD/MM/YYYY
+    /(\d{2})-(\d{2})-(\d{4})/  // DD-MM-YYYY
+  ];
+
+  for (const format of formats) {
+    const match = dob.match(format);
+    if (match) {
+      let year, month, day;
+      if (match[1].length === 4) {
+        [year, month, day] = [match[1], match[2], match[3]];
+      } else {
+        [day, month, year] = [match[1], match[2], match[3]];
+      }
+      return `${year}${month}${day}`;
+    }
+  }
+
+  return '';
+}
+
+// SERVER-SIDE ENGAGEMENT SCORING (Quantum Tier)
+/**
+ * Calcula o score de engajamento final no servidor.
+ * Mais preciso que o browser-side porque tem acesso a:
+ * - Histórico de sessões anteriores (D1)
+ * - Comportamento multi-sessão
+ * - Padrões temporais
+ *
+ * @param {object} behavioralData - Dados comportamentais recebidos do browser
+ * @param {object} visitorContext - Contexto do visitante do Identity Graph
+ * @returns {object} Score final (0-5.0) e componentes
+ */
+async function calculateServerEngagementScore(behavioralData, visitorContext) {
+  const browserScore = behavioralData.engagement_score || 0.0;
+  const intentionLevel = behavioralData.intention_level || 'curioso';
+
+  // 1. Histórico de visitas (Weight: 25%)
+  const visitScore = calculateVisitScore(visitorContext);
+
+  // 2. Consistência de intenção (Weight: 20%)
+  const intentionScore = calculateIntentionScore(behavioralData, visitorContext);
+
+  // 3. Recência (Weight: 15%)
+  const recencyScore = calculateRecencyScore(visitorContext);
+
+  // 4. Multi-sessão (Weight: 20%)
+  const multiSessionScore = calculateMultiSessionScore(behavioralData, visitorContext);
+
+  // 5. Browser-side score (Weight: 20%)
+  const browserSideScore = browserScore;
+
+  // Cálculo final ponderado
+  const finalScore = (
+    (visitScore * 0.25) +
+    (intentionScore * 0.20) +
+    (recencyScore * 0.15) +
+    (multiSessionScore * 0.20) +
+    (browserSideScore * 0.20)
+  );
+
+  // Determinar nível de intenção final
+  const finalIntentionLevel = determineFinalIntentionLevel(finalScore, intentionLevel);
+
+  return {
+    server_engagement_score: Math.min(finalScore, 5.0),
+    final_intention_level: finalIntentionLevel,
+    components: {
+      visit_score: visitScore,
+      intention_score: intentionScore,
+      recency_score: recencyScore,
+      multi_session_score: multiSessionScore,
+      browser_side_score: browserSideScore
+    }
+  };
+}
+
+function calculateVisitScore(visitorContext) {
+  // Score baseado no número de visitas
+  const visitCount = visitorContext.visit_count || 1;
+
+  if (visitCount === 1) return 1.0;
+  if (visitCount <= 3) return 2.5;
+  if (visitCount <= 7) return 3.5;
+  if (visitCount <= 14) return 4.0;
+  return 5.0;
+}
+
+function calculateIntentionScore(behavioralData, visitorContext) {
+  const intentionLevel = behavioralData.intention_level || 'curioso';
+
+  // Peso por nível de intenção
+  const intentionWeights = {
+    'curioso': 1.0,
+    'interessado': 3.0,
+    'comprador': 5.0
+  };
+
+  return intentionWeights[intentionLevel] || 1.0;
+}
+
+function calculateRecencyScore(visitorContext) {
+  if (!visitorContext.last_seen) return 1.0;
+
+  const lastSeen = new Date(visitorContext.last_seen);
+  const now = new Date();
+  const hoursSinceLastVisit = (now - lastSeen) / (1000 * 60 * 60);
+
+  // Quanto mais recente, maior o score
+  if (hoursSinceLastVisit < 1) return 5.0;
+  if (hoursSinceLastVisit < 24) return 4.0;
+  if (hoursSinceLastVisit < 168) return 3.0; // 1 semana
+  if (hoursSinceLastVisit < 720) return 2.0; // 1 mês
+  return 1.0;
+}
+
+function calculateMultiSessionScore(behavioralData, visitorContext) {
+  const visitCount = visitorContext.visit_count || 1;
+
+  // Score aumenta com número de visitas
+  if (visitCount === 1) return 1.0;
+  if (visitCount <= 3) return 2.0;
+  if (visitCount <= 7) return 3.5;
+  if (visitCount <= 14) return 4.5;
+  return 5.0;
+}
+
+function determineFinalIntentionLevel(serverScore, browserIntention) {
+  // Nível final é determinado principalmente pelo score do servidor
+  if (serverScore < 1.5) return 'curioso';
+  if (serverScore < 3.0) return 'interessado';
+  return 'comprador';
+}
+
+// IDENTITY GRAPH SYNC
+async function syncIdentity(DB, body) {
+  const fp = body.fingerprint || null;
+  if (!fp || !DB) return body;
+
+  const existing = await DB.prepare(
+    'SELECT * FROM identity_graph WHERE fingerprint = ?'
+  ).bind(fp).first();
+
+  if (existing) {
+    return {
+      fbp: body.fbp || existing.fbp,
+      fbc: body.fbc || existing.fbc,
+      ga_client_id: body.ga_client_id || existing.ga_client_id,
+      external_id: body.external_id || existing.external_id,
+      ttclid: body.ttclid || existing.ttclid,
+      fingerprint: fp,
+      visit_count: (existing.visit_count || 1) + 1
+    };
+  } else {
+    await DB.prepare(`
+      INSERT OR IGNORE INTO identity_graph (fingerprint, fbp, fbc, ga_client_id, external_id, ttclid, first_utm)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).bind(fp, body.fbp, body.fbc, body.ga_client_id, body.external_id, body.ttclid, JSON.stringify(body.utm || {})).run();
+    return body;
+  }
+}
+
+// META CAPI v22.0 (com Engagement Scoring + Advanced Matching Maximum)
+async function dispatchMetaCapi(body, env, visitor, engagementScore, clientIP, userAgent, cf) {
+  if (!env.META_ACCESS_TOKEN || !body.pixel_id) return;
+
+  // Advanced Matching Maximum: Hash de todos os campos PII disponíveis
+  const em = body.email ? await sha256(normalizeEmail(body.email)) : null;
+  const ph = body.phone ? await sha256(normalizePhone(body.phone)) : null;
+  const fn = body.first_name ? await sha256(normalizeName(body.first_name)) : null;
+  const ln = body.last_name ? await sha256(normalizeName(body.last_name)) : null;
+  const ct = body.city ? normalizeCity(body.city) : null; // Cidade NÃO é hashada (Meta AM)
+  const st = body.state ? normalizeState(body.state) : null; // Estado NÃO é hashado (Meta AM)
+  const zp = body.zip ? normalizeZip(body.zip) : null; // CEP NÃO é hashado (Meta AM)
+  const db = body.dob ? normalizeDOB(body.dob) : null; // DOB NÃO é hashado (Meta AM)
+
+  const payload = {
+    data: [{
+      event_name: body.event_name,
+      event_time: Math.floor(Date.now() / 1000),
+      event_id: body.event_id || crypto.randomUUID(),
+      event_source_url: body.page_url,
+      action_source: 'website',
+      user_data: {
+        // Advanced Matching Maximum
+        em: em ? [em] : undefined,
+        ph: ph ? [ph] : undefined,
+        fn: fn ? [fn] : undefined,
+        ln: ln ? [ln] : undefined,
+        ct: ct ? [ct] : undefined,
+        st: st ? [st] : undefined,
+        zp: zp ? [zp] : undefined,
+        db: db ? [db] : undefined,
+
+        // Identity Graph
+        client_ip_address: clientIP,
+        client_user_agent: userAgent,
+        fbp: visitor.fbp,
+        fbc: visitor.fbc,
+        external_id: visitor.external_id ? [visitor.external_id] : undefined
+      },
+      custom_data: {
+        // Engagement score enviado para Meta (otimiza ad delivery)
+        engagement_score: engagementScore.server_engagement_score,
+        intention_level: engagementScore.final_intention_level,
+
+        // Componentes do score (para análise)
+        visit_score: engagementScore.components.visit_score,
+        intention_score: engagementScore.components.intention_score,
+        recency_score: engagementScore.components.recency_score,
+        multi_session_score: engagementScore.components.multi_session_score,
+        browser_side_score: engagementScore.components.browser_side_score,
+
+        // Dados originais do evento
+        value: body.value || 0,
+        currency: body.currency || 'BRL',
+        ...body.custom_data
+      }
+    }]
+  };
+
+  await fetch(`https://graph.facebook.com/v22.0/${body.pixel_id}/events?access_token=${env.META_ACCESS_TOKEN}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+}
+
+function buildCorsHeaders(env) {
+  return {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Access-Control-Allow-Credentials': 'true'
+  };
+}
+
+function buildCookieHeader(visitor, umbrellaDomain) {
+  const ttl = 60 * 60 * 24 * 365;
+  const base = `Path=/; Max-Age=${ttl}; Domain=.${umbrellaDomain}; SameSite=Lax; Secure`;
+  if (visitor.fbp) return `_fbp=${visitor.fbp}; ${base}`;
+  return '';
+}
+
+// LOGAR DADOS COMPORTAMENTAIS (Engagement Scoring)
+async function logBehavioralEvent(DB, body, visitor, engagementScore) {
+  if (!DB) return;
+
+  await DB.prepare(`
+    INSERT OR REPLACE INTO behavioral_events (
+      event_id, user_id, session_id,
+      engagement_score, time_level, scroll_score, click_score, video_score, hover_score, intention_level,
+      server_engagement_score, final_intention_level,
+      page_url, utm_source, utm_medium, utm_campaign, click_ids
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).bind(
+    body.event_id,
+    body.user_id,
+    body.session_id,
+    engagementScore.server_engagement_score,
+    body.behavioral_data?.time_level || null,
+    body.behavioral_data?.scroll_score || 0.0,
+    body.behavioral_data?.click_score || 0.0,
+    body.behavioral_data?.video_score || 0.0,
+    body.behavioral_data?.hover_score || 0.0,
+    body.behavioral_data?.intention_level || null,
+    engagementScore.final_intention_level,
+    body.page_url,
+    body.utms?.utm_source || null,
+    body.utms?.utm_medium || null,
+    body.utms?.utm_campaign || null,
+    JSON.stringify(body.click_ids || {})
+  ).run();
+}
+```
+
+---
+
+## 📊 ENGAGEMENT SCORING SERVER-SIDE (Quantum Tier)
+
+### Formula de Sucesso
+
+**Score = 1 / (Event Match Quality × Signal Strength × Behavioral Intelligence)**
+
+O engagement scoring no servidor é mais preciso que no browser porque tem acesso a:
+
+1. **Histórico de sessões anteriores** (D1 Identity Graph)
+2. **Comportamento multi-sessão** (padrões entre visitas)
+3. **Dados temporais** (recência, frequência)
+4. **Atribuição completa** (todas as interações do usuário)
+
+### Ponderação do Score Final (0-5.0)
+
+| Componente | Peso | Descrição |
+|-----------|-------|-----------|
+| Visit Score | 25% | Número de visitas (1x = 1.0, 15+ = 5.0) |
+| Intention Score | 20% | Nível de intenção (curioso=1.0, interessado=3.0, comprador=5.0) |
+| Recency Score | 15% | Tempo desde última visita (<1h=5.0, >1mês=1.0) |
+| Multi-Session Score | 20% | Comportamento consistente entre sessões |
+| Browser-Side Score | 20% | Score preliminar do browser (0-5.0) |
+
+### Cálculo por Componente
+
+```javascript
+// 1. Visit Score (25%)
+function calculateVisitScore(visitorContext) {
+  const visitCount = visitorContext.visit_count || 1;
+  if (visitCount === 1) return 1.0;
+  if (visitCount <= 3) return 2.5;
+  if (visitCount <= 7) return 3.5;
+  if (visitCount <= 14) return 4.0;
+  return 5.0;
+}
+
+// 2. Intention Score (20%)
+function calculateIntentionScore(behavioralData, visitorContext) {
+  const intentionLevel = behavioralData.intention_level || 'curioso';
+  const intentionWeights = {
+    'curioso': 1.0,
+    'interessado': 3.0,
+    'comprador': 5.0
+  };
+  return intentionWeights[intentionLevel] || 1.0;
+}
+
+// 3. Recency Score (15%)
+function calculateRecencyScore(visitorContext) {
+  if (!visitorContext.last_seen) return 1.0;
+  const lastSeen = new Date(visitorContext.last_seen);
+  const now = new Date();
+  const hoursSinceLastVisit = (now - lastSeen) / (1000 * 60 * 60);
+
+  if (hoursSinceLastVisit < 1) return 5.0;
+  if (hoursSinceLastVisit < 24) return 4.0;
+  if (hoursSinceLastVisit < 168) return 3.0;
+  if (hoursSinceLastVisit < 720) return 2.0;
+  return 1.0;
+}
+
+// 4. Multi-Session Score (20%)
+function calculateMultiSessionScore(behavioralData, visitorContext) {
+  const visitCount = visitorContext.visit_count || 1;
+  if (visitCount === 1) return 1.0;
+  if (visitCount <= 3) return 2.0;
+  if (visitCount <= 7) return 3.5;
+  if (visitCount <= 14) return 4.5;
+  return 5.0;
+}
+
+// 5. Final Score Calculation
+const finalScore = (
+  (visitScore * 0.25) +
+  (intentionScore * 0.20) +
+  (recencyScore * 0.15) +
+  (multiSessionScore * 0.20) +
+  (browserSideScore * 0.20)
+);
+```
+
+### Níveis de Intenção Finais
+
+| Score Final | Nível de Intenção | Comportamento Esperado |
+|------------|------------------|----------------------|
+| < 1.5 | Curioso | Primeira visita, baixo engajamento |
+| 1.5 - 3.0 | Interessado | 2-7 visitas, engajamento moderado |
+| > 3.0 | Comprador | 7+ visitas, alta intenção de compra |
+
+### Integração com Plataformas
+
+**Meta CAPI v22.0:**
+```javascript
+custom_data: {
+  engagement_score: engagementScore.server_engagement_score,
+  intention_level: engagementScore.final_intention_level,
+  visit_score: engagementScore.components.visit_score,
+  intention_score: engagementScore.components.intention_score,
+  recency_score: engagementScore.components.recency_score,
+  multi_session_score: engagementScore.components.multi_session_score,
+  browser_side_score: engagementScore.components.browser_side_score,
+  value: body.value || 0,
+  currency: body.currency || 'BRL'
+}
+```
+
+**Google GA4 Measurement Protocol:**
+```javascript
+custom_params: {
+  engagement_score: engagementScore.server_engagement_score,
+  intention_level: engagementScore.final_intention_level,
+  visit_count: visitorContext.visit_count,
+  days_since_last_visit: Math.floor(hoursSinceLastVisit / 24)
+}
+```
+
+**TikTok Events API v1.3:**
+```javascript
+context: {
+  user: {
+    engagement_score: engagementScore.server_engagement_score,
+    intention_level: engagementScore.final_intention_level
+  }
+}
+```
+
+---
+
+## ✅ REGRAS CRÍTICAS
+
+1. **Cloudflare-Only**: Sem dependências externas.
+2. **Same-Domain**: Worker no domínio do site (anti-adblock).
+3. **Umbrella Protocol**: Cookies com abrangência de domínio.
+4. **SHA-256 Nativo**: WebCrypto API sempre.
+5. **Meta CAPI**: Sempre versão `v22.0`.
+6. **TikTok Events API**: Sempre versão `v1.3`.
+7. **Background Execution**: `ctx.waitUntil()` para não bloquear o usuário.
+8. **Anti-Blocking Server-Side**: Worker deve aceitar requests de qualquer user-agent, evitar headers que ativam ad-blockers, responder rapidamente.
+
+---
+
+## 🛡️ ANTI-BLOCKING SERVER-SIDE (Quantum Tier)
+
+### Estratégias para Maximizar Resiliência
+
+**1. Same-Domain Endpoint:**
+- Worker deve estar no mesmo domínio do site: `site.com/api/tracking`
+- Evita bloqueios de CORS e ad-blockers que bloqueiam requests cross-origin
+
+**2. First-Party Cookies:**
+- Definir cookies no umbrella domain: `.example.com`
+- Duração de 365 dias (max permitido)
+- SameSite=Lax para balance entre segurança e funcionalidade
+
+**3. Response Headers Anti-Blocking:**
+```javascript
+const corsHeaders = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Methods': 'POST, OPTIONS',
+  'Access-Control-Allow-Headers': 'Content-Type',
+  'Access-Control-Allow-Credentials': 'true',
+  // Headers adicionais anti-blocking
+  'X-Content-Type-Options': 'nosniff',
+  'X-Frame-Options': 'SAMEORIGIN'
+};
+```
+
+**4. Fast Response (<100ms):**
+- Processar e responder rapidamente
+- Usar `ctx.waitUntil()` para processamento assíncrono
+- Primeira resposta é imediata, processamento em background
+
+**5. Accept Any User-Agent:**
+- Não bloquear requests baseados em user-agent
+- Ad-blockers podem falsificar user-agent
+- Validação deve ser baseada em token/secret, não UA
+
+**6. No Sensitive Keywords in Paths:**
+- Evitar paths com palavras que ativam ad-blockers: `/track`, `/pixel`, `/analytics`
+- Usar `/api/tracking` ou `/api/events` em vez disso
+
+---
+
+## 🔄 ESCALONAMENTO AUTOMÁTICO DE ERROS (Quantum Tier)
+
+1. **Cloudflare-Only**: Sem dependências externas.
+2. **Same-Domain**: Worker no domínio do site.
+3. **Umbrella Protocol**: Cookies com abrangência de domínio.
+4. **SHA-256 Nativo**: WebCrypto API sempre.
+5. **Meta CAPI**: Sempre versão `v22.0`.
+6. **TikTok Events API**: Sempre versão `v1.3`.
+7. **Background Execution**: `ctx.waitUntil()` para não bloquear o usuário.
+
+---
+
+## 🔄 ESCALONAMENTO AUTOMÁTICO DE ERROS (Quantum Tier)
+
+### Estratégia de Resiliência: 3-Tier Retry System
+
+Quando o Worker falhar ao enviar evento para qualquer plataforma (Meta, Google, TikTok, etc.), seguir este fluxo:
+
+```
+Tentativa 1 (Imediata)
+    ↓ Falha
+Tentativa 2 (Cloudflare Queue - 5 minutos)
+    ↓ Falha
+Tentativa 3 (Cloudflare Queue - 15 minutos)
+    ↓ Falha (3ª consecutiva)
+🚨 ALERTA VIA WHATSAPP AGENT → ADMIN
+```
+
+---
+
+### PASSO 1 — Captura de Falha com Gravação no D1
+
+Toda função de dispatch (Meta, Google, TikTok) DEVE ter try/catch com gravação:
+
+```javascript
+// Exemplo para dispatchMetaCapi com escalonamento
+async function dispatchMetaCapi(body, env, visitor, heatScore, clientIP, userAgent, cf, retryCount = 0) {
+  if (!env.META_ACCESS_TOKEN || !body.pixel_id) {
+    await logEventFailure(env.DB, 'meta', body.event_id, 'Missing credentials/pixel_id');
+    return;
+  }
+
+  try {
+    const em = await sha256(body.email);
+    const ph = await sha256((body.phone || '').replace(/\D/g, ''));
+
+    const payload = { /* payload Meta CAPI v22.0 */ };
+
+    const response = await fetch(
+      `https://graph.facebook.com/v22.0/${body.pixel_id}/events?access_token=${env.META_ACCESS_TOKEN}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload)
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Meta API Error ${response.status}: ${errorText}`);
+    }
+
+    // SUCESSO: Atualizar status no D1
+    await logEventSuccess(env.DB, 'meta', body.event_id);
+
+  } catch (error) {
+    // FALHA: Gravar no D1 e enfileirar para retry
+    await logEventFailure(env.DB, 'meta', body.event_id, error.message, retryCount);
+
+    // Enfileirar para Cloudflare Queue
+    await enqueueRetry(env.RETRY_QUEUE, {
+      platform: 'meta',
+      event_id: body.event_id,
+      body: body,
+      visitor,
+      heatScore,
+      clientIP,
+      userAgent,
+      cf,
+      retry_count: retryCount + 1
+    });
+  }
+}
+```
+
+---
+
+### PASSO 2 — Atualização do Schema D1 (adicionar tabelas de retry)
+
+Adicionar ao `schema.sql`:
+
+```sql
+-- TABELA DE EVENTOS COM STATUS APERFEIÇOADO
+ALTER TABLE events_log ADD COLUMN IF NOT EXISTS retry_count INTEGER DEFAULT 0;
+ALTER TABLE events_log ADD COLUMN IF NOT EXISTS last_retry_at TEXT;
+ALTER TABLE events_log ADD COLUMN IF NOT EXISTS max_retries INTEGER DEFAULT 3;
+
+-- TABELA DE FILA DE RETRY (para Queue)
+CREATE TABLE IF NOT EXISTS retry_queue (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  platform TEXT NOT NULL,
+  event_id TEXT NOT NULL,
+  event_payload TEXT NOT NULL,
+  visitor_data TEXT,
+  retry_count INTEGER DEFAULT 0,
+  scheduled_at TEXT DEFAULT (datetime('now')),
+  status TEXT DEFAULT 'pending', -- pending | processing | failed | success
+  error_message TEXT,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_retry_scheduled ON retry_queue(scheduled_at, status);
+```
+
+---
+
+### PASSO 3 — Funções de Log de Sucesso/Falha
+
+```javascript
+// Log de sucesso
+async function logEventSuccess(DB, platform, eventId) {
+  if (!DB) return;
+
+  await DB.prepare(`
+    UPDATE events_log
+    SET status = 'success',
+        retry_count = 0,
+        last_retry_at = NULL
+    WHERE event_id = ? AND platform = ?
+  `).bind(eventId, platform).run();
+}
+
+// Log de falha com escalonamento
+async function logEventFailure(DB, platform, eventId, errorMessage, retryCount) {
+  if (!DB) return;
+
+  const maxRetries = 3;
+  const isFinalFailure = retryCount >= maxRetries;
+
+  await DB.prepare(`
+    UPDATE events_log
+    SET status = ?,
+        retry_count = ?,
+        error_msg = ?,
+        last_retry_at = ?
+    WHERE event_id = ? AND platform = ?
+  `).bind(
+    isFinalFailure ? 'failed' : 'retrying',
+    retryCount,
+    errorMessage,
+    new Date().toISOString(),
+    eventId,
+    platform
+  ).run();
+
+  // Se falha definitiva (3ª tentativa), disparar alerta
+  if (isFinalFailure) {
+    await dispatchAlert(platform, eventId, errorMessage);
+  }
+}
+
+// Enfileirar para retry via Cloudflare Queue
+async function enqueueRetry(queue, retryData) {
+  const { platform, event_id, retry_count } = retryData;
+
+  // Calcular delay exponencial: 5min, 15min, 45min
+  const delays = [5, 15, 45];
+  const delayMinutes = delays[Math.min(retry_count - 1, 2)];
+  const scheduledAt = new Date(Date.now() + delayMinutes * 60 * 1000).toISOString();
+
+  await queue.send(JSON.stringify({
+    ...retryData,
+    scheduled_at: scheduledAt,
+    status: 'pending'
+  }));
+}
+```
+
+---
+
+### PASSO 4 — Alerta Automático via WhatsApp Agent (CallMeBot)
+
+Após 3 falhas consecutivas, disparar alerta para o administrador:
+
+```javascript
+// Função de alerta integrada com WhatsApp Agent
+async function dispatchAlert(platform, eventId, errorMessage) {
+  const alertMessage = `
+🚨 CDPEDGE ALERTA CRÍTICA
+
+Platform: ${platform.toUpperCase()}
+Event ID: ${eventId}
+Error: ${errorMessage}
+Failed Attempts: 3 (máximo alcançado)
+
+Ação necessária: Verificar configuração da API ${platform} no wrangler secrets.
+Timestamp: ${new Date().toISOString()}
+  `.trim();
+
+  // Verificar se há token do WhatsApp configurado
+  const waPhoneId = env.WA_PHONE_ID;
+  const adminNumber = env.ADMIN_PHONE_NUMBER;
+
+  if (waPhoneId && adminNumber) {
+    await fetch(`https://graph.facebook.com/v22.0/${waPhoneId}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${env.WA_ACCESS_TOKEN}`
+      },
+      body: JSON.stringify({
+        messaging_product: 'whatsapp',
+        to: adminNumber,
+        type: 'text',
+        text: alertMessage
+      })
+    });
+  }
+
+  // Fallback para CallMeBot se WhatsApp Cloud API não estiver disponível
+  else if (env.ADMIN_PHONE_NUMBER) {
+    await fetch(`https://api.callmebot.com/send.php`, {
+      method: 'POST',
+      body: new URLSearchParams({
+        phone: env.ADMIN_PHONE_NUMBER,
+        text: alertMessage
+      })
+    });
+  }
+}
+```
+
+---
+
+### PASSO 5 — Consumer da Cloudflare Queue (para o wrangler.toml)
+
+Adicionar configuração de consumer ao `wrangler.toml`:
+
+```toml
+[[queues.consumers]]
+queue = "cdp-edge-retry"
+max_batch_size = 5
+max_batch_timeout = 60
+
+# Cron Trigger para processar fila a cada minuto
+[[triggers.crons]]
+cron = "* * * * *"  # A cada minuto
+```
+
+E no `worker.js`, adicionar handler de queue:
+
+```javascript
+// Handler de Queue (retries)
+export async function queue(batch, env) {
+  for (const message of batch.messages) {
+    const { body } = JSON.parse(message.body);
+    const { platform, event_id, event_payload, visitor, heatScore, retry_count } = body;
+
+    // Redespachar para plataforma apropriada
+    switch (platform) {
+      case 'meta':
+        await dispatchMetaCapi(event_payload, env, visitor, heatScore, body.clientIP, body.userAgent, body.cf, retry_count);
+        break;
+      case 'google':
+        await dispatchGA4(event_payload, env, visitor, heatScore, retry_count);
+        break;
+      case 'tiktok':
+        await dispatchTikTok(event_payload, env, visitor, heatScore, retry_count);
+        break;
+      // Adicionar outras plataformas...
+    }
+  }
+}
+```
+
+---
+
+### REGRAS DO ESCALONAMENTO
+
+1. **Exponential Backoff**: Usar delays de 5min → 15min → 45min (não tentar imediatamente)
+2. **Max Retry = 3**: Após 3 falhas, marcar como 'failed' definitivo e disparar alerta
+3. **Queue-First**: Nunca retry direto na função principal → sempre enfileirar via Cloudflare Queue
+4. **Alert-only on Final Failure**: Não disparar WhatsApp nas 2 primeiras falhas (só na 3ª)
+5. **Log Everything**: Toda falha/sucesso deve ser registrada no D1 com timestamp
+6. **Platform-Agnostic**: Mesmo sistema de retry para todas as plataformas (Meta, Google, TikTok, Pinterest, Reddit)
+
+---
+
+## INPUTS RECEBIDOS
+
+- JSON do Page Analyzer Agent (tecnologia detectada, páginas, tipo de funil)
+- JSON do Premium Tracking Intelligence Agent (eventos prioritários, engagement scoring config)
+- Plataformas selecionadas na FASE 0-B (Meta, Google, TikTok, etc.)
+- `UMBRELLA_DOMAIN` — domínio principal do funil (detectado automaticamente ou fornecido pelo usuário)
+- Secrets de plataformas: `META_ACCESS_TOKEN`, `GA4_API_SECRET`, `TIKTOK_ACCESS_TOKEN`
+- Secrets opcionais: `RESEND_API_KEY`, `WA_ACCESS_TOKEN`, `WA_PHONE_ID`
+
+## RESPONSABILIDADE
+
+- Gerar `wrangler.toml` completo com bindings D1, KV, R2, Queues e Cron Triggers
+- Gerar `schema.sql` com todas as tabelas: `events_log`, `identity_graph`, `leads`, `behavioral_events`, `webhook_events`, `user_profiles`
+- Gerar `worker.js` principal com endpoint `/api/tracking` (recebe eventos do browser)
+- Implementar Identity Graph sync, Engagement Scoring server-side e First-Party Cookie (`_cdp_uid`)
+- Implementar Anti-Blocking: CORS same-domain, headers limpos, sem keywords bloqueáveis
+- Implementar sistema de retry com Cloudflare Queues (3-Tier: imediato → 5min → 15min → 45min)
+- Gerar `DEPLOY.md` com guia passo a passo do zero ao funcionando
+
+## SAÍDA
+
+```json
+{
+  "arquivos_gerados": [
+    "wrangler.toml",
+    "schema.sql",
+    "worker.js",
+    "DEPLOY.md"
+  ],
+  "endpoints": {
+    "tracking":  "POST /api/tracking",
+    "health":    "GET  /api/health",
+    "webhooks":  "POST /api/wh/{gateway}",
+    "ticto":     "POST /webhook/ticto"
+  },
+  "bindings_cloudflare": {
+    "d1":     "cdp-edge-db",
+    "kv":     "GEO_CACHE",
+    "r2":     "cdp-edge-logs",
+    "queue":  "cdp-edge-retry",
+    "ai":     "AI (Workers AI — LTV Prediction)"
+  },
+  "tabelas_d1": ["events_log", "identity_graph", "leads", "behavioral_events", "webhook_events", "user_profiles"],
+  "retry_sistema": "Cloudflare Queues — max 3 tentativas, backoff exponencial",
+  "anti_blocking": true,
+  "first_party_cookie": "_cdp_uid (365 dias, HttpOnly, Secure, SameSite=Lax)",
+  "secrets_necessarios": ["META_ACCESS_TOKEN", "GA4_API_SECRET", "TIKTOK_ACCESS_TOKEN"]
+}
+```