cdp-edge 2.0.0 → 2.0.2

package/extracted-skill/tracking-events-generator/agents/security-enterprise-agent.md

@@ -402,7 +402,7 @@ export async function checkIPBlocking(request, env) {
   const ip = request.headers.get('CF-Connecting-IP') || 'unknown';
 
   // 1. Verificar whitelist (primeiro - bypass rate limiting)
-  const isWhitelisted = await checkIPWhitelist(ip);
+  const isWhitelisted = await checkIPWhitelist(ip, env);
   if (isWhitelisted) {
     return {
       allowed: true,
@@ -412,7 +412,7 @@ export async function checkIPBlocking(request, env) {
   }
 
   // 2. Verificar blacklist manual
-  const isManuallyBlocked = await checkIPBlacklist(ip);
+  const isManuallyBlocked = await checkIPBlacklist(ip, env);
   if (isManuallyBlocked) {
     await logSecurityEvent({
       type: 'IP_BLACKLISTED',
@@ -430,7 +430,7 @@ export async function checkIPBlocking(request, env) {
   }
 
   // 3. Verificar geoblocking
-  const isGeoBlocked = await checkGeoBlocking(request);
+  const isGeoBlocked = await checkGeoBlocking(request, env);
   if (isGeoBlocked) {
     await logSecurityEvent({
       type: 'IP_GEO_BLOCKED',
@@ -447,7 +447,7 @@ export async function checkIPBlocking(request, env) {
   }
 
   // 4. Verificar bloqueio automático (comportamento malicioso)
-  const isAutoBlocked = await checkAutoIPBlocking(ip);
+  const isAutoBlocked = await checkAutoIPBlocking(ip, env);
   if (isAutoBlocked) {
     await logSecurityEvent({
       type: 'IP_AUTO_BLOCKED',
@@ -470,13 +470,13 @@ export async function checkIPBlocking(request, env) {
 }
 
 // Verificar se IP está na whitelist
-async function checkIPWhitelist(ip) {
+async function checkIPWhitelist(ip, env) {
   if (!IP_BLOCKING_CONFIG.whitelist.enabled) {
     return false;
   }
 
   // 1. Verificar whitelist manual (IP exato)
-  const manualWhitelist = await DB.prepare(`
+  const manualWhitelist = await env.DB.prepare(`
     SELECT ip, cidr_range
     FROM ip_whitelist
     WHERE ip = ?
@@ -497,8 +497,8 @@ async function checkIPWhitelist(ip) {
 }
 
 // Verificar se IP está na blacklist
-async function checkIPBlacklist(ip) {
-  const blocked = await DB.prepare(`
+async function checkIPBlacklist(ip, env) {
+  const blocked = await env.DB.prepare(`
     SELECT block_reason, blocked_at, unblocked_at, blocking_type, violation_count
     FROM ip_blacklist
     WHERE ip = ? AND unblocked_at IS NULL
@@ -508,7 +508,7 @@ async function checkIPBlacklist(ip) {
 }
 
 // Verificar geoblocking
-async function checkGeoBlocking(request) {
+async function checkGeoBlocking(request, env) {
   if (!IP_BLOCKING_CONFIG.blacklist.geo_blocking.enabled) {
     return null;
   }
@@ -527,7 +527,7 @@ async function checkGeoBlocking(request) {
 }
 
 // Verificar bloqueio automático por comportamento
-async function checkAutoIPBlocking(ip) {
+async function checkAutoIPBlocking(ip, env) {
   if (!IP_BLOCKING_CONFIG.blacklist.automatic.enabled) {
     return null;
   }
@@ -535,7 +535,7 @@ async function checkAutoIPBlocking(ip) {
   const config = IP_BLOCKING_CONFIG.blacklist.automatic;
 
   // 1. Verificar falhas por hora
-  const failuresPerHour = await DB.prepare(`
+  const failuresPerHour = await env.DB.prepare(`
     SELECT COUNT(*) as failures
     FROM ip_violations
     WHERE ip = ?
@@ -544,7 +544,7 @@ async function checkAutoIPBlocking(ip) {
 
   if (failuresPerHour.failures >= config.threshold_failures_per_hour) {
     // Bloquear IP automaticamente
-    await blockIPAutomatically(ip, 'EXCEEDED_FAILURES_PER_HOUR', failuresPerHour.failures);
+    await blockIPAutomatically(ip, 'EXCEEDED_FAILURES_PER_HOUR', failuresPerHour.failures, env);
     return {
       blocked: true,
       reason: 'EXCEEDED_FAILURES_PER_HOUR',
@@ -554,7 +554,7 @@ async function checkAutoIPBlocking(ip) {
   }
 
   // 2. Verificar falhas por dia
-  const failuresPerDay = await DB.prepare(`
+  const failuresPerDay = await env.DB.prepare(`
     SELECT COUNT(*) as failures
     FROM ip_violations
     WHERE ip = ?
@@ -562,7 +562,7 @@ async function checkAutoIPBlocking(ip) {
   `).bind(ip).get();
 
   if (failuresPerDay.failures >= config.threshold_failures_per_day) {
-    await blockIPAutomatically(ip, 'EXCEEDED_FAILURES_PER_DAY', failuresPerDay.failures);
+    await blockIPAutomatically(ip, 'EXCEEDED_FAILURES_PER_DAY', failuresPerDay.failures, env);
     return {
       blocked: true,
       reason: 'EXCEEDED_FAILURES_PER_DAY',
@@ -572,7 +572,7 @@ async function checkAutoIPBlocking(ip) {
   }
 
   // 3. Verificar erros 429 por hora
-  const rateLimitErrorsPerHour = await DB.prepare(`
+  const rateLimitErrorsPerHour = await env.DB.prepare(`
     SELECT COUNT(*) as errors
     FROM ip_violations
     WHERE ip = ?
@@ -581,7 +581,7 @@ async function checkAutoIPBlocking(ip) {
   `).bind(ip).get();
 
   if (rateLimitErrorsPerHour.errors >= config.threshold_429_per_hour) {
-    await blockIPAutomatically(ip, 'EXCEEDED_RATE_LIMITS_PER_HOUR', rateLimitErrorsPerHour.errors);
+    await blockIPAutomatically(ip, 'EXCEEDED_RATE_LIMITS_PER_HOUR', rateLimitErrorsPerHour.errors, env);
     return {
       blocked: true,
       reason: 'EXCEEDED_RATE_LIMITS_PER_HOUR',
@@ -594,10 +594,10 @@ async function checkAutoIPBlocking(ip) {
 }
 
 // Bloquear IP automaticamente
-async function blockIPAutomatically(ip, reason, count) {
+async function blockIPAutomatically(ip, reason, count, env) {
   const now = new Date().toISOString();
 
-  await DB.prepare(`
+  await env.DB.prepare(`
     INSERT OR REPLACE INTO ip_blacklist
     (ip, block_reason, blocked_at, blocking_type, violation_count, last_violation_type, last_violation_at)
     VALUES (?, ?, ?, ?, ?, ?, ?)
@@ -925,7 +925,106 @@ export function sanitizePayload(eventData, eventName) {
 }
 ```
 
-### 3.3 Middleware de Validação e Sanitização
+### 3.3 CSRF Protection (Anti-Cross-Site Request Forgery)
+
+CSRF é relevante nos **endpoints de webhook** (Hotmart, Kiwify, Ticto) onde um atacante pode forjar requisições. A proteção é HMAC-SHA256 por assinatura — cada plataforma assina o payload com um secret compartilhado.
+
+```javascript
+/**
+ * Verificação CSRF via HMAC-SHA256 para webhooks de plataformas de pagamento.
+ * Cada plataforma tem seu próprio header e algoritmo.
+ *
+ * @param {Request} request
+ * @param {Object} env
+ * @param {string} gateway - 'hotmart' | 'kiwify' | 'ticto' | 'stripe'
+ * @returns {Promise<boolean>} true se assinatura válida
+ */
+export async function validateWebhookSignature(request, env, gateway) {
+  const body = await request.text(); // Ler como texto para HMAC exato
+
+  switch (gateway) {
+    case 'hotmart': {
+      // Hotmart: header X-Hotmart-Hottok (token fixo, não HMAC)
+      const token = request.headers.get('X-Hotmart-Hottok');
+      return token === env.WEBHOOK_SECRET_HOTMART;
+    }
+
+    case 'kiwify': {
+      // Kiwify: query param ?signature=HMAC_SHA256(body, secret)
+      const url = new URL(request.url);
+      const receivedSig = url.searchParams.get('signature') || '';
+      const expectedSig = await hmacSHA256(body, env.WEBHOOK_SECRET_KIWIFY);
+      return timingSafeEqual(receivedSig, expectedSig);
+    }
+
+    case 'ticto': {
+      // Ticto: header X-Ticto-Signature = HMAC_SHA256(body, secret)
+      const receivedSig = request.headers.get('X-Ticto-Signature') || '';
+      const expectedSig = await hmacSHA256(body, env.WEBHOOK_SECRET_TICTO);
+      return timingSafeEqual(receivedSig, expectedSig);
+    }
+
+    case 'stripe': {
+      // Stripe: header Stripe-Signature = t={ts},v1={HMAC}
+      const sigHeader = request.headers.get('Stripe-Signature') || '';
+      const parts = Object.fromEntries(sigHeader.split(',').map(p => p.split('=')));
+      const signedPayload = `${parts.t}.${body}`;
+      const expectedSig = await hmacSHA256(signedPayload, env.STRIPE_WEBHOOK_SECRET);
+      return timingSafeEqual(parts.v1, expectedSig);
+    }
+
+    default:
+      return false; // Gateway desconhecido = rejeitar
+  }
+}
+
+// HMAC-SHA256 usando WebCrypto (disponível em Cloudflare Workers)
+async function hmacSHA256(message, secret) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    'raw', encoder.encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false, ['sign']
+  );
+  const sig = await crypto.subtle.sign('HMAC', key, encoder.encode(message));
+  return Array.from(new Uint8Array(sig)).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+// Comparação em tempo constante — previne timing attacks
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+/**
+ * Uso no handler de webhook:
+ *
+ * const isValid = await validateWebhookSignature(request, env, 'hotmart');
+ * if (!isValid) return new Response('Unauthorized', { status: 401 });
+ *
+ * REGRA: Validar assinatura ANTES de parsear o body JSON.
+ * Re-clonar o request se precisar ler o body depois:
+ *   const clonedRequest = request.clone();
+ *   const valid = await validateWebhookSignature(clonedRequest, env, gateway);
+ *   const body = await request.json(); // original ainda disponível
+ */
+```
+
+### Checklist CSRF
+
+- [ ] HMAC validado para Hotmart, Kiwify, Ticto antes de processar
+- [ ] Rejeição 401 imediata se assinatura inválida
+- [ ] Uso de `timingSafeEqual` para prevenir timing attacks
+- [ ] Body lido como texto para HMAC (não como JSON — evita parsing antes da validação)
+- [ ] Secrets via `wrangler secret put WEBHOOK_SECRET_HOTMART` etc.
+
+---
+
+### 3.4 Middleware de Validação e Sanitização
 
 ```javascript
 // Middleware de segurança completo
@@ -1401,7 +1500,7 @@ const SEVERITY_LEVELS = {
 
 ```javascript
 // Log de evento de segurança
-export async function logSecurityEvent(eventData) {
+export async function logSecurityEvent(eventData, env) {
   const {
     type,
     severity,
@@ -1419,7 +1518,7 @@ export async function logSecurityEvent(eventData) {
 
   const timestamp = new Date().toISOString();
 
-  await DB.prepare(`
+  await env.DB.prepare(`
     INSERT INTO audit_logs
     (timestamp, ip, user_id, session_id, user_agent, event_name, event_id,
      log_type, severity, action, outcome, details, blocked)
@@ -1453,7 +1552,7 @@ export async function logSecurityEvent(eventData) {
 }
 
 // Query de audit logs
-export async function queryAuditLogs(filters = {}) {
+export async function queryAuditLogs(filters = {}, env) {
   const {
     ip,
     user_id,
@@ -1509,7 +1608,7 @@ export async function queryAuditLogs(filters = {}) {
 
   query += ' ORDER BY timestamp DESC LIMIT ?';
 
-  const results = await DB.prepare(query).bind(...params).all();
+  const results = await env.DB.prepare(query).bind(...params).all();
 
   return results;
 }
@@ -1539,7 +1638,7 @@ export async function getRateLimitStatus(request, env) {
         refill_rate: rateLimiters.event.get('global').refillRate
       }
     },
-    recent_violations: await DB.prepare(`
+    recent_violations: await env.DB.prepare(`
       SELECT
         log_type,
         severity,
@@ -1566,9 +1665,9 @@ export async function getIPStatus(request, env) {
   const ip = request.headers.get('CF-Connecting-IP') || 'unknown';
 
   // Verificar status do IP
-  const blacklist = await checkIPBlacklist(ip);
-  const whitelist = await checkIPWhitelist(ip);
-  const geoBlock = await checkGeoBlocking(request);
+  const blacklist = await checkIPBlacklist(ip, env);
+  const whitelist = await checkIPWhitelist(ip, env);
+  const geoBlock = await checkGeoBlocking(request, env);
 
   const status = {
     ip,
@@ -1577,7 +1676,7 @@ export async function getIPStatus(request, env) {
     blacklist_reason: blacklist ? blacklist.block_reason : null,
     is_geo_blocked: !!geoBlock,
     geo_details: geoBlock || null,
-    recent_violations: await DB.prepare(`
+    recent_violations: await env.DB.prepare(`
       SELECT
         COUNT(*) as violations,
         MAX(violation_count) as max_violation_count
@@ -1699,6 +1798,16 @@ export const SEVERITY_LEVELS = { ... };
 - [ ] CIDR ranges implementados
 - [ ] Auto-unblock implementado
 
+### CSRF Protection (Webhooks)
+
+- [ ] HMAC-SHA256 validado para Hotmart
+- [ ] HMAC-SHA256 validado para Kiwify
+- [ ] HMAC-SHA256 validado para Ticto
+- [ ] HMAC-SHA256 validado para Stripe
+- [ ] `timingSafeEqual` implementado (sem timing attacks)
+- [ ] Body lido como text antes do JSON.parse para validação HMAC
+- [ ] Secrets via `wrangler secret put` (nunca hardcode)
+
 ### Input Validation
 
 - [ ] Joi schemas criados (Lead, Purchase, Contact)

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

@@ -89,11 +89,10 @@ UMBRELLA_DOMAIN = "dominio.com"
 # 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)
+# WHATSAPP_ACCESS_TOKEN       ← WhatsApp Cloud API — token de acesso permanente
+# WHATSAPP_PHONE_NUMBER_ID    ← WhatsApp Cloud API — Phone Number ID (ex: 123456789012345)
+# WA_NOTIFY_NUMBER            ← Número do dono para receber notificações (ex: 5511999998888)
+# WA_WEBHOOK_VERIFY_TOKEN     ← Token de verificação do webhook CTWA (gerado via 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
@@ -1050,7 +1049,7 @@ Timestamp: ${new Date().toISOString()}
   `.trim();
 
   // Verificar se há token do WhatsApp configurado
-  const waPhoneId = env.WA_PHONE_ID;
+  const waPhoneId = env.WHATSAPP_PHONE_NUMBER_ID;
   const adminNumber = env.ADMIN_PHONE_NUMBER;
 
   if (waPhoneId && adminNumber) {
@@ -1058,7 +1057,7 @@ Timestamp: ${new Date().toISOString()}
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'Authorization': `Bearer ${env.WA_ACCESS_TOKEN}`
+        'Authorization': `Bearer ${env.WHATSAPP_ACCESS_TOKEN}`
       },
       body: JSON.stringify({
         messaging_product: 'whatsapp',
@@ -1145,7 +1144,7 @@ export async function queue(batch, env) {
 - 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`
+- Secrets opcionais: `RESEND_API_KEY`, `WHATSAPP_ACCESS_TOKEN`, `WHATSAPP_PHONE_NUMBER_ID`
 
 ## RESPONSABILIDADE
 

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

@@ -73,6 +73,69 @@ Gere payloads para o Worker seguir a API oficial:
 
 ---
 
+## ⏱️ RATE LIMITS — TikTok Events API v1.3
+
+Conforme `contracts/api-versions.json`, a TikTok Events API tem limites estritos:
+
+| Limite | Valor | Ação se excedido |
+|--------|-------|-----------------|
+| Requisições por minuto (por pixel) | 10 req/min | Implementar throttling |
+| Eventos por batch | 5 events/batch | Agrupar eventos em batches |
+| Retries máximos | 3 tentativas | Backoff exponencial |
+
+### Implementação de Throttling no Worker
+
+```javascript
+// Rate limit KV key: 'tiktok_rate_{pixel_id}_{minute}'
+async function dispatchTikTokWithRateLimit(env, events, pixelId, accessToken) {
+  const now = new Date();
+  const minuteKey = `tiktok_rate_${pixelId}_${now.getUTCFullYear()}${now.getUTCMonth()}${now.getUTCDate()}${now.getUTCHours()}${now.getUTCMinutes()}`;
+
+  // Verificar rate limit no KV
+  const currentCount = parseInt(await env.GEO_CACHE.get(minuteKey) || '0');
+
+  if (currentCount >= 10) {
+    // Rate limit atingido — encaminhar para RETRY_QUEUE
+    await env.RETRY_QUEUE.send({ platform: 'tiktok', events, pixelId });
+    return { queued: true, reason: 'rate_limit' };
+  }
+
+  // Agrupar eventos em batches de 5
+  const batches = [];
+  for (let i = 0; i < events.length; i += 5) {
+    batches.push(events.slice(i, i + 5));
+  }
+
+  const results = [];
+  for (const batch of batches) {
+    const result = await fetch('https://business-api.tiktok.com/open_api/v1.3/event/track/', {
+      method: 'POST',
+      headers: {
+        'Content-Type':  'application/json',
+        'Access-Token':  accessToken
+      },
+      body: JSON.stringify({
+        pixel_code: pixelId,
+        event_source: 'web',
+        event_source_id: pixelId,
+        data: batch
+      })
+    });
+
+    // Incrementar contador no KV (TTL de 60s = 1 minuto)
+    await env.GEO_CACHE.put(minuteKey, String(currentCount + 1), { expirationTtl: 60 });
+
+    results.push(result);
+  }
+
+  return { sent: results.length, batches: batches.length };
+}
+```
+
+> **Regra:** Se `HTTP 429` for recebido da TikTok API, encaminhar eventos para `RETRY_QUEUE` com backoff de 1min, 2min, 4min (máximo 3 tentativas).
+
+---
+
 ## INPUTS RECEBIDOS
 
 - JSON do Page Analyzer Agent (eventos mapeados, seletores, tipo de página)

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

@@ -59,19 +59,30 @@ function validateEventCoverage(pageAnalysis, agentOutputs) {
     });
   });
 
-  // Encontrar eventos faltantes (no plano mas implementados)
-  const missingEvents = [];
+  // Encontrar eventos do Page Analyzer NÃO implementados por nenhum agente
+  const unimplementedEvents = [];
+  pageEvents.forEach(eventKey => {
+    if (!agentEvents.has(eventKey)) {
+      unimplementedEvents.push(eventKey);
+    }
+  });
+
+  // Encontrar eventos implementados pelos agentes mas SEM correspondência no Page Analyzer
+  const orphanEvents = [];
   agentEvents.forEach(eventKey => {
     if (!pageEvents.has(eventKey)) {
-      missingEvents.push(eventKey);
+      orphanEvents.push(eventKey);
     }
   });
 
   return {
     total_page_events: pageEvents.size,
     total_implemented_events: agentEvents.size,
-    missing_events,
-    coverage_percentage: Math.round((agentEvents.size / pageEvents.size) * 100)
+    unimplemented_events: unimplementedEvents,  // ← Eventos do plano sem código
+    orphan_events: orphanEvents,                // ← Código sem evento no plano
+    coverage_percentage: Math.round(
+      ((pageEvents.size - unimplementedEvents.length) / Math.max(pageEvents.size, 1)) * 100
+    )
   };
 }
 ```
@@ -187,6 +198,90 @@ async function validateApiVersions(trackingPlan) {
 }
 ```
 
+### 1.5 Validação Cruzada Completa (runFullValidation)
+
+```javascript
+/**
+ * Ponto de entrada principal — executa TODAS as validações em sequência
+ * e retorna um relatório consolidado com status PASS | WARN | BLOCK
+ *
+ * @param {Object} pageAnalysis - Output do Page Analyzer Agent
+ * @param {Object} agentOutputs - Código gerado por todos os agentes
+ * @param {Object} apiVersions  - Conteúdo de contracts/api-versions.json
+ * @returns {Object} Relatório consolidado de validação
+ */
+async function runFullValidation(pageAnalysis, agentOutputs, apiVersions) {
+  const report = {
+    status: 'PASS',   // PASS | WARN | BLOCK
+    timestamp: new Date().toISOString(),
+    checks: {}
+  };
+
+  // CHECK 1: Cobertura de eventos
+  const coverage = validateEventCoverage(pageAnalysis, agentOutputs);
+  report.checks.event_coverage = coverage;
+  if (coverage.coverage_percentage < 100) {
+    report.status = coverage.coverage_percentage < 80 ? 'BLOCK' : 'WARN';
+  }
+
+  // CHECK 2: Parâmetros de conversão
+  const allEvents = Object.values(agentOutputs).flatMap(o => o.events || []);
+  const paramIssues = validateConversionParameters(allEvents, apiVersions);
+  report.checks.conversion_params = paramIssues;
+  if (paramIssues.filter(i => i.severity === 'HIGH').length > 0) {
+    report.status = 'BLOCK';
+  }
+
+  // CHECK 3: Seletores existentes no código
+  const missingSelectors = validateSelectorsExist({}, pageAnalysis);
+  report.checks.selectors = { missing: missingSelectors };
+  if (missingSelectors.length > 0) {
+    if (report.status === 'PASS') report.status = 'WARN';
+  }
+
+  // CHECK 4: Versões de API consistentes com api-versions.json
+  const trackingPlan = { events: {} };
+  Object.entries(agentOutputs).forEach(([agent, output]) => {
+    if (output.events) trackingPlan.events[agent] = output.events;
+  });
+  await validateApiVersions(trackingPlan);
+  const apiIssues = Object.values(trackingPlan.events)
+    .flatMap(events => events.filter(e => e.api_version_issue || e.api_deprecated));
+  report.checks.api_versions = apiIssues;
+  if (apiIssues.some(e => e.api_deprecated)) {
+    report.status = 'BLOCK';  // API depreciada = bloquear deploy
+  }
+
+  // CHECK 5: Regras de ouro — deduplicação event_id
+  const missingEventId = allEvents.filter(e => !e.event_id && !e.params?.event_id);
+  report.checks.deduplication = {
+    events_missing_event_id: missingEventId.map(e => `${e.platform}:${e.name}`)
+  };
+  if (missingEventId.length > 0) report.status = 'WARN';
+
+  // CHECK 6: SHA-256 em campos PII
+  const piiFields = ['em', 'ph', 'fn', 'ln'];
+  const unhashed = allEvents.filter(e =>
+    piiFields.some(field => e.user_data?.[field] && !e.user_data[field].match(/^[a-f0-9]{64}$/))
+  );
+  report.checks.pii_hashing = {
+    events_with_unhashed_pii: unhashed.map(e => `${e.platform}:${e.name}`)
+  };
+  if (unhashed.length > 0) {
+    report.status = 'BLOCK';  // PII sem hash = bloquear imediatamente
+  }
+
+  // Determinar mensagem de status
+  report.summary = {
+    PASS:  '✅ Tracking Plan validado — pode fazer deploy',
+    WARN:  '⚠️ Tracking Plan com alertas — revisar antes do deploy',
+    BLOCK: '❌ BLOQUEADO — corrigir itens críticos antes do deploy'
+  }[report.status];
+
+  return report;
+}
+```
+
 ---
 
 ## PASSO 2 — GERAR O TRACKING PLAN COM VALIDAÇÃO

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

@@ -12,6 +12,48 @@ Você é o especialista em Webhooks do CDP Edge. Sua missão é capturar vendas
 
 ---
 
+## 🔐 NORMALIZAÇÃO E HASHING DE PII (OBRIGATÓRIO)
+
+Antes de qualquer dispatch para CAPI, normalizar e hashear PII extraída do webhook:
+
+```javascript
+// Hashing SHA-256 para PII — usar WebCrypto (disponível em Cloudflare Workers)
+async function hashPII(value) {
+  if (!value) return null;
+  const normalized = value.toString().toLowerCase().trim();
+  const encoder = new TextEncoder();
+  const data = encoder.encode(normalized);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+  return Array.from(new Uint8Array(hashBuffer)).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+// Normalização E.164 para telefone (Brasil)
+function normalizePhone(phone) {
+  if (!phone) return null;
+  const digits = phone.replace(/\D/g, '');
+  // Adicionar +55 se não tiver código de país
+  if (digits.length === 10 || digits.length === 11) return `+55${digits}`;
+  if (digits.startsWith('55') && (digits.length === 12 || digits.length === 13)) return `+${digits}`;
+  return `+${digits}`;
+}
+
+// Exemplo de uso no handler de webhook:
+async function hashWebhookUserData(webhookPayload) {
+  const email = webhookPayload.buyer?.email || webhookPayload.email;
+  const phone = webhookPayload.buyer?.phone || webhookPayload.phone;
+  return {
+    em: email ? await hashPII(email) : null,             // SHA-256 lowercase+trim
+    ph: phone ? await hashPII(normalizePhone(phone)) : null, // SHA-256 após E.164
+    fn: webhookPayload.buyer?.first_name ? await hashPII(webhookPayload.buyer.first_name) : null,
+    ln: webhookPayload.buyer?.last_name  ? await hashPII(webhookPayload.buyer.last_name)  : null,
+  };
+}
+```
+
+> **Regra:** NUNCA enviar email ou telefone em plaintext para Meta CAPI, GA4 MP ou TikTok Events API. Sempre normalizar → hashear → enviar.
+
+---
+
 ## 🏗️ PADRÕES TÉCNICOS (Quantum Tier)
 
 1.  **D1 Identity Cross-Check**: Utilize o e-mail ou telefone do webhook para buscar no banco **D1** os identificadores originais (`fbp`, `fbc`, `ttp`). Isso garante a precisão da atribuição.
@@ -29,6 +71,64 @@ Você é o especialista em Webhooks do CDP Edge. Sua missão é capturar vendas
 
 ---
 
+## 🔗 INTEGRAÇÃO COM OUTROS AGENTES (Fluxo Pós-Compra)
+
+Após processar um webhook de compra com sucesso, o Webhook Agent DEVE disparar:
+
+```
+Webhook (Hotmart/Kiwify/Ticto/Stripe)
+    │
+    ├─► [1] Validar HMAC → rejeitar 401 se inválido
+    ├─► [2] Dedup D1 por transaction_id
+    ├─► [3] Cross-check D1 por email → fbp/fbc/ttp/gclid
+    ├─► [4] Hashear PII (SHA-256) — ver seção acima
+    │
+    ├─► [5] CAPI Dispatch (ctx.waitUntil) — paralelo:
+    │         → Meta CAPI v22.0 (Purchase)
+    │         → GA4 MP (purchase)
+    │         → TikTok Events API v1.3 (CompletePayment)
+    │
+    ├─► [6] Email Agent (ctx.waitUntil) — enviar confirmação de compra:
+    │         → Chamar sendEmail(env, 'purchase_confirmation', { email, nome, produto, valor })
+    │         → Ver email-agent.md para implementação completa
+    │
+    └─► [7] CRM Sync (ctx.waitUntil) — sincronizar comprador:
+              → Chamar syncToCRM(env, 'purchase', { email, nome, produto, valor, order_id })
+              → Ver crm-integration-agent.md para implementação completa
+```
+
+### Código de Integração (webhook handler)
+
+```javascript
+// No handler de webhook, após validação e dedup:
+ctx.waitUntil(Promise.allSettled([
+  // [5] CAPI dispatch
+  dispatchToCAPI(env, hashedUserData, purchaseData),
+
+  // [6] Email Agent — confirmação de compra
+  sendEmail(env, 'purchase_confirmation', {
+    to:      buyerEmail,
+    name:    buyerName,
+    product: productName,
+    value:   purchaseValue
+  }),
+
+  // [7] CRM Sync — criar/atualizar contato como comprador
+  syncToCRM(env, 'purchase', {
+    email:    buyerEmail,
+    name:     buyerName,
+    product:  productName,
+    value:    purchaseValue,
+    order_id: transactionId
+  })
+]));
+```
+
+> **Nota:** `sendEmail()` é implementada pelo Email Agent em `cloudflare/email-service.js`.
+> `syncToCRM()` é implementada pelo CRM Integration Agent em `cloudflare/crm-service.js`.
+
+---
+
 ## INPUTS RECEBIDOS
 
 - Payload JSON do webhook da plataforma de vendas (Hotmart, Kiwify, Ticto, Stripe)