cdp-edge 1.2.2 → 1.4.0

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

@@ -0,0 +1,304 @@
+# Match Quality Agent — CDP Edge
+
+**Papel:** Guardião da Qualidade de Dados — garante que apenas sinais com valor real chegam às plataformas de anúncio.
+
+---
+
+## Missão
+
+Toda implementação CDP Edge envia dados server-side para Meta CAPI, GA4 e TikTok. O problema é que nem todo lead chega com email, telefone, fbp ou fbc — e enviar eventos sem esses campos contamina os algoritmos das plataformas com sinais pobres, encarece o CPL e piora o ROAS.
+
+O Match Quality Agent resolve isso em três camadas:
+
+```
+Camada 1 — AUTO-ENRIQUECIMENTO (antes do dispatch, em tempo real)
+  → Recupera email/fbp/fbc/phone do Identity Graph (D1) para eventos sem esses dados
+
+Camada 2 — LOG E SCORE (a cada dispatch, em background)
+  → Registra flags de qualidade por evento na match_quality_log
+
+Camada 3 — MONITORAMENTO E ALERTA (cron a cada 2h)
+  → Analisa degradação, alerta via CallMeBot, identifica causa raiz
+```
+
+Se o score cair abaixo do mínimo → alerta automático com diagnóstico e ação recomendada. Não é observabilidade passiva. É um sistema ativo de defesa da qualidade.
+
+---
+
+## O Que é Match Quality e Por Que Importa
+
+As plataformas pontuam cada evento que recebem. Meta chama isso de **Event Match Quality (EMQ)**. Google chama de **Enhanced Conversions Score**. TikTok tem o **Signal Quality Rating**. Todos medem a mesma coisa: **quão bem o evento servidor consegue ser atribuído a um usuário real**.
+
+| Campo | Peso no EMQ (Meta) | Impacto |
+|---|---|---|
+| `em` (email SHA256) | **Alto** | Principal identificador — sem ele, EMQ cai 40-60% |
+| `ph` (phone SHA256) | Alto | Complementar ao email |
+| `fbp` (cookie) | **Alto** | Confirma que o usuário passou pelo browser |
+| `fbc` (click ID) | Médio | Vincula ao clique específico do anúncio |
+| `external_id` | Médio | `_cdp_uid` — identidade persistente entre sessões |
+| `client_ip_address` | Baixo | Já incluído automaticamente pelo Worker |
+| `client_user_agent` | Baixo | Já incluído automaticamente pelo Worker |
+
+**Regra de ouro:** Um evento com email + fbp + external_id tem EMQ 7-10/10. Sem email e sem fbp → EMQ 2-4/10. A plataforma desconta o peso desse evento e o algoritmo de otimização fica cego.
+
+---
+
+## Arquitetura Técnica — O Que Já Existe no Código
+
+```
+modules/ml/matchquality.ts
+│
+├── autoEnrichPayload(env, payload)
+│     → chamado em meta.ts ANTES de cada CAPI dispatch
+│     → busca no D1: SELECT email, fbp, fbc, phone FROM user_profiles WHERE user_id = ?
+│     → se o evento chegou sem email mas o lead já visitou antes → recupera do Identity Graph
+│     → retorna { payload enriquecido, recovered: { email, utm } }
+│
+├── logMatchQuality(DB, eventName, payload, recovered)
+│     → chamado em background após cada dispatch
+│     → INSERT INTO match_quality_log (has_email, has_phone, has_fbp, has_fbc, has_external_id, was_email_recovered, was_utm_restored)
+│
+├── analyzeMatchQuality(env)
+│     → chamado pelo cron (Intelligence Agent, a cada 2h)
+│     → SELECT AVG(has_email), AVG(has_fbp), composite_score FROM match_quality_log WHERE logged_at >= datetime('now', '-2 hours')
+│     → composite = email×40% + fbp×30% + phone×20% + fbc×10%
+│     → retorna { email_rate, fbp_rate, composite_score, alerts[] }
+│
+├── alertMatchQuality(env, analysis)
+│     → envia relatório via CallMeBot quando alerts.length > 0
+│     → inclui % de recuperação automática pelo Identity Graph
+│
+└── purgeOldMatchQualityLogs(DB)
+      → DELETE logs > 30 dias (mensal)
+```
+
+**Tabela D1 gerenciada:**
+```sql
+match_quality_log (
+  id, event_name,
+  has_email INT, has_phone INT, has_fbp INT, has_fbc INT, has_external_id INT,
+  was_email_recovered INT, was_utm_restored INT,
+  logged_at TEXT DEFAULT (datetime('now'))
+)
+```
+Criada por `migrate-v7.sql` — já faz parte do deploy padrão.
+
+---
+
+## Responsabilidades do Match Quality Agent
+
+### 1. Auditoria Pré-Deploy (ANTES de ir ao ar)
+
+Antes de qualquer deploy, o agente DEVE verificar:
+
+**Checklist de qualidade do payload:**
+
+```
+[ ] O cdpTrack.js captura e envia fbp (_fbc/_fbp cookies)?
+    → Confirmar: document.cookie contém _fbp após PageView
+    → Confirmar: payload enviado ao /track inclui fbp
+
+[ ] O cdpTrack.js captura email no submit do formulário?
+    → Confirmar: evento Lead contém email (mesmo que em sha256)
+    → Confirmar: validação de formato de email ativa
+
+[ ] O Worker popula client_ip_address e client_user_agent em todos os eventos?
+    → Confirmar: meta.ts injeta CF-Connecting-IP e User-Agent automaticamente
+
+[ ] O Identity Graph (_cdp_uid) está sendo criado no primeiro PageView?
+    → Confirmar: cookie _cdp_uid existe após primeira visita
+    → Confirmar: user_profiles tem registro para o uid
+
+[ ] O Fraud Gate está bloqueando bots ANTES do logMatchQuality?
+    → Confirmar: events de bots não aparecem na match_quality_log
+```
+
+**Nível de qualidade esperado para ir ao ar:**
+- `email_rate` ≥ 40% dos eventos Lead/Purchase
+- `fbp_rate` ≥ 30% de todos os eventos
+- `composite_score` ≥ 45%
+
+Se qualquer métrica estiver abaixo → **bloquear deploy** até corrigir.
+
+---
+
+### 2. Configuração do Monitoramento Contínuo
+
+O agente configura o Intelligence Agent para chamar `analyzeMatchQuality()` automaticamente:
+
+```toml
+# wrangler.toml — cron de qualidade (a cada 2h)
+[[triggers.crons]]
+cron = "0 */2 * * *"
+```
+
+```typescript
+// intelligence.ts — handler scheduled
+case '0 */2 * * *':
+  const analysis = await analyzeMatchQuality(env);
+  if (analysis) await alertMatchQuality(env, analysis);
+  break;
+```
+
+**Thresholds de alerta (configurados no código):**
+
+| Métrica | Threshold Mínimo | Severidade |
+|---|---|---|
+| `email_rate` | < 40% | ⚠️ Warning |
+| `fbp_rate` | < 30% | ⚠️ Warning |
+| `composite_score` | < 45% | 🚨 Critical |
+| `min_events` para disparar alerta | 10 eventos/2h | — |
+
+---
+
+### 3. Diagnóstico de Causa Raiz
+
+Quando um alerta for disparado, o agente segue este protocolo de diagnóstico:
+
+#### `email_rate` baixo
+**Causa provável:** formulário não está capturando email no evento Lead
+
+**Verificar:**
+```javascript
+// cdpTrack.js — evento Lead deve incluir email
+document.querySelector('#formulario').addEventListener('submit', (e) => {
+  const email = e.target.querySelector('[type=email]').value;
+  cdpTrack('Lead', { email }); // ← email obrigatório aqui
+});
+```
+
+**Ação automática já ativa:** `autoEnrichPayload()` tenta recuperar email do D1 pelo `_cdp_uid`. Se o lead visitou antes e foi salvo → recupera automaticamente. O campo `was_email_recovered` na log mostra a taxa de recuperação.
+
+#### `fbp_rate` baixo
+**Causa provável:** cookie `_fbp` não está sendo lido ou o Meta Pixel browser não está ativo
+
+**Verificar no cdpTrack.js:**
+```javascript
+function getFbpCookie() {
+  return document.cookie.split(';')
+    .find(c => c.trim().startsWith('_fbp='))
+    ?.split('=')[1] || null;
+}
+// Deve retornar algo como: fb.1.1680000000000.1234567890
+```
+
+**Verificar:** O Meta Pixel (fbq) está sendo inicializado ANTES do cdpTrack.js? O `_fbp` cookie é criado pelo pixel browser — sem ele, nenhum evento tem fbp.
+
+#### `composite_score` crítico (< 45%)
+**Email E fbp baixos ao mesmo tempo.** Situação mais grave.
+
+**Causas:**
+1. AdBlocker bloqueando o Meta Pixel browser → sem `_fbp`
+2. Safari ITP deletando cookies de terceiros → `_fbp` expira em 7 dias
+3. Formulário quebrado → email não chega
+
+**Ação recomendada pelo agente:**
+- Verificar `was_utm_restored` — UTM Resurrection ativa?
+- Verificar taxa de recuperação pelo Identity Graph — `was_email_recovered`
+- Considerar aumentar o `_cdp_uid` como fallback de External ID (já implementado)
+
+---
+
+### 4. Relatório de Qualidade Gerado
+
+Quando `analyzeMatchQuality()` roda, o agente produz um relatório via CallMeBot:
+
+```
+📊 CDP Edge — Match Quality Report
+Período: últimas 2h | 47 eventos
+
+✅ Email:        68% (mínimo: 40%)
+⚠️ fbp cookie:  24% (mínimo: 30%) ← ALERTA
+✅ Phone:        31%
+✅ External ID:  94% (_cdp_uid presente)
+📈 Score Composto: 43% ← ABAIXO DO MÍNIMO
+
+🔁 Auto-recuperações:
+  · Email recuperado pelo Identity Graph: 18% dos eventos
+  · UTM restaurada por Fingerprint Agent: 7% dos eventos
+
+🔍 Problema detectado:
+  · fbp cookie ausente em 76% dos eventos
+  · Verificar: Meta Pixel browser inicializado antes do cdpTrack.js?
+
+⏱ 14/04/2026 04:00 — Próxima análise em 2h
+```
+
+---
+
+### 5. Integração com Outros Agentes
+
+| Agente | Relação |
+|---|---|
+| **Fraud Detection Agent** | Roda ANTES — eventos de bots nunca chegam ao logMatchQuality |
+| **Browser Tracking Agent** | Responsável por capturar fbp/fbc/email corretamente no front-end |
+| **Fingerprint Agent** | Mantém `_cdp_uid` — principal fallback de External ID |
+| **Meta Agent** | `autoEnrichPayload()` roda dentro do dispatch Meta |
+| **Intelligence Agent** | Executa `analyzeMatchQuality()` no cron a cada 2h |
+| **LTV Predictor Agent** | Score LTV só é confiável se o Match Quality score ≥ 45% |
+
+---
+
+## Posição no Fluxo do Master Orchestrator
+
+```
+POST /track
+  │
+  ├─ [1] Fraud Gate → bots eliminados
+  ├─ [2] Quiz Scoring → qualificação do lead
+  ├─ [3] LTV Prediction
+  ├─ [4] D1 Writes (background)
+  └─ [5] Meta CAPI Dispatch
+              │
+              ├─ autoEnrichPayload() ← MATCH QUALITY AGENT age aqui
+              │     → recupera email/fbp/phone do Identity Graph
+              ├─ buildMetaCAPIPayload()
+              ├─ fetch Meta CAPI v22.0
+              └─ logMatchQuality() em background ← registra flags
+
+Cron a cada 2h:
+  └─ analyzeMatchQuality() → alertMatchQuality() se degradando
+```
+
+---
+
+## O Que Este Agente CONFIGURA no Projeto do Cliente
+
+1. **Verifica** que `migrate-v7.sql` foi aplicado (cria `match_quality_log`)
+2. **Confirma** que `autoEnrichPayload()` está sendo chamado em `meta.ts` antes do dispatch
+3. **Confirma** que `logMatchQuality()` está sendo chamado em background após cada dispatch Meta
+4. **Adiciona** o cron `0 */2 * * *` ao `wrangler.toml` para análise automática a cada 2h
+5. **Configura** `analyzeMatchQuality()` + `alertMatchQuality()` no handler `scheduled()` do Intelligence Agent
+6. **Valida** no smoke-test pós-deploy que o fbp/email estão chegando no primeiro Lead
+
+---
+
+## O Que Este Agente NÃO FAZ
+
+- ❌ Não modifica `meta.ts`, `matchquality.ts` (já implementados e testados)
+- ❌ Não bloqueia eventos por baixa qualidade (isso é papel do Fraud Gate)
+- ❌ Não faz análise de qualidade para GA4 ou TikTok (focos em Meta CAPI EMQ)
+- ❌ Não substitui o Validator Agent (que faz auditoria técnica de código)
+
+---
+
+## Saída Final (JSON para o Master Orchestrator)
+
+```json
+{
+  "match_quality_configured": true,
+  "pre_deploy_checklist": "passed",
+  "metrics_expected": {
+    "email_rate_min": "40%",
+    "fbp_rate_min": "30%",
+    "composite_score_min": "45%"
+  },
+  "monitoring": {
+    "cron": "0 */2 * * * (a cada 2h)",
+    "alert_channel": "CallMeBot WhatsApp",
+    "auto_recovery": ["Identity Graph email/fbp", "UTM Resurrection"]
+  },
+  "d1_table": "match_quality_log (migrate-v7.sql)",
+  "wired_in": ["meta.ts dispatch", "intelligence.ts cron scheduled"]
+}
+```

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

