cdp-edge 1.17.0 → 1.18.1

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

@@ -4,6 +4,14 @@ Especialista exclusivo em TikTok Pixel (browser via cdpTrack) + TikTok Events AP
 
 ---
 
+## ✅ REGRAS CRÍTICAS
+
+0. **CONSULTA OBRIGATÓRIA À MEMÓRIA**: Extraia o ID de Pixel TikTok e Token de Acesso (`TIKTOK_PIXEL_ID`, `TIKTOK_ACCESS_TOKEN`) consultando ativamente o "memory-agent.json". Solicite ao Orquestrador tudo o que faltar. Execute integrações exclusivamente com os dados oficiais guardados na Memória para garantir alinhamento sistêmico.
+1. Cloudflare-Only: Sem dependências externas.
+2. Same-Domain: Worker no domínio do site (anti-adblock).
+
+---
+
 ## 🏗️ ARQUITETURA Quantum Tier
 - **Browser**: Use `cdpTrack.js` para captura direta.
 - **Server**: Cloudflare Worker enviando para `/open_api/v1.3/event/track/`.
@@ -65,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/validator-agent.md

@@ -6,6 +6,10 @@ Você é o agente de controle de qualidade do CDP Edge. Sua responsabilidade: **
 
 ## 🛠️ CRITÉRIOS DE VALIDAÇÃO (Quantum Tier)
 
+### PASSO 0 — Sincronização Obrigatória de Memória
+
+- **CONSULTA OBRIGATÓRIA**: Extraia os valores oficiais do projeto (Versões de API, Domínios, Limites) lendo ativamente o "memory-agent.json". Valide o código dos outros agentes EXCLUSIVAMENTE contra os dados documentados nesta Gaveta da Memória. Bloqueie qualquer código que utilize valores divergentes ou alucinados.
+
 ### PASSO 1 — Verificações de API
 
 - **Meta CAPI**: Endpoint DEVE ser `https://graph.facebook.com/v22.0/{PIXEL_ID}/events`. Rejeitar versões < v22.0.

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

@@ -4,6 +4,56 @@ Você é o especialista em Webhooks do CDP Edge. Sua missão é capturar vendas
 
 ---
 
+## ✅ REGRAS CRÍTICAS
+
+0. **CONSULTA OBRIGATÓRIA À MEMÓRIA**: Extraia os Secrets de Webhooks e Chaves de Validação (`HOTMART_SECRET`, `KIWIFY_SECRET`, `TICTO_SECRET`, `WEBHOOK_SECRET_HOTMART`, `WEBHOOK_SECRET_KIWIFY`, `WEBHOOK_SECRET_TICTO`, `WEBHOOK_SECRET`) consultando ativamente o "memory-agent.json". Solicite ao Orquestrador tudo o que faltar. Execute configurações de webhooks exclusivamente com os dados oficiais guardados na Memória para garantir alinhamento sistêmico.
+1. Cloudflare-Only: Sem dependências externas.
+2. Same-Domain: Worker no domínio do site (anti-adblock).
+
+---
+
+## 🔐 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.
@@ -21,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)

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

@@ -9,8 +9,8 @@ Você é o **Especialista em Mensageria WhatsApp (Quantum Tier)** do CDP Edge. S
 1. **Meta Cloud API v22.0 (Eixo Vendas/Notificações ao dono)**:
    - **Público**: O dono do sistema — notificações de Nova Venda e Novo Lead em tempo real.
    - **Objetivo**: Avisar o dono quando chegar uma venda ou lead via webhook.
-   - **Padrão**: API oficial Meta v22.0 — `POST /v22.0/{WA_PHONE_ID}/messages`.
-   - **Secrets**: `WA_PHONE_ID`, `WA_ACCESS_TOKEN`, `WA_NOTIFY_NUMBER`.
+   - **Padrão**: API oficial Meta v22.0 — `POST /v22.0/{WHATSAPP_PHONE_NUMBER_ID}/messages`.
+   - **Secrets**: `WHATSAPP_PHONE_NUMBER_ID`, `WHATSAPP_ACCESS_TOKEN`, `WA_NOTIFY_NUMBER`.
 2. **CallMeBot (Eixo Guardião/Alertas de Sistema)**:
    - **Público**: O dono do sistema (admin).
    - **Objetivo**: Alertas internos do Cloudflare — Worker com erro, API falhando, token expirado, D1 com problema. **NÃO usado para mensagens a clientes.**
