cdp-edge 1.18.0 → 1.18.2

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

@@ -1,5 +1,15 @@
 # Performance Agent (Monitoring Master) — CDP Edge
 
+> **ESCOPO DESTE AGENTE:** Monitoramento e observabilidade em tempo real.
+> Para otimização de cache, queries e latência, ver: **performance-optimization-agent.md**
+>
+> | Este agente faz | performance-optimization-agent faz |
+> |---|---|
+> | Medir latência, throughput, error rates | Estratégias de caching (L1/L2/L3) |
+> | Alertas de degradação de SLA | Otimização de queries D1 |
+> | Health checks e dashboards | Batch processing, indexação |
+> | Relatórios de performance | Profiling e tunning de Workers |
+
 Você é o **Agente de Monitoramento de Performance do CDP Edge**. Sua responsabilidade: **monitorar continuamente a saúde do sistema de tracking** (latência, throughput, error rates, performance de D1) e prover métricas acionáveis para otimização.
 
 ---
@@ -107,20 +117,20 @@ function evaluateLatencyPerformance(latencyMetrics) {
 
 ```javascript
 // Monitorar taxa de falhas em todas as APIs
-export async function measureApiErrorRate(hours = 24) {
+export async function measureApiErrorRate(env, hours = 24) {
   const platforms = ['meta', 'google', 'tiktok', 'pinterest', 'reddit'];
   const errorRates = {};
 
   for (const platform of platforms) {
     // Total de requisições (sucesso + falha)
-    const totalRequests = await DB.prepare(`
+    const totalRequests = await env.DB.prepare(`
       SELECT COUNT(*) as total
       FROM events_log
       WHERE platform = ? AND created_at > datetime('now', '-${hours} hours')
     `).bind(platform).get();
 
     // Requisições que falharam
-    const failedRequests = await DB.prepare(`
+    const failedRequests = await env.DB.prepare(`
       SELECT COUNT(*) as failed
       FROM events_log
       WHERE platform = ? AND status = 'failed' AND created_at > datetime('now', '-${hours} hours')
@@ -159,7 +169,7 @@ function evaluateErrorRate(errorRate) {
 
 ```javascript
 // Monitorar eventos processados por segundo/minuto
-export async function measureThroughput(hours = 24) {
+export async function measureThroughput(env, hours = 24) {
   const now = new Date();
   const windows = [];
 
@@ -168,7 +178,7 @@ export async function measureThroughput(hours = 24) {
     const windowStart = new Date(now - (i + 1) * 60 * 60 * 1000);
     const windowEnd = new Date(now - i * 60 * 60 * 1000);
 
-    const eventsInWindow = await DB.prepare(`
+    const eventsInWindow = await env.DB.prepare(`
       SELECT COUNT(*) as events,
              MIN(created_at) as first_event,
              MAX(created_at) as last_event
@@ -229,9 +239,9 @@ function evaluateThroughputTrend(recent, historical) {
 
 ```javascript
 // Monitorar performance do banco de dados D1
-export async function measureD1Performance(hours = 24) {
+export async function measureD1Performance(env, hours = 24) {
   // Queries lentas
-  const slowQueries = await DB.prepare(`
+  const slowQueries = await env.DB.prepare(`
     SELECT
       query_hash,
       COUNT(*) as execution_count,
@@ -246,7 +256,7 @@ export async function measureD1Performance(hours = 24) {
   `).all();
 
   // Verificar locks
-  const locks = await DB.prepare(`
+  const locks = await env.DB.prepare(`
     SELECT
       COUNT(*) as total_locks,
       AVG(lock_duration_ms) as avg_lock_duration,
@@ -323,9 +333,9 @@ function evaluateD1Health(slowQueries, locks, dbSize) {
 
 ```javascript
 // Monitorar eficiência do cache KV
-export async function measureCachePerformance(hours = 24) {
+export async function measureCachePerformance(env, hours = 24) {
   // Cache hits e misses
-  const cacheStats = await DB.prepare(`
+  const cacheStats = await env.DB.prepare(`
     SELECT
       COUNT(*) FILTER (WHERE hit = 1) as hits,
       COUNT(*) FILTER (WHERE hit = 0) as misses,
@@ -340,7 +350,7 @@ export async function measureCachePerformance(hours = 24) {
   const hitRate = total > 0 ? (hits / total * 100) : 0;
 
   // Keys armazenadas
-  const totalKeys = await KV.list().then(list => list.keys.length);
+  const totalKeys = await env.GEO_CACHE.list().then(list => list.keys.length);
 
   return {
     hits,
@@ -849,7 +859,7 @@ cpu_ms = 50 # Aumentar de 10ms para 50ms
 ```javascript
 // Cache de métricas globais por 1 hora
 const cacheKey = `metrics:global:${getHourBucket()}`;
-const cached = await KV.get(cacheKey);
+const cached = await env.GEO_CACHE.get(cacheKey);
 
 if (cached) {
   return JSON.parse(cached);
@@ -857,7 +867,7 @@ if (cached) {
 
 // Cache miss — consultar D1 e persistir no KV
 const metrics = await fetchMetricsFromD1();
-await KV.put(cacheKey, JSON.stringify(metrics), { expirationTtl: 3600 });
+await env.GEO_CACHE.put(cacheKey, JSON.stringify(metrics), { expirationTtl: 3600 });
 
 return metrics;
 ```
@@ -948,17 +958,17 @@ const RATE_LIMITS = {
   tiktok: { tokens: 10, refill_rate: 1 }        // 10 req/min
 };
 
-async function consumeToken(platform) {
+async function consumeToken(platform, env) {
   const limit = RATE_LIMITS[platform];
   const key = `rate_limit:${platform}`;
 
-  let tokens = await KV.get(key) || JSON.stringify(limit.tokens);
+  let tokens = await env.GEO_CACHE.get(key) || JSON.stringify(limit.tokens);
 
   tokens = JSON.parse(tokens);
 
   if (tokens > 0) {
     tokens--;
-    await KV.put(key, JSON.stringify(tokens));
+    await env.GEO_CACHE.put(key, JSON.stringify(tokens));
     return true; // Permitido
   }
 
@@ -1030,17 +1040,17 @@ const CACHE_TTL = {
 **Solução:**
 ```javascript
 // Invalidar cache quando dados mudarem
-async function invalidateCacheOnChange(eventType) {
+async function invalidateCacheOnChange(eventType, env) {
   const patterns = {
     'lead_created': ['metrics:*', 'user_profile:*'],
     'purchase_completed': ['metrics:*', 'session_data:*'],
     'api_config_changed': ['api_config:*']
   };
 
-  const keysToDelete = await KV.list({ prefix: patterns[eventType] });
+  const keysToDelete = await env.GEO_CACHE.list({ prefix: patterns[eventType] });
 
   for (const key of keysToDelete.keys) {
-    await KV.delete(key.name);
+    await env.GEO_CACHE.delete(key.name);
   }
 
   console.log(`Invalidated ${keysToDelete.keys.length} cache keys for ${eventType}`);

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

@@ -8,6 +8,16 @@ version: "1.0.0"
 
 # Performance Optimization Enterprise Agent
 
+> **ESCOPO DESTE AGENTE:** Otimização ativa de performance — caching, queries, batching.
+> Para monitoramento passivo (métricas, alertas, dashboards), ver: **performance-agent.md**
+>
+> | Este agente faz | performance-agent faz |
+> |---|---|
+> | Estratégias de caching L1/L2/L3 | Medir latência e throughput |
+> | Otimização de queries D1 e indexação | Alertas de degradação de SLA |
+> | Batch processing e pipeline tuning | Health checks e dashboards |
+> | Profiling de Workers e CPU optimization | Relatórios de performance |
+
 ## 🚀 Visão Geral
 
 Agente especializado em otimização de performance para o sistema CDP Edge (Cloudflare Workers + D1 + Queue). Implementa estratégias de caching multi-camada, otimização de queries, processamento em lote e monitoramento de latência em tempo real.
@@ -159,7 +169,7 @@ let l1Cache = new L1Cache();
  */
 class L2Cache {
   constructor(env) {
-    this.kv = env.CACHE_KV; // Cloudflare KV namespace
+    this.kv = env.GEO_CACHE; // Cloudflare KV namespace
     this.stats = {
       hits: 0,
       misses: 0,

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)