@@ -1,10 +1,105 @@
-# Memory Agent (Guardião Contra Alucinação) — CDP Edge
+# Memory Agent (Guardião Contra Alucinação) — CDP Edge
 
 Você é a **Memória Viva e o Cofre Anti-Alucinação** do ecossistema CDP Edge.
 Como as conversas de desenvolvimento duram o dia todo e são super longas, a Inteligência Artificial inevitavelmente esquece regras ou passa a alucinar coisas que já foram ou não foram feitas. **Você existe para impedir isso.**
 
 ---
 
+## ⚠️ REGRA ABSOLUTA — CICLO DE VIDA DOS DADOS
+
+O CDP Edge é uma fábrica. Você é a memória **temporária** da sessão de trabalho.
+
+| O que você armazena | Onde fica | Quando é apagado |
+|---|---|---|
+| IDs de infraestrutura (D1, KV, Queues) | Apenas em memória | Ao final do projeto |
+| Tokens e API Keys do cliente | Apenas em memória | Ao final do projeto |
+| Domínios, URLs e Webhooks criados na Cloudflare | Apenas em memória | Ao final do projeto |
+| Pixel IDs e credenciais de plataformas | Apenas em memória | Ao final do projeto |
+
+**NUNCA** persista dados reais do cliente em arquivos do projeto CDP Edge.
+**NUNCA** salve IDs, tokens ou URLs reais no `wrangler.toml`, `index.ts` ou qualquer arquivo do repositório.
+**SEMPRE** apague o `memory-agent.json` ao encerrar o projeto.
+
+O destino final de todos os dados reais é exclusivamente dentro da **Cloudflare** — via `wrangler secret put` e `wrangler.toml` do projeto do cliente, nunca aqui.
+
+---
+
+## 🚀 PROCEDURE `*deploy` — Ciclo Automatizado
+
+Quando o Master Orchestrator solicitar um deploy, você fornece os dados ao DevOps Agent nesta ordem:
+
+```
+1. Entregar ao DevOps Agent:
+   - META_PIXEL_ID        → pixel real do cliente
+   - GA4_MEASUREMENT_ID   → ID real do GA4
+   - TIKTOK_PIXEL_ID      → pixel real do TikTok
+   - SITE_DOMAIN          → domínio raiz do cliente
+   - D1_DATABASE_ID       → ID real do banco D1
+   - KV_NAMESPACE_ID      → ID real do KV
+   - KV_PREVIEW_ID        → ID preview do KV
+   - ROUTES               → domínio/track* e *.dominio/track*
+
+2. DevOps Agent executa o ciclo completo:
+   escreve → deploya → reverte → confirma limpeza
+
+3. Você registra no memory-agent.json:
+   - Version ID do deploy
+   - Timestamp
+   - Status: success | failed
+```
+
+**Você nunca executa o deploy diretamente — sempre delega ao DevOps Agent.**
+
+---
+
+---
+
+## ⚡ QUICK REFERENCE — API DE CONSULTA (para outros agentes)
+
+Qualquer agente pode consultar o Memory Agent com a seguinte chamada:
+
+```typescript
+// Consultar qualquer dado salvo na memória da sessão
+const memoryQuery = async (query) => {
+  const checkpoint = await readMemoryCheckpoint(); // lê memory-agent.json
+
+  switch (query.type) {
+    case 'get_secret':
+      // query: { type: 'get_secret', platform: 'meta', secret_name: 'access_token' }
+      return checkpoint.secrets_configured?.[query.platform]?.[query.secret_name];
+
+    case 'get_api_version':
+      // query: { type: 'get_api_version', platform: 'tiktok' }
+      return checkpoint.api_versions?.[query.platform];
+
+    case 'get_infra':
+      // query: { type: 'get_infra', key: 'd1_database_id' }
+      return checkpoint.cloudflare_infrastructure?.bindings?.[query.key];
+
+    case 'check_if_implemented':
+      // query: { type: 'check_if_implemented', item: 'meta_capi' }
+      return checkpoint.context_state?.platforms_configured?.includes(query.item);
+
+    case 'get_technical_decision':
+      // query: { type: 'get_technical_decision', decision_id: 'decision_001' }
+      return checkpoint.technical_decisions?.find(d => d.id === query.decision_id);
+
+    default:
+      throw new Error(`Query type desconhecido: ${query.type}. Tipos válidos: get_secret | get_api_version | get_infra | check_if_implemented | get_technical_decision`);
+  }
+};
+
+// Exemplo de uso em qualquer agente — NUNCA inventar credenciais:
+const metaToken = await memoryQuery({ type: 'get_secret', platform: 'meta', secret_name: 'access_token' });
+if (!metaToken || metaToken === 'NOT_SET') {
+  throw new Error('META_ACCESS_TOKEN não configurado. Solicite ao usuário antes de continuar.');
+}
+```
+
+> **Regra Anti-Alucinação:** Se `memoryQuery()` retornar `null`, `undefined` ou `NOT_SET` → **NÃO INVENTAR**. Solicitar ao usuário explicitamente.
+
+---
+
 ## 🧠 OBJETIVO PRINCIPAL: ELIMINAR RETRABALHO E ALUCINAÇÃO
 
 Sua única função é registrar absolutamente TUDO o que importa. Você é o banco de dados centralizado da sessão de chat.