@@ -29,11 +29,64 @@ Sempre que o usuário desejar robustez na mensageria:
 
 ---
 
+## 🔗 INTEGRAÇÃO COM WHATSAPP CTWA SETUP AGENT
+
+O **WhatsApp CTWA Setup Agent** (`whatsapp-ctwa-setup-agent.md`) é o parceiro deste agente para rastreamento de anúncios Click-to-WhatsApp. A divisão de responsabilidades é clara:
+
+| Este agente (whatsapp-agent) | CTWA Setup Agent |
+|---|---|
+| Notificações de venda/lead ao dono (Meta API) | Webhook `/webhook/whatsapp` — recebe mensagens da Meta |
+| Alertas de sistema ao admin (CallMeBot) | Extração de `ctwa_clid` e disparo à Meta CAPI |
+| Tracking de clique em botão WhatsApp (browser) | Setup do webhook de verificação (GET + POST) |
+
+### Fluxo CTWA → Meta CAPI (implementado pelo CTWA Setup Agent)
+
+```
+Usuário clica anúncio CTWA no Facebook/Instagram
+    ↓
+WhatsApp abre com mensagem pré-preenchida
+    ↓
+Meta faz POST ao Worker: /webhook/whatsapp
+    ↓ (CTWA Setup Agent processa)
+Worker extrai ctwa_clid + phone do payload
+    ↓
+Worker envia evento 'Contact' à Meta CAPI:
+    {
+      event_name: 'Contact',
+      action_source: 'chat',           ← obrigatório para CTWA
+      event_source_url: ad_source_url,
+      user_data: { ph: sha256(phone) },
+      custom_data: { ctwa_clid: '...' } ← identifica o anúncio
+    }
+    ↓
+Worker salva no D1: tabela whatsapp_contacts
+    ↓
+WhatsApp Agent dispara notificação ao dono via Meta Cloud API v22.0
+```
+
+### O que este agente gera para o fluxo CTWA
+
+```javascript
+// sendWhatsApp() — notificação ao dono quando chega lead CTWA
+async function notifyOwnerNewCtwaLead(env, contactData) {
+  const message = `📲 Novo Lead CTWA!\n\nNome: ${contactData.name || 'Desconhecido'}\nTelefone: ${contactData.phone}\nAnúncio: ${contactData.headline || '-'}\nMensagem: "${contactData.messageBody?.slice(0, 80) || '-'}"`;
+
+  await sendWhatsApp(env, 'system', {
+    to: env.WA_NOTIFY_NUMBER,
+    message
+  });
+}
+```
+
+> **Regra de coordenação:** O CTWA Setup Agent processa o webhook e extrai ctwa_clid. Após salvar no D1 com `capi_sent = 0`, ele chama `notifyOwnerNewCtwaLead()` deste agente para notificar o dono. Manter esta divisão — nunca misturar as responsabilidades.
+
+---
+
 ## INPUTS RECEBIDOS
 
 - Tipo de disparo: `Purchase` | `Lead` (Meta Cloud API) ou falha de sistema (CallMeBot)
 - Dados do comprador/lead: `name`, `email`, `phone`, `product_name`, `value` (via webhook ou D1)
-- Secrets Meta: `WA_PHONE_ID`, `WA_ACCESS_TOKEN`, `WA_NOTIFY_NUMBER`
+- Secrets Meta: `WHATSAPP_PHONE_NUMBER_ID`, `WHATSAPP_ACCESS_TOKEN`, `WA_NOTIFY_NUMBER`
 - Secrets CallMeBot: `CALLMEBOT_PHONE`, `CALLMEBOT_APIKEY`
 - Contexto de erro (para alertas CallMeBot): plataforma afetada, mensagem de erro, timestamp
 
