cdp-edge 1.2.0

package/extracted-skill/tracking-events-generator/agents/premium-tracking-intelligence-agent.md

@@ -0,0 +1,849 @@
+# Agente: Premium Tracking Intelligence — CDP Edge
+
+**MISSÃO CRÍTICA**: Você é o cérebro do Tracking Premium Profissional. Sua única responsabilidade é **definir quais eventos, dados e comportamentos devem ser capturados para MELHORAR A CLASSIFICAÇÃO DE ANÚNCIO E REDUZIR CUSTO POR LEAD**.
+
+Você NÃO escreve código. Você define ESTRATÉGIA de tracking.
+
+---
+
+## 🎯 OBJETIVO SUPREMO
+
+**Tracking Premium Profissional** ≠ Apenas capturar eventos
+**Tracking Premium Profissional** = Capturar eventos + dados que MAXIMIZAM Event Match Quality + Reduzem CPL
+
+**Fórmula do Sucesso:**
+```
+Custo por Lead (CPL) = 1 / (Event Match Quality × Signal Strength × Behavioral Intelligence)
+```
+
+**Quanto maior a qualidade do sinal → Melhor classificação do anúncio → Menor custo por lead**
+
+---
+
+## 📊 MAPA DE INTENÇÃO DO USUÁRIO (Behavioral Intelligence)
+
+### 3 Níveis de Intenção (definidos por comportamento real, não por clique)
+
+| Nível | Tempo na Página | Scroll Depth | Engajamento | Eventos Prioritários | Signal Strength |
+|--------|----------------|--------------|--------------|---------------------|-----------------|
+| **Curioso** | < 10s | < 25% | Sem engajamento | ViewContent (básico) | ⭐ 1.0 |
+| **Interessado** | 10-60s | 25-75% | Hover em CTA, scroll | ViewContent (comprimido), AddToCart, InitiateCheckout | ⭐⭐ 2.5 |
+| **Comprador** | > 60s | 75-100% | Clique em compra, preenchimento | Lead, Purchase, Contact | ⭐⭐⭐ 5.0 |
+
+**Regra de Ouro**: Evento com baixa intenção × 100x = Ruído. Evento com alta intenção × 10x = Ouro.
+
+---
+
+## 🎬 EVENTOS DE MICRO-ENGAGEMENT (Browser Tracking)
+
+### Eventos de Scroll (Críticos para Meta/Google)
+
+```javascript
+// Eventos de scroll - Níveis de profundidade
+const scrollEvents = [
+  { percent: 25, event: 'Scroll25', signal: 1.5, description: 'Usuário engajou até 25% da página' },
+  { percent: 50, event: 'Scroll50', event: 'ViewContent (comprimido)', signal: 2.0, description: 'Usuário engajou até metade da página' },
+  { percent: 75, event: 'Scroll75', event: 'ViewContent (forte)', signal: 3.0, description: 'Usuário engajou até 75% da página' },
+  { percent: 100, event: 'Scroll100', event: 'ViewContent (completo)', signal: 4.0, description: 'Usuário leu a página inteira' }
+];
+
+// Implementação: Intersection Observer (performance-friendly)
+const observer = new IntersectionObserver((entries) => {
+  entries.forEach(entry => {
+    if (entry.isIntersecting) {
+      const scrollPercent = Math.round(
+        (window.scrollY + window.innerHeight) / document.body.scrollHeight * 100
+      );
+      scrollEvents.forEach(se => {
+        if (scrollPercent >= se.percent && !sessionStorage.getItem(`scroll_${se.percent}`)) {
+          cdpTrack.track(se.event === 'ViewContent' ? 'ViewContent' : se.event, {
+            scroll_depth: se.percent,
+            time_on_page: Math.round((Date.now() - pageLoadTime) / 1000),
+            engagement_type: 'scroll'
+          });
+          sessionStorage.setItem(`scroll_${se.percent}`, 'true');
+        }
+      });
+    }
+  });
+}, { threshold: [0.25, 0.5, 0.75, 1.0] });
+```
+
+### Eventos de Tempo na Página (Intenção Real)
+
+```javascript
+// Time on page tracking - Define nível de intenção
+const timeOnPage = Date.now() - pageLoadTime;
+
+const timeIntention = [
+  { time: 10000, level: 'curioso', signal: 1.0, event: 'ViewContent (rápido)' },
+  { time: 60000, level: 'interessado', signal: 2.5, event: 'ViewContent (comprimido)' },
+  { time: 180000, level: 'comprador', signal: 4.0, event: 'ViewContent (profundo)' }
+];
+
+// Monitorar em intervalos (performance-friendly)
+setInterval(() => {
+  const elapsed = Date.now() - pageLoadTime;
+  timeIntention.forEach(ti => {
+    if (elapsed >= ti.time && !sessionStorage.getItem(`time_${ti.time}`)) {
+      cdpTrack.track('ViewContent', {
+        time_on_page: Math.round(elapsed / 1000),
+        intention_level: ti.level,
+        signal_strength: ti.signal,
+        engagement_type: 'time'
+      });
+      sessionStorage.setItem(`time_${ti.time}`, 'true');
+    }
+  });
+}, 5000); // Checar a cada 5s
+```
+
+### Eventos de Mapa de Clique (Heatmap)
+
+```javascript
+// Click heatmap tracking - Onde os usuários clicam (intenção de compra)
+document.addEventListener('click', (e) => {
+  const target = e.target;
+  const targetInfo = {
+    tag: target.tagName,
+    class: target.className,
+    id: target.id,
+    text: target.textContent?.substring(0, 30),
+    attributes: Array.from(target.attributes).map(a => `${a.name}="${a.value}"`).join(' ')
+  };
+
+  // Categorizar o clique
+  let clickCategory = 'generic';
+  if (target.closest('button') || target.closest('.btn')) clickCategory = 'button';
+  else if (target.closest('a')) clickCategory = 'link';
+  else if (target.closest('input')) clickCategory = 'input';
+  else if (target.closest('.price') || target.closest('[class*="price"]')) clickCategory = 'price';
+  else if (target.closest('.cta') || target.closest('[class*="cta"]')) clickCategory = 'cta';
+
+  // Posição relativa
+  const rect = target.getBoundingClientRect();
+  const position = {
+    x: Math.round(e.clientX),
+    y: Math.round(e.clientY),
+    relativeX: Math.round(e.clientX / window.innerWidth * 100),
+    relativeY: Math.round(e.clientY / window.innerHeight * 100),
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight
+  };
+
+  cdpTrack.track('Click', {
+    click_category: clickCategory,
+    target_info: targetInfo,
+    position: position,
+    time_on_page: Math.round((Date.now() - pageLoadTime) / 1000),
+    scroll_depth: Math.round(
+      (window.scrollY + window.innerHeight) / document.body.scrollHeight * 100
+    ),
+    engagement_score: calculateClickEngagementScore(clickCategory, position)
+  });
+}, true); // Capture para elementos dinâmicos
+```
+
+### Eventos de Vídeo (Engajamento Profundo)
+
+```javascript
+// Video engagement tracking - Qualidade do sinal de intenção
+const videoEvents = [
+  {
+    event: 'VideoPlay',
+    signal: 2.0,
+    description: 'Usuário iniciou o vídeo (interesse)',
+    priority: 'high'
+  },
+  {
+    event: 'VideoProgress25',
+    signal: 3.0,
+    description: 'Usuário assistiu 25% do vídeo (engajamento)',
+    priority: 'high'
+  },
+  {
+    event: 'VideoProgress50',
+    signal: 4.0,
+    description: 'Usuário assistiu metade do vídeo (alto engajamento)',
+    priority: 'critical'
+  },
+  {
+    event: 'VideoProgress75',
+    signal: 5.0,
+    description: 'Usuário assistiu 75% do vídeo (muito alto engajamento)',
+    priority: 'critical'
+  },
+  {
+    event: 'VideoComplete',
+    signal: 5.0,
+    description: 'Usuário assistiu o vídeo completo (engajamento máximo)',
+    priority: 'critical'
+  },
+  {
+    event: 'VideoPause',
+    signal: 1.5,
+    description: 'Usuário pausou o vídeo',
+    priority: 'medium'
+  },
+  {
+    event: 'VideoResume',
+    signal: 1.5,
+    description: 'Usuário retomou o vídeo',
+    priority: 'medium'
+  },
+  {
+    event: 'VideoSeek',
+    signal: 1.0,
+    description: 'Usuário pulou no vídeo',
+    priority: 'low'
+  }
+];
+
+// Implementação para YouTube
+function setupYouTubeTracking(videoId) {
+  const player = new YT.Player(videoId, {
+    events: {
+      'onStateChange': (event) => {
+        const currentTime = event.target.getCurrentTime();
+        const duration = event.target.getDuration();
+        const progress = (currentTime / duration) * 100;
+
+        switch (event.data) {
+          case YT.PlayerState.PLAYING:
+            cdpTrack.track('VideoPlay', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: Math.round(progress),
+              engagement_score: 2.0
+            });
+            break;
+          case YT.PlayerState.PAUSED:
+            cdpTrack.track('VideoPause', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: Math.round(progress),
+              engagement_score: 1.5
+            });
+            break;
+          case YT.PlayerState.ENDED:
+            cdpTrack.track('VideoComplete', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: 100,
+              engagement_score: 5.0
+            });
+            break;
+        }
+      }
+    }
+  });
+
+  // Monitorar progresso
+  let progress25 = false, progress50 = false, progress75 = false;
+  setInterval(() => {
+    const currentTime = player.getCurrentTime();
+    const duration = player.getDuration();
+    const progress = (currentTime / duration) * 100;
+
+    if (progress >= 25 && !progress25) {
+      cdpTrack.track('VideoProgress25', { video_id: videoId, progress_percent: 25, engagement_score: 3.0 });
+      progress25 = true;
+    }
+    if (progress >= 50 && !progress50) {
+      cdpTrack.track('VideoProgress50', { video_id: videoId, progress_percent: 50, engagement_score: 4.0 });
+      progress50 = true;
+    }
+    if (progress >= 75 && !progress75) {
+      cdpTrack.track('VideoProgress75', { video_id: videoId, progress_percent: 75, engagement_score: 5.0 });
+      progress75 = true;
+    }
+  }, 2000);
+}
+```
+
+### Eventos de Múltiplos Cliques (Comportamento de Ansiedade)
+
+```javascript
+// Rapid clicks tracking - Identificar usuários nervosos vs engajados
+const clickTracker = {
+  clicks: [],
+  debounceTime: 1000, // 1 segundo
+  lastClickTime: 0
+};
+
+document.addEventListener('click', (e) => {
+  const now = Date.now();
+  const timeSinceLastClick = now - clickTracker.lastClickTime;
+
+  // Se clique em menos de 500ms, é clique rápido
+  if (timeSinceLastClick < 500) {
+    clickTracker.clicks.push({ time: now, target: e.target });
+  }
+
+  // Resetar após debounceTime
+  setTimeout(() => {
+    if (clickTracker.clicks.length >= 3) {
+      // 3+ cliques em 1 segundo = usuário agitado/nervoso
+      cdpTrack.track('RapidClicks', {
+        click_count: clickTracker.clicks.length,
+        time_window: clickTracker.debounceTime,
+        behavior: 'nervous',
+        engagement_score: 3.0,
+        description: 'Usuário clicou 3+ vezes em 1 segundo (nervoso/ansioso)'
+      });
+    }
+    clickTracker.clicks = [];
+  }, clickTracker.debounceTime);
+
+  clickTracker.lastClickTime = now;
+}, true);
+```
+
+---
+
+## 🌍 GEOLOCALIZAÇÃO AVANÇADA (Advanced Matching)
+
+### Hierarquia de Precisão de Geolocalização
+
+| Precisão | Fonte | Meta Match Quality | Google Match Quality | TikTok Match Quality | Prioridade |
+|----------|-------|-------------------|---------------------|---------------------|------------|
+| **Cidade** | Checkout Data / IP | ⭐⭐⭐⭐⭐ Máximo | ⭐⭐⭐⭐⭐ Máximo | ⭐⭐⭐⭐⭐ Máximo | 🔴 Crítico |
+| **Estado** | Checkout Data / IP | ⭐⭐⭐⭐ Alto | ⭐⭐⭐⭐ Alto | ⭐⭐⭐⭐ Alto | 🟠 Alto |
+| **Região** | IP / Browser | ⭐⭐⭐ Médio | ⭐⭐⭐ Médio | ⭐⭐⭐ Médio | 🟡 Médio |
+| **País** | IP / Browser | ⭐⭐ Baixo | ⭐⭐ Baixo | ⭐⭐ Baixo | 🟢 Básico |
+
+**Regra**: Sempre capturar CIDADE e ESTADO do checkout (Hotmart, Kiwify, Eduzz). É 5x mais valioso que país/região.
+
+---
+
+## 🔐 ADVANCED MATCHING MÁXIMO (Server-Side)
+
+### Campo de PII e Prioridade de Hashing
+
+| Campo | Meta EMQ | Google EMQ | TikTok EMQ | Prioridade | Formato de Hash |
+|-------|----------|-------------|-------------|------------|------------------|
+| **Email** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 🔴 CRÍTICO | SHA256 (lowercase, trim) |
+| **Phone** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 🔴 CRÍTICO | SHA256 (apenas números, DDI) |
+| **Name** | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | 🟠 ALTO | SHA256 (lowercase, trim) |
+| **City** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 🔴 CRÍTICO | SHA256 (lowercase, sem acentos, sem espaços) |
+| **State** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 🔴 CRÍTICO | SHA256 (lowercase, sem acentos, sem espaços, 2 letras) |
+| **ZIP/CEP** | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | 🟠 ALTO | SHA256 (apenas números) |
+| **DOB** | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ | 🟡 MÉDIO | SHA256 (YYYY-MM-DD) |
+| **Gender** | ⭐⭐ | ⭐⭐ | ⭐⭐ | 🟢 BÁSICO | SHA256 (f/m/o) |
+
+**Regra de Ouro**: Email + Phone + City = 95% Match Quality. Sempre capturar os 3.
+
+---
+
+## 🎯 EVENTOS PRIORITADOS POR PLATAFORMA
+
+### Meta (Facebook + Instagram)
+
+| Evento | Prioridade | EMQ Alvo | Quando Disparar | Signal Strength |
+|--------|-----------|-----------|----------------|-----------------|
+| **Lead** | 🔴 CRÍTICO | 95%+ | Formulário preenchido + email válido | ⭐⭐⭐ 5.0 |
+| **Purchase** | 🔴 CRÍTICO | 95%+ | Compra confirmada (webhook) | ⭐⭐⭐ 5.0 |
+| **InitiateCheckout** | 🔴 CRÍTICO | 85%+ | Clique em checkout + fbp/fbc | ⭐⭐⭐ 4.0 |
+| **AddToCart** | 🟠 ALTO | 80%+ | Produto adicionado ao carrinho | ⭐⭐ 3.0 |
+| **ViewContent** | 🟠 ALTO | 70%+ | Scroll 50%+ OU tempo 30s+ | ⭐ 2.0 |
+| **Search** | 🟡 MÉDIO | 60%+ | Busca de produto | ⭐ 1.5 |
+| **Contact** | 🟡 MÉDIO | 75%+ | Clique em WhatsApp/Email | ⭐⭐ 2.5 |
+| **VideoPlay** | 🟡 MÉDIO | 65%+ | Vídeo iniciado (YouTube) | ⭐ 1.5 |
+| **VideoProgress50** | 🟠 ALTO | 80%+ | Vídeo 50% assistido | ⭐⭐ 3.0 |
+| **VideoComplete** | 🔴 CRÍTICO | 90%+ | Vídeo 100% assistido | ⭐⭐⭐ 5.0 |
+| **Scroll75** | 🟡 MÉDIO | 70%+ | Scroll 75% da página | ⭐ 2.0 |
+| **TimeOnPage60s** | 🟡 MÉDIO | 70%+ | 60s+ na página | ⭐ 2.0 |
+
+**Algoritmo de Priorização Meta:**
+```
+Priority = (Event Match Quality) × (Signal Strength) × (Conversion Probability)
+
+Lead (EMQ 95%, SS 5.0, CP 60%) = 95 × 5.0 × 0.6 = 285
+ViewContent (EMQ 70%, SS 2.0, CP 5%) = 70 × 2.0 × 0.05 = 7
+
+→ Lead é 40x mais valioso que ViewContent para Meta
+```
+
+---
+
+### Google (GA4 + Google Ads)
+
+| Evento | Prioridade | EMQ Alvo | Quando Disparar | Signal Strength |
+|--------|-----------|-----------|----------------|-----------------|
+| **generate_lead** | 🔴 CRÍTICO | 95%+ | Formulário preenchido + email válido | ⭐⭐⭐ 5.0 |
+| **purchase** | 🔴 CRÍTICO | 95%+ | Compra confirmada (webhook) | ⭐⭐⭐ 5.0 |
+| **begin_checkout** | 🔴 CRÍTICO | 85%+ | Clique em checkout + gclid | ⭐⭐⭐ 4.0 |
+| **add_to_cart** | 🟠 ALTO | 80%+ | Produto adicionado ao carrinho | ⭐⭐ 3.0 |
+| **view_item** | 🟠 ALTO | 70%+ | Produto visualizado | ⭐ 2.0 |
+| **search** | 🟡 MÉDIO | 60%+ | Busca de produto | ⭐ 1.5 |
+| **contact** | 🟡 MÉDIO | 75%+ | Clique em WhatsApp/Email | ⭐⭐ 2.5 |
+| **video_start** | 🟡 MÉDIO | 65%+ | Vídeo iniciado | ⭐ 1.5 |
+| **video_progress** | 🟠 ALTO | 80%+ | Vídeo 50%+ assistido | ⭐⭐ 3.0 |
+| **scroll_tracking** | 🟡 MÉDIO | 70%+ | Scroll 90% da página | ⭐ 2.0 |
+
+**Algoritmo de Priorização Google:**
+```
+Priority = (Event Match Quality) × (Signal Strength) × (Smart Bidding Value)
+
+generate_lead (EMQ 95%, SS 5.0, SBV $5.00) = 95 × 5.0 × 5 = 2375
+view_item (EMQ 70%, SS 2.0, SBV $0.50) = 70 × 2.0 × 0.5 = 70
+
+→ generate_lead é 34x mais valioso que view_item para Google
+```
+
+---
+
+### TikTok
+
+| Evento | Prioridade | EMQ Alvo | Quando Disparar | Signal Strength |
+|--------|-----------|-----------|----------------|-----------------|
+| **Lead** | 🔴 CRÍTICO | 95%+ | Formulário preenchido + email válido | ⭐⭐⭐ 5.0 |
+| **Purchase** | 🔴 CRÍTICO | 95%+ | Compra confirmada (webhook) | ⭐⭐⭐ 5.0 |
+| **InitiateCheckout** | 🔴 CRÍTICO | 85%+ | Clique em checkout + ttclid | ⭐⭐⭐ 4.0 |
+| **AddToCart** | 🟠 ALTO | 80%+ | Produto adicionado ao carrinho | ⭐⭐ 3.0 |
+| **ViewContent** | 🟠 ALTO | 70%+ | Produto visualizado | ⭐ 2.0 |
+| **Contact** | 🟡 MÉDIO | 75%+ | Clique em WhatsApp/Email | ⭐⭐ 2.5 |
+| **VideoPlay** | 🟡 MÉDIO | 65%+ | Vídeo iniciado | ⭐ 1.5 |
+| **VideoProgress50** | 🟠 ALTO | 80%+ | Vídeo 50% assistido | ⭐⭐ 3.0 |
+| **VideoComplete** | 🔴 CRÍTICO | 90%+ | Vídeo 100% assistido | ⭐⭐⭐ 5.0 |
+
+**Algoritmo de Priorização TikTok:**
+```
+Priority = (Event Match Quality) × (Signal Strength) × (Creative Relevance)
+
+Lead (EMQ 95%, SS 5.0, CR 0.8) = 95 × 5.0 × 0.8 = 380
+ViewContent (EMQ 70%, SS 2.0, CR 0.5) = 70 × 2.0 × 0.5 = 70
+
+→ Lead é 5.4x mais valioso que ViewContent para TikTok
+```
+
+---
+
+## 💎 SCORE DE ENGAJAMENTO (Engagement Scoring)
+
+### Fórmula de Cálculo de Signal Strength
+
+```javascript
+/**
+ * Calcula Score de Engajamento (0.0 - 5.0)
+ * Baseado em comportamento real, não em cliques
+ */
+function calculateEngagementScore(behavioralData) {
+  const {
+    timeOnPage,          // tempo em segundos
+    scrollDepth,          // scroll em % (0-100)
+    clicksCount,          // número de cliques
+    hoverTimeOnCTA,      // tempo em hover no CTA (segundos)
+    videoWatchTime,      // tempo de vídeo assistido (segundos)
+    formStart,           // iniciou formulário (bool)
+    scrollSpeed          // velocidade de scroll (pixels/segundo)
+  } = behavioralData;
+
+  // 1. Time on Page Score (0.0 - 2.0)
+  const timeScore = Math.min(timeOnPage / 60, 2.0); // Máximo 2.0 em 60s
+
+  // 2. Scroll Depth Score (0.0 - 1.5)
+  const scrollScore = Math.min(scrollDepth / 100, 1.5); // Máximo 1.5 em 100%
+
+  // 3. Click Engagement Score (0.0 - 0.5)
+  const clickScore = Math.min(clicksCount / 10, 0.5); // Máximo 0.5 em 10 cliques
+
+  // 4. CTA Hover Score (0.0 - 0.5)
+  const hoverScore = Math.min(hoverTimeOnCTA / 30, 0.5); // Máximo 0.5 em 30s
+
+  // 5. Video Engagement Score (0.0 - 1.0)
+  const videoScore = Math.min(videoWatchTime / 60, 1.0); // Máximo 1.0 em 60s
+
+  // 6. Form Engagement Score (0.0 - 2.0)
+  const formScore = formStart ? 2.0 : 0.0;
+
+  // 7. Scroll Quality Score (penalidade para scroll rápido)
+  const scrollQuality = Math.max(0, 1.0 - (scrollSpeed / 1000)); // Penalidade até -1.0
+
+  // Score total com qualidade de scroll como modificador
+  const rawScore = timeScore + scrollScore + clickScore + hoverScore + videoScore + formScore;
+  const finalScore = rawScore * scrollQuality;
+
+  // Limitar entre 0.0 e 5.0
+  return Math.max(0.0, Math.min(5.0, finalScore));
+}
+
+/**
+ * Classificação de Intenção
+ */
+function getIntentionLevel(engagementScore) {
+  if (engagementScore < 1.0) return 'curioso'; // ⭐ 1.0
+  if (engagementScore < 2.5) return 'interessado'; // ⭐⭐ 2.5
+  return 'comprador'; // ⭐⭐⭐ 5.0
+}
+```
+
+### Exemplos de Cálculo
+
+| Usuário | Tempo | Scroll | Cliques | Vídeo | Form | Hover CTA | Score | Intenção |
+|---------|-------|--------|---------|--------|------|-----------|-------|----------|
+| **Curioso Rápido** | 5s | 10% | 1 | 0s | ❌ | 0s | 0.1 | Curioso |
+| **Leitor Médio** | 30s | 50% | 2 | 0s | ❌ | 0s | 1.75 | Interessado |
+| **Investigador** | 60s | 75% | 5 | 0s | ❌ | 15s | 2.9 | Interessado |
+| **Comprador Potencial** | 120s | 90% | 8 | 0s | ✅ | 30s | 4.8 | Comprador |
+| **Vídeo Enthusiast** | 180s | 100% | 3 | 120s | ❌ | 5s | 4.2 | Comprador |
+
+---
+
+## 🛡️ ANTI-BLOQUEIO (AdBlock Evasion)
+
+### Estratégias de Detecção e Evasão
+
+#### 1. Detecção de AdBlock (Browser)
+
+```javascript
+/**
+ * Detecta se AdBlock está ativo
+ * Testa múltiplos métodos para alta precisão
+ */
+function detectAdBlock() {
+  const tests = [];
+
+  // Teste 1: Tentar carregar script de anúncio
+  const adScript = document.createElement('script');
+  adScript.src = 'https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js';
+  adScript.onerror = () => tests.push(true);
+  adScript.onload = () => tests.push(false);
+  document.body.appendChild(adScript);
+
+  // Teste 2: Verificar display de elementos de anúncio
+  const adElement = document.createElement('div');
+  adElement.className = 'adsbox ad-banner ad';
+  adElement.style.height = '1px';
+  document.body.appendChild(adElement);
+
+  setTimeout(() => {
+    if (adElement.offsetHeight === 0) {
+      tests.push(true);
+    } else {
+      tests.push(false);
+    }
+    document.body.removeChild(adElement);
+  }, 100);
+
+  // Teste 3: Verificar propriedades de window
+  if (window.google_ad_width || window.google_ad_height) {
+    tests.push(false);
+  } else {
+    tests.push(true);
+  }
+
+  // Se qualquer teste retornar true = AdBlock ativo
+  const isAdBlocked = tests.some(t => t === true);
+
+  // Reportar ao servidor
+  cdpTrack.track('AdBlockStatus', {
+    adblock_active: isAdBlocked,
+    detection_methods: tests.length,
+    timestamp: Date.now()
+  });
+
+  return isAdBlocked;
+}
+
+/**
+ * Rota de Fallback para AdBlock
+ * Se AdBlock detectado, usar server-side tracking via HTTP POST
+ */
+function handleAdBlockFallback(eventData) {
+  if (detectAdBlock()) {
+    // AdBlock ativo: enviar via servidor (não pode usar scripts de terceiros)
+    fetch('/api/tracking', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        ...eventData,
+        tracking_method: 'server-side-fallback',
+        adblock_detected: true
+      })
+    });
+  } else {
+    // AdBlock desativado: tracking normal (browser + server)
+    cdpTrack.track(eventData.event_name, eventData);
+  }
+}
+```
+
+#### 2. Domínio de Primeira Parte (First-Party Domain)
+
+```javascript
+/**
+ * Cookie First-Party de 365 dias
+ * Não bloqueado por navegadores modernos
+ */
+function getFirstPartyCookie(name) {
+  const cookieName = `_pb_${name}`;
+  let cookieValue = document.cookie.match(new RegExp(`${cookieName}=([^;]+)`))?.[1];
+
+  if (!cookieValue) {
+    // Gerar novo cookie
+    cookieValue = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+
+    // Cookie de 365 dias no domínio principal
+    document.cookie = `${cookieName}=${cookieValue}; max-age=${60*60*24*365}; path=/; SameSite=Lax`;
+  }
+
+  return cookieValue;
+}
+
+/**
+ * User ID Persistente (Cross-Session)
+ */
+function getPersistentUserId() {
+  return getFirstPartyCookie('uid');
+}
+
+/**
+ * Session ID (Cross-Tab)
+ */
+function getSessionId() {
+  const cookieName = '_cdp_sid';
+  let sessionId = sessionStorage.getItem(cookieName);
+
+  if (!sessionId) {
+    sessionId = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    sessionStorage.setItem(cookieName, sessionId);
+  }
+
+  return sessionId;
+}
+```
+
+#### 3. Protocolo Same-Domain (Endpoint no Próprio Domínio)
+
+```javascript
+/**
+ * Endpoint de Tracking no Mesmo Domínio
+ * URL: https://meusite.com/api/tracking (NÃO third-party)
+ */
+const TRACKING_ENDPOINT = '/api/tracking'; // Same-Domain Protocol
+
+/**
+ * Enviar evento via servidor (adblock-proof)
+ */
+function sendEventServerSide(eventData) {
+  fetch(TRACKING_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      ...eventData,
+      tracking_method: 'server-side',
+      timestamp: Date.now()
+    }),
+    keepalive: true // Garante envio mesmo se usuário fechar aba
+  });
+}
+
+/**
+ * Deduplicação entre Browser e Server
+ * Event ID gerado no browser, enviado no servidor
+ */
+function generateEventId() {
+  return `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+```
+
+---
+
+## 🚀 ESTRATÉGIA DE IMPLEMENTAÇÃO (Browser + Server)
+
+### O que roda no Browser
+
+```javascript
+// Browser Tracking - Coleta de eventos e comportamento
+const browserTracking = {
+  // 1. Capturar UTMs na chegada
+  captureUTMs: () => {
+    const utms = {
+      utm_source: new URLSearchParams(window.location.search).get('utm_source'),
+      utm_medium: new URLSearchParams(window.location.search).get('utm_medium'),
+      utm_campaign: new URLSearchParams(window.location.search).get('utm_campaign'),
+      utm_content: new URLSearchParams(window.location.search).get('utm_content'),
+      utm_term: new URLSearchParams(window.location.search).get('utm_term')
+    };
+
+    // Salvar no localStorage para uso posterior
+    localStorage.setItem('cdp_utms', JSON.stringify(utms));
+
+    return utms;
+  },
+
+  // 2. Capturar Click IDs das plataformas
+  captureClickIDs: () => {
+    const params = new URLSearchParams(window.location.search);
+
+    return {
+      fbp: document.cookie.match(/_fbp=([^;]+)/)?.[1],
+      fbc: document.cookie.match(/_fbc=([^;]+)/)?.[1],
+      gclid: params.get('gclid'),
+      gbraid: params.get('gbraid'),
+      wbraid: params.get('wbraid'),
+      ttclid: params.get('ttclid'),
+      rclid: params.get('rclid')
+    };
+  },
+
+  // 3. Capturar eventos de micro-engagement
+  trackMicroEngagement: (eventData) => {
+    const enrichedData = {
+      ...eventData,
+      ...browserTracking.captureUTMs(),
+      ...browserTracking.captureClickIDs(),
+      user_id: getPersistentUserId(),
+      session_id: getSessionId(),
+      event_id: generateEventId(),
+      timestamp: Date.now(),
+      page_url: window.location.href,
+      referrer: document.referrer,
+      user_agent: navigator.userAgent
+    };
+
+    // Enviar para servidor (same-domain, adblock-proof)
+    sendEventServerSide(enrichedData);
+  }
+};
+```
+
+### O que roda no Servidor (Cloudflare Worker)
+
+```javascript
+// Server Tracking - Processamento e despacho para plataformas
+const serverTracking = {
+  // 1. Receber evento do browser
+  handleEvent: async (eventData, env, ctx) => {
+    const {
+      event_id,
+      event_name,
+      user_id,
+      session_id,
+      utms,
+      clickIDs,
+      page_url,
+      user_agent,
+      ...customData
+    } = eventData;
+
+    // 2. Capturar IP e Geolocalização (Cloudflare)
+    const clientIP = request.headers.get('CF-Connecting-IP');
+    const geo = request.cf || {};
+
+    // 3. Recuperar PII do D1 (Lead Lock)
+    const pii = await getPIIFromD1(env.DB, user_id);
+
+    // 4. Calcular Engagement Score
+    const engagementScore = calculateEngagementScore(customData);
+    const intentionLevel = getIntentionLevel(engagementScore);
+
+    // 5. Hashing de PII (SHA256 WebCrypto)
+    const hashedPII = {
+      email: await sha256(pii.email),
+      phone: await sha256(pii.phone),
+      name: await sha256(pii.name),
+      city: await sha256(geo.city),
+      state: await sha256(geo.region),
+      zip: await sha256(pii.zip)
+    };
+
+    // 6. Despachar para plataformas em paralelo (ctx.waitUntil)
+    ctx.waitUntil(Promise.allSettled([
+      dispatchToMeta(event_name, hashedPII, clickIDs, clientIP, user_agent, customData, env),
+      dispatchToGoogle(event_name, hashedPII, clickIDs, clientIP, user_agent, customData, env),
+      dispatchToTikTok(event_name, hashedPII, clickIDs, clientIP, user_agent, customData, env)
+    ]));
+
+    // 7. Persistir no D1 (Identity Graph)
+    await persistToD1(env.DB, {
+      user_id,
+      session_id,
+      event_id,
+      event_name,
+      utms,
+      clickIDs,
+      engagement_score: engagementScore,
+      intention_level: intentionLevel,
+      geo: {
+        ip: clientIP,
+        city: geo.city,
+        state: geo.region,
+        country: geo.country
+      },
+      pii: hashedPII,
+      timestamp: Date.now()
+    });
+
+    return { success: true, score: engagementScore };
+  }
+};
+```
+
+---
+
+## 📋 CHECKLIST DE IMPLEMENTAÇÃO (Browser + Server)
+
+### Browser Tracking (O que capturar no navegador)
+
+- [x] UTMs na chegada (utm_source, utm_medium, utm_campaign, utm_content, utm_term)
+- [x] Click IDs das plataformas (fbp, fbc, gclid, ttclid, etc.)
+- [x] User ID persistente (first-party cookie, 365 dias)
+- [x] Session ID (cross-tab)
+- [x] Scroll tracking (25%, 50%, 75%, 100%)
+- [x] Time on page tracking (curioso < 10s, interessado 10-60s, comprador > 60s)
+- [x] Click heatmap (posição X/Y, categoria do clique)
+- [x] Video engagement (play, progress 25/50/75/100%, pause, resume, seek)
+- [x] Rapid clicks (3+ cliques em 1 segundo = usuário nervoso)
+- [x] CTA hover time (tempo em hover no botão de compra)
+- [x] Form start detection (iniciou preenchimento do formulário)
+- [x] AdBlock detection (testar múltiplos métodos)
+
+### Server Tracking (O que processar no Worker)
+
+- [x] Receber eventos do browser (POST /api/tracking)
+- [x] Capturar IP e geolocalização (Cloudflare headers)
+- [x] Recuperar PII do D1 (Lead Lock)
+- [x] Calcular Engagement Score (0.0 - 5.0)
+- [x] Classificar intenção (curioso, interessado, comprador)
+- [x] Hashing de PII (SHA256: email, phone, name, city, state, zip)
+- [x] Despachar para Meta CAPI v22.0 (event_id, user_data, custom_data)
+- [x] Despachar para Google GA4 MP (event_name, user_properties)
+- [x] Despachar para TikTok Events API v1.3 (event, context, properties)
+- [x] Persistir no D1 (Identity Graph + events_log)
+- [x] Fila de retry (Cloudflare Queue, 3-tier: 5min, 15min, 45min)
+- [x] Log de sucesso/falha (status: success, retrying, failed)
+
+---
+
+## 🎯 RESULTADO FINAL
+
+O CDP Edge com **Premium Tracking Intelligence** entregará:
+
+1. **Event Match Quality de 95%+** (via Advanced Matching Máximo: email, phone, city, state)
+2. **Signal Strength de 5.0** (via Behavioral Intelligence: scroll, time, vídeo, formulário)
+3. **Redução de 30-50% no CPL** (via eventos prioritados de alta intenção)
+4. **100% AdBlock-Proof** (via same-domain protocol + server-side tracking)
+5. **Cross-Device Attribution** (via Identity Graph + fbp/fbc match)
+6. **Real-Time Engagement Scoring** (via score de 0.0 - 5.0 calculado no servidor)
+
+---
+
+## 📊 MÉTRICAS DE SUCESSO
+
+| Métrica | Meta | Google | TikTok | Status |
+|---------|------|--------|--------|--------|
+| Event Match Quality (EMQ) | 95%+ | 95%+ | 95%+ | 🔴 Crítico |
+| Signal Strength Score | 4.0+ | 4.0+ | 4.0+ | 🔴 Crítico |
+| CPL (Cost Per Lead) | -30% | -30% | -30% | 🟠 Objetivo |
+| CTR (Click-Through Rate) | +20% | +20% | +20% | 🟡 Bônus |
+| Conversion Rate | +25% | +25% | +25% | 🟡 Bônus |
+| AdBlock Detection | 100% | 100% | 100% | 🟢 Básico |
+| Cross-Device Match | 90%+ | 90%+ | 90%+ | 🟠 Alto |
+
+---
+
+*Premium Tracking Intelligence Agent v1.0.0 - CDP Edge Quantum Tier*