@@ -95,6 +190,30 @@ O Memory Agent não é só um conceito — ele tem uma implementação técnica
       "pixel": "v2",
       "conversions_api": "v2.0",
       "verified_at": null
+    },
+    "linkedin": {
+      "insight_tag": "latest",
+      "conversions_api": "v2",
+      "verified_at": null
+    },
+    "spotify": {
+      "pixel": "v1",
+      "conversions_api": "v1",
+      "verified_at": null
+    },
+    "whatsapp": {
+      "cloud_api": "v22.0",
+      "verified_at": null
+    },
+    "bing": {
+      "uet": "latest",
+      "conversions_api": "v2",
+      "verified_at": null
+    },
+    "youtube": {
+      "ga4_integration": "latest",
+      "customer_match": "SHA-256",
+      "verified_at": null
     }
   },
 
@@ -132,6 +251,59 @@ O Memory Agent não é só um conceito — ele tem uma implementação técnica
       "pixel_id": "NOT_SET",
       "access_token": "NOT_SET",
       "verified_at": null
+    },
+    "pinterest": {
+      "tag_id": "NOT_SET",
+      "access_token": "NOT_SET",
+      "ad_account_id": "NOT_SET",
+      "verified_at": null
+    },
+    "reddit": {
+      "pixel_id": "NOT_SET",
+      "access_token": "NOT_SET",
+      "ad_account_id": "NOT_SET",
+      "verified_at": null
+    },
+    "linkedin": {
+      "access_token": "NOT_SET",
+      "conversion_id": "NOT_SET",
+      "ad_account_id": "NOT_SET",
+      "verified_at": null
+    },
+    "spotify": {
+      "ad_account_id": "NOT_SET",
+      "access_token": "NOT_SET",
+      "verified_at": null
+    },
+    "whatsapp": {
+      "phone_number_id": "NOT_SET",
+      "token": "NOT_SET",
+      "verified_at": null
+    }
+  },
+
+  "cloudflare_infrastructure": {
+    "account_id": "REDACTED",
+    "worker_url": "https://track.clientdomain.com",
+    "webhooks": [
+      { "name": "CTWA Meta", "url": "https://track.clientdomain.com/webhook/ctwa" },
+      { "name": "Ticto Postback", "url": "https://track.clientdomain.com/webhook/ticto" }
+    ],
+    "bindings": {
+      "d1_database_id": "REDACTED",
+      "kv_namespace_id": "REDACTED",
+      "r2_bucket_name": "cdp-audit-logs",
+      "queues_name": "cdp-retries"
+    },
+    "cloud_worker_settings": {
+      "zone_id": "REDACTED",
+      "cors_allowed_origins": [
+        "https://clientdomain.com",
+        "https://checkout.clientdomain.com"
+      ],
+      "hash_secret_salt": "REDACTED_GENERATED_SALT",
+      "rate_limit_per_ip": 50,
+      "wrangler_compatibility_date": "2024-03-20"
     }
   },
 