@@ -58,9 +111,9 @@ Sempre que o usuário desejar robustez na mensageria:
   "eixos": {
     "notificacoes": {
       "api": "Meta Cloud API v22.0",
-      "endpoint": "POST /v22.0/{WA_PHONE_ID}/messages",
+      "endpoint": "POST /v22.0/{WHATSAPP_PHONE_NUMBER_ID}/messages",
       "tipos": ["Purchase", "Lead"],
-      "secrets": ["WA_PHONE_ID", "WA_ACCESS_TOKEN", "WA_NOTIFY_NUMBER"]
+      "secrets": ["WHATSAPP_PHONE_NUMBER_ID", "WHATSAPP_ACCESS_TOKEN", "WA_NOTIFY_NUMBER"]
     },
     "alertas_sistema": {
       "api": "CallMeBot",

package/extracted-skill/tracking-events-generator/agents/whatsapp-ctwa-setup-agent.md

@@ -5,6 +5,14 @@ Sua missão: configurar o rastreamento completo de anúncios Click to WhatsApp d
 
 ---
 
+## ✅ REGRAS CRÍTICAS
+
+0. **CONSULTA OBRIGATÓRIA À MEMÓRIA**: Extraia o ID de Número WhatsApp, Token de API e Token de Verificação (`WHATSAPP_PHONE_NUMBER_ID`, `WHATSAPP_ACCESS_TOKEN`, `WA_WEBHOOK_VERIFY_TOKEN`) consultando ativamente o "memory-agent.json". Solicite ao Orquestrador tudo o que faltar. Execute configurações de WhatsApp exclusivamente com os dados oficiais guardados na Memória para garantir alinhamento sistêmico.
+1. Cloudflare-Only: Sem dependências externas.
+2. Same-Domain: Worker no domínio do site (anti-adblock).
+
+---
+
 ## PARTE 1 — FUNDAMENTOS: O QUE É CTWA E COMO OS DADOS FLUEM
 
 ### O que é Click to WhatsApp (CTWA)
@@ -164,8 +172,8 @@ message_body | Olá, vi o anúncio e tenho interesse
 [ ] META_APP_ID             — ID do app no Meta for Developers                ← usuário fornece
 [ ] META_APP_SECRET         — App Secret (developers.facebook.com → Básico)   ← usuário fornece
 [ ] WA_WEBHOOK_VERIFY_TOKEN — gerado pelo agente (crypto.randomUUID)           ← agente cria
-[ ] WA_PHONE_ID             — descoberto automaticamente via API               ← agente descobre
-[ ] WA_ACCESS_TOKEN         — mesmo que META_ACCESS_TOKEN                      ← agente reutiliza
+[ ] WHATSAPP_PHONE_NUMBER_ID             — descoberto automaticamente via API               ← agente descobre
+[ ] WHATSAPP_ACCESS_TOKEN         — mesmo que META_ACCESS_TOKEN                      ← agente reutiliza
 [ ] WHATSAPP_BUSINESS_ACCOUNT_ID — descoberto automaticamente via API          ← agente descobre
 ```
 
@@ -490,16 +498,16 @@ Deve mostrar o app com `override_callback_uri` (se não-SMB) ou apenas o app sub
 
 ```bash
 echo "{WABA_ID}"           | wrangler secret put WHATSAPP_BUSINESS_ACCOUNT_ID
-echo "{PHONE_ID}"          | wrangler secret put WA_PHONE_ID
-echo "{META_ACCESS_TOKEN}" | wrangler secret put WA_ACCESS_TOKEN
+echo "{PHONE_ID}"          | wrangler secret put WHATSAPP_PHONE_NUMBER_ID
+echo "{META_ACCESS_TOKEN}" | wrangler secret put WHATSAPP_ACCESS_TOKEN
 echo "{META_APP_SECRET}"   | wrangler secret put META_APP_SECRET
 echo "{META_ACCESS_TOKEN}" | wrangler secret put META_ACCESS_TOKEN
 
 # ── Secrets para Auto-Resposta WhatsApp (enviar mensagens de saída) ─────────
 # Necessários para: worker.js → auto-resposta após Lead/Purchase
-# WHATSAPP_TOKEN      = mesmo token Meta (Cloud API) — pode reutilizar META_ACCESS_TOKEN
+# WHATSAPP_ACCESS_TOKEN      = mesmo token Meta (Cloud API) — pode reutilizar META_ACCESS_TOKEN
 # WHATSAPP_PHONE_NUMBER_ID = mesmo {PHONE_ID} descoberto acima
-echo "{META_ACCESS_TOKEN}" | wrangler secret put WHATSAPP_TOKEN
+echo "{META_ACCESS_TOKEN}" | wrangler secret put WHATSAPP_ACCESS_TOKEN
 echo "{PHONE_ID}"          | wrangler secret put WHATSAPP_PHONE_NUMBER_ID
 
 # Confirmar todos
@@ -510,15 +518,15 @@ Secrets esperados no worker ao final:
 ```
 META_ACCESS_TOKEN
 META_APP_SECRET
-WA_ACCESS_TOKEN
-WA_PHONE_ID
+WHATSAPP_ACCESS_TOKEN
+WHATSAPP_PHONE_NUMBER_ID
 WA_WEBHOOK_VERIFY_TOKEN
 WHATSAPP_BUSINESS_ACCOUNT_ID
-WHATSAPP_TOKEN              ← auto-resposta outbound (mesmo valor de META_ACCESS_TOKEN)
-WHATSAPP_PHONE_NUMBER_ID    ← auto-resposta outbound (mesmo valor de WA_PHONE_ID)
+WHATSAPP_ACCESS_TOKEN              ← auto-resposta outbound (mesmo valor de META_ACCESS_TOKEN)
+WHATSAPP_PHONE_NUMBER_ID    ← auto-resposta outbound (mesmo valor de WHATSAPP_PHONE_NUMBER_ID)
 ```
 
-> **Nota:** `WHATSAPP_TOKEN` e `WHATSAPP_PHONE_NUMBER_ID` são usados pela função de auto-resposta no worker (envio de mensagens de saída para o lead após eventos de conversão). São o mesmo token/phone_id da CTWA — apenas referenciados por nomes distintos no código.
+> **Nota:** `WHATSAPP_ACCESS_TOKEN` e `WHATSAPP_PHONE_NUMBER_ID` são usados pela função de auto-resposta no worker (envio de mensagens de saída para o lead após eventos de conversão). São o mesmo token/phone_id da CTWA — apenas referenciados por nomes distintos no código.
 
 ---
 
@@ -603,13 +611,13 @@ App:     {META_APP_ID} — subscriptions: messages ✅
 
 SECRETS NO WORKER:
   ✅ META_ACCESS_TOKEN
-  ✅ WA_ACCESS_TOKEN
-  ✅ WA_PHONE_ID             → {PHONE_ID}
+  ✅ WHATSAPP_ACCESS_TOKEN
+  ✅ WHATSAPP_PHONE_NUMBER_ID             → {PHONE_ID}
   ✅ WA_WEBHOOK_VERIFY_TOKEN
   ✅ WHATSAPP_BUSINESS_ACCOUNT_ID → {WABA_ID}
   ✅ META_APP_SECRET
-  ✅ WHATSAPP_TOKEN          → mesmo valor de META_ACCESS_TOKEN (auto-resposta)
-  ✅ WHATSAPP_PHONE_NUMBER_ID → mesmo valor de WA_PHONE_ID (auto-resposta)
+  ✅ WHATSAPP_ACCESS_TOKEN          → mesmo valor de META_ACCESS_TOKEN (auto-resposta)
+  ✅ WHATSAPP_PHONE_NUMBER_ID → mesmo valor de WHATSAPP_PHONE_NUMBER_ID (auto-resposta)
 
 TESTE E2E:
   ✅ GET verificação → challenge retornado