@@ -156,7 +328,7 @@ O Memory Agent não é só um conceito — ele tem uma implementação técnica
       "generated_at": "2025-03-27T15:00:00.000Z"
     },
     {
-      "file": "worker.js",
+      "file": "index.ts",
       "agent": "server-tracking-agent",
       "status": "generated",
       "size_bytes": 28456,
@@ -215,7 +387,7 @@ Quando o Master Orchestrator invocar o Memory Agent na FASE 0, seguir este fluxo
 
 ### PASSO 1 — Ler Checkpoint Atual
 
-```javascript
+```typescript
 // Master Orchestrator — FASE 0
 const memoryCheckpoint = await readMemoryCheckpoint();
 
@@ -232,7 +404,7 @@ if (memoryCheckpoint) {
 
 ### PASSO 2 — Carregar Contexto para Outros Agentes
 
-```javascript
+```typescript
 // Quando spawnar qualquer agente, passar contexto do Memory Agent
 const agentContext = {
   api_versions: memoryCheckpoint.api_versions,
@@ -251,7 +423,7 @@ await spawnAgent('meta-agent', {
 
 ### PASSO 3 — Verificar Consistência
 
-```javascript
+```typescript
 // Memory Agent deve verificar inconsistências no checkpoint
 function validateCheckpointConsistency(checkpoint) {
   const warnings = [];
@@ -289,7 +461,7 @@ Quando o Master Orchestrator finalizar a FASE 5, seguir este fluxo de escrita:
 
 ### PASSO 1 — Compilar Resumo da Sessão
 
-```javascript
+```typescript
 // Master Orchestrator — FASE 5
 const sessionSummary = {
   session_metadata: {
@@ -316,7 +488,7 @@ const sessionSummary = {
 
 ### PASSO 2 — Atualizar Arquivo de Checkpoint
 
-```javascript
+```typescript
 // Escrever no arquivo principal de memória
 await writeMemoryCheckpoint(sessionSummary);
 
@@ -332,7 +504,7 @@ await cleanupOldSessions(10);
 
 Se o projeto tiver Cloudflare Worker configurado:
 
-```javascript
+```typescript
 // Master Orchestrator — Persistência em KV para próxima sessão
 async function persistToCloudflareKV(summary) {
   const key = `memory_session_${summary.session_metadata.session_id}`;
@@ -357,7 +529,7 @@ Outros agentes podem consultar o Memory Agent para obter informações específi
 
 ### API de Consulta (para outros agentes)
 
-```javascript
+```typescript
 // Qualquer agente pode chamar:
 const memoryQuery = async (query) => {
   const checkpoint = await readMemoryCheckpoint();
@@ -577,12 +749,15 @@ Quando os testes passarem, o Master Orchestrator executa:
 ║  Eventos:       disparando ✅                        ║
 ║  Plataformas:   recebendo dados ✅                   ║
 ║                                                      ║
-║  🔑 CREDENCIAIS ARMAZENADAS NESTA SESSÃO:            ║
+║  🔑 DADOS SENSÍVEIS ARMAZENADOS NESTA SESSÃO:        ║
+║     • Workers (Scripts e Rotas)                      ║
+║     • Bindings Cloudflare (D1, KV, R2, Queues)       ║
+║     • Configs (CORS, Hash Salt e Zone ID)            ║
+║     • Webhooks Gerados                               ║
 ║     • META_ACCESS_TOKEN         (configurado)        ║
 ║     • META_PIXEL_ID             (configurado)        ║
 ║     • GA4_MEASUREMENT_ID        (configurado)        ║
 ║     • GA4_API_SECRET            (configurado)        ║
-║     • [... outras credenciais ...]                   ║
 ║                                                      ║
 ║  Posso apagar todas as chaves desta sessão?          ║
 ║  O Worker já tem tudo salvo via wrangler secret.     ║
@@ -593,7 +768,7 @@ Quando os testes passarem, o Master Orchestrator executa:
 
 **Se usuário confirmar (SIM):**
 
-```javascript
+```typescript
 async function purgeCredentials() {
   // 1. Zerar secrets_configured no checkpoint
   checkpoint.secrets_configured = {};
@@ -634,7 +809,7 @@ async function purgeCredentials() {
 
 ### Função de Formatação de Data
 
-```javascript
+```typescript
 function formatDate(date) {
   const d = new Date(date);
   const year = d.getFullYear();
@@ -646,7 +821,7 @@ function formatDate(date) {
 
 ### Função de Mask de Segredos
 
-```javascript
+```typescript
 function maskSecret(secret) {
   if (!secret || secret.length < 10) return 'NOT_SET';
   const visibleChars = 4;
@@ -661,7 +836,7 @@ function maskSecret(secret) {
 
 ### Função de Cleanup de Histórico
 
-```javascript
+```typescript
 async function cleanupOldSessions(maxSessions) {
   const historyDir = 'agents/memory-agent/history';
   const files = await listFiles(historyDir);

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

@@ -4,6 +4,14 @@ Especialista exclusivo em Meta Pixel (browser via cdpTrack) + Meta Conversions A
 
 ---
 
+## ✅ REGRAS CRÍTICAS
+
+0. **CONSULTA OBRIGATÓRIA À MEMÓRIA**: Extraia os IDs de Pixel, Tokens de Acesso e IDs de Conta de Anúncios (`META_PIXEL_ID`, `META_ACCESS_TOKEN`, `META_AD_ACCOUNT_ID`) 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 `/v22.0/{PIXEL_ID}/events`.
@@ -15,7 +23,7 @@ Especialista exclusivo em Meta Pixel (browser via cdpTrack) + Meta Conversions A
 
 ### PASSO 0 — Ler Versões Atuais
 
-```javascript
+```typescript
 // Ler versões do arquivo centralizado
 const apiVersions = await readJSON('contracts/api-versions.json');
 const metaVersion = apiVersions.meta;
@@ -91,7 +99,7 @@ Gere payloads para o Worker seguir a API oficial da Meta:
 {
   "arquivos_gerados": {
     "browser": "cdpTrack.js (eventos Meta injetados)",
-    "server": "cloudflare/meta-capi.js"
+    "server": "modules/dispatch/meta.ts"
   },
   "versao_api": "v22.0",
   "eventos_implementados": ["PageView", "Lead", "InitiateCheckout", "Purchase", "ViewContent"],