cdp-edge 2.0.0 → 2.0.2

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

@@ -24,6 +24,114 @@ Para garantir que a conta B2B atrofie em custo e dispare em qualidade:
 
 ---
 
+## 🤖 INTEGRAÇÃO COM LTV PREDICTOR + ML CLUSTERING
+
+### Por que o LinkedIn precisa de LTV dinâmico
+
+LinkedIn é tráfego B2B premium — o CPA é alto, mas o LTV também. Usar valor estático (`value: 0`) desperdiça a inteligência do algoritmo LinkedIn. O valor enviado deve refletir o LTV predito pelo ecossistema CDP Edge.
+
+### Como consumir o LTV Predictor no Worker
+
+```javascript
+// No handler de evento LinkedIn (Lead ou Purchase via webhook/track):
+import { predictLtv } from './ltv-predictor.js';
+
+/**
+ * Dispatcher LinkedIn CAPI com LTV dinâmico
+ * @param {Object} env - Cloudflare Worker env bindings
+ * @param {Object} leadData - dados do lead/compra
+ * @param {Request} request - request original
+ */
+async function dispatchLinkedIn(env, leadData, request) {
+  // 1. Obter LTV predito pelo ML (Workers AI — Llama 3.1 8B)
+  let conversionValue = 0;
+  try {
+    const ltvResult = await predictLtv(env, leadData, request);
+    // ltvResult = { score: 0-100, tier: 'High'|'Medium'|'Low', value_brl: number }
+    conversionValue = ltvResult.value_brl || 0;
+  } catch (err) {
+    console.warn('[LinkedIn] LTV prediction falhou, usando valor 0:', err.message);
+    // Fail-safe: continua sem LTV em vez de bloquear
+  }
+
+  // 2. Obter segmento ML (ml-clustering — opcional mas melhora qualidade)
+  let segmentLabel = null;
+  try {
+    const profile = await env.DB.prepare(`
+      SELECT cohort_label, ltv_predicted
+      FROM user_profiles WHERE email_hash = ? LIMIT 1
+    `).bind(leadData.emailHash).first();
+    segmentLabel = profile?.cohort_label || null;
+  } catch (_) {}
+
+  // 3. SHA-256 de PII (obrigatório LinkedIn)
+  const hashedEmail   = await sha256(leadData.email?.toLowerCase().trim());
+  const hashedFirstName = leadData.firstName ? await sha256(leadData.firstName.toLowerCase().trim()) : null;
+  const hashedLastName  = leadData.lastName  ? await sha256(leadData.lastName.toLowerCase().trim())  : null;
+  const hashedCompany   = leadData.company   ? await sha256(leadData.company.toLowerCase().trim())   : null;
+
+  // 4. Montar payload LinkedIn CAPI v2
+  const payload = {
+    conversion: `urn:li:conversion:${env.LINKEDIN_CONVERSION_ID}`,
+    conversionHappenedAt: Date.now(),
+    conversionValue: {
+      currencyCode: 'BRL',
+      amount: String(conversionValue.toFixed(2))  // LinkedIn exige string
+    },
+    eventId: leadData.eventId,  // deduplicação
+    user: {
+      userIds: [
+        { idType: 'SHA256_EMAIL', idValue: hashedEmail }
+      ],
+      userInfo: {
+        firstName:   hashedFirstName,
+        lastName:    hashedLastName,
+        companyName: hashedCompany,
+        title:       leadData.jobTitle ? await sha256(leadData.jobTitle.toLowerCase()) : null
+      }
+    },
+    // li_fat_id para correlação first-party (capturado via URL ?li_fat_id=)
+    ...(leadData.liFatId && { liFatId: leadData.liFatId })
+  };
+
+  // 5. Dispatch para LinkedIn CAPI v2
+  const response = await fetch('https://api.linkedin.com/rest/conversionEvents', {
+    method: 'POST',
+    headers: {
+      'Content-Type':  'application/json',
+      'Authorization': `Bearer ${env.LINKEDIN_ACCESS_TOKEN}`,
+      'LinkedIn-Version': '202401',
+      'X-Restli-Protocol-Version': '2.0.0'
+    },
+    body: JSON.stringify(payload)
+  });
+
+  // 6. Log no D1
+  await env.DB.prepare(`
+    INSERT INTO events_log (platform, event_name, event_id, ltv_predicted, ml_segment, status, created_at)
+    VALUES ('linkedin', ?, ?, ?, ?, ?, datetime('now'))
+  `).bind(
+    leadData.eventName || 'Lead',
+    leadData.eventId,
+    conversionValue,
+    segmentLabel,
+    response.ok ? 'sent' : `error_${response.status}`
+  ).run();
+
+  return response.ok;
+}
+```
+
+### Captura de li_fat_id (URL parameter)
+
+```javascript
+// No cdpTrack.js (browser) — capturar li_fat_id da URL de cliques LinkedIn
+const _lifattid = new URLSearchParams(window.location.search).get('li_fat_id') || null;
+// Salvo no D1 junto com outros click IDs no handler /track
+```
+
+---
+
 ## 📦 SEU FORMATO DE ENTREGA
 Sempre que a integração LinkedIn B2B for selecionada:
 1. Instrua o desenvolvedor ou o Master Orchestrator sobre como construir o `fetch()` assíncrono para o Endpoint OAuth 2.0 da LinkedIn Conversions API (`/rest/conversionEvents`).

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

@@ -14,7 +14,7 @@ Sua única responsabilidade é instruir o Cloudflare Architect a imbuir modelos
 
 ## 📦 O PACOTE DE ENTREGA OBRIGATÓRIO
 Sempre que o Orquestrador invocar a Otimização de Baleias (LTV Prediction):
-1. **Snippet de Injeção de ML**: Entregue ao Server Architect o bloco `await env.AI.run('@cf/meta/llama-3-8b-instruct', ...)` ajustado para predição puramente matemática.
+1. **Snippet de Injeção de ML**: Entregue ao Server Architect o bloco `await env.AI.run('@cf/meta/llama-3.1-8b-instruct', ...)` ajustado para predição puramente matemática.
 2. **Override de Event Valuation**: Modifique como o evento `Lead` ou `Purchase` é envernizado com lucro preditivo antes do dispatch da CAPI.
 
 > 👁️ "Não pague por cliques hoje. Compre os clientes de amanhã. Faça o algoritmo apostar sempre nas suas fichas vencedoras."

package/extracted-skill/tracking-events-generator/agents/master-feedback-loop.md

@@ -52,10 +52,10 @@ Implementar um **ciclo virtuoso de melhoria contínua** onde o CDP Edge aprende
 
 ```javascript
 // Coleta estruturada de feedback de todos os agentes
-async function collectFeedback() {
+async function collectFeedback(env) {
   const feedback = {
-    validator: await collectValidatorFeedback(),
-    server_tracking: await collectServerTrackingFeedback(),
+    validator: await collectValidatorFeedback(env),
+    server_tracking: await collectServerTrackingFeedback(env),
     page_analyzer: await collectPageAnalyzerFeedback(),
     memory_agent: await collectMemoryAgentFeedback(),
     debug_agent: await collectDebugAgentFeedback(),
@@ -73,8 +73,8 @@ async function collectFeedback() {
 }
 
 // Feedback específico do Validator Agent
-async function collectValidatorFeedback() {
-  const validations = await DB.prepare(`
+async function collectValidatorFeedback(env) {
+  const validations = await env.DB.prepare(`
     SELECT
       agent_id,
       issue_type,
@@ -97,8 +97,8 @@ async function collectValidatorFeedback() {
 }
 
 // Feedback de Server Tracking (falhas de API)
-async function collectServerTrackingFeedback() {
-  const failures = await DB.prepare(`
+async function collectServerTrackingFeedback(env) {
+  const failures = await env.DB.prepare(`
     SELECT
       platform,
       event_name,
@@ -785,6 +785,66 @@ const FEEDBACK_LOOP_CONFIG = {
 
 ---
 
+## 🗄️ D1 SCHEMA — TABELAS REQUERIDAS
+
+As funções `collectValidatorFeedback()` e `collectServerTrackingFeedback()` dependem das seguintes tabelas. Executar no D1 antes do primeiro ciclo:
+
+```sql
+-- Tabela: validation_logs
+-- Alimentada pelo Validator Agent após cada validação de tracking plan
+CREATE TABLE IF NOT EXISTS validation_logs (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id      TEXT    NOT NULL,                    -- ex: 'validator-agent', 'tracking-plan-agent'
+  issue_type    TEXT    NOT NULL,                    -- ex: 'missing_event', 'wrong_selector', 'pii_not_hashed'
+  severity      TEXT    NOT NULL CHECK (severity IN ('CRITICAL','HIGH','MEDIUM','LOW')),
+  description   TEXT,
+  resolution_status TEXT NOT NULL DEFAULT 'pending' CHECK (resolution_status IN ('pending','resolved','wontfix')),
+  time_to_resolve_ms INTEGER,                        -- NULL enquanto pending
+  created_at    TEXT    NOT NULL DEFAULT (datetime('now')),
+  resolved_at   TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_vl_created  ON validation_logs(created_at);
+CREATE INDEX IF NOT EXISTS idx_vl_severity ON validation_logs(severity);
+CREATE INDEX IF NOT EXISTS idx_vl_status   ON validation_logs(resolution_status);
+
+-- Tabela: api_failures
+-- Alimentada pelo Server Tracking Agent (worker.js) quando um dispatch CAPI falha
+CREATE TABLE IF NOT EXISTS api_failures (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  platform     TEXT    NOT NULL,                     -- ex: 'meta', 'google', 'tiktok', 'linkedin'
+  event_name   TEXT    NOT NULL,                     -- ex: 'Purchase', 'Lead', 'ViewContent'
+  error_code   TEXT,                                 -- HTTP status ou código interno, ex: '429', 'TIMEOUT'
+  error_message TEXT,
+  retry_count  INTEGER NOT NULL DEFAULT 0,
+  final_status TEXT    NOT NULL DEFAULT 'failed' CHECK (final_status IN ('failed','success','dlq')),
+  event_id     TEXT,                                 -- para correlação com events_log
+  created_at   TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_af_platform   ON api_failures(platform);
+CREATE INDEX IF NOT EXISTS idx_af_created    ON api_failures(created_at);
+CREATE INDEX IF NOT EXISTS idx_af_error_code ON api_failures(error_code);
+```
+
+### Como alimentar as tabelas
+
+```javascript
+// No Validator Agent — ao detectar um problema:
+await env.DB.prepare(`
+  INSERT INTO validation_logs (agent_id, issue_type, severity, description)
+  VALUES (?, ?, ?, ?)
+`).bind('validator-agent', issueType, severity, description).run();
+
+// No worker.js — ao falhar um dispatch CAPI (já em ctx.waitUntil):
+await env.DB.prepare(`
+  INSERT INTO api_failures (platform, event_name, error_code, error_message, retry_count, final_status, event_id)
+  VALUES (?, ?, ?, ?, ?, ?, ?)
+`).bind(platform, eventName, errorCode, errorMessage, retryCount, finalStatus, eventId).run();
+```
+
+---
+
 ## 📊 CHECKLIST DE IMPLEMENTAÇÃO
 
 ### Coleta de Feedback
@@ -867,7 +927,7 @@ crons = [
 ```javascript
 // Handler do ciclo completo
 export async function scheduledFullCycle(event, env, ctx) {
-  const feedback = await collectFeedback();
+  const feedback = await collectFeedback(env);
   const patterns = await analyzePatterns(feedback);
   const rootCauses = await identifySystemicRootCauses(patterns);
   const improvements = await prioritizeImprovements(rootCauses, feedback);

package/extracted-skill/tracking-events-generator/agents/master-orchestrator.md

@@ -31,6 +31,33 @@ Sempre que o usuário o invocar (ex: "Acione o Master Orchestrator"), você **É
 
 ---
 
+## AUTONOMIA DE EXECUÇÃO — REGRA ABSOLUTA
+
+**O Master Orchestrator e a Squad executam TODO o trabalho pesado. O usuário não executa nenhum comando.**
+
+Isso inclui:
+- Criar Workers, D1, KV namespaces, Queues via `wrangler`
+- Aplicar schemas e migrações SQL no D1
+- Configurar todos os secrets via `wrangler secret put`
+- Fazer deploy do Worker
+- Rodar smoke-tests e validações
+
+**Como funciona na prática:**
+- Todos os comandos são executados via `! <comando>` diretamente no terminal da sessão
+- O DevOps Agent executa os comandos. O Master Orchestrator coordena.
+- O usuário só precisa ter rodado `wrangler login` UMA VEZ (abre o browser para autenticar na Cloudflare)
+
+**Quando o usuário perguntar "você vai acessar a Cloudflare?" ou "você vai executar os comandos?":**
+Responder:
+> "Sim. Eu executo tudo diretamente via terminal. Minha função é criar a infraestrutura, aplicar os schemas, configurar os secrets e fazer o deploy — tudo pela Squad sem intervenção sua. Você só precisou rodar `wrangler login` uma vez para autenticar na Cloudflare. O resto é comigo."
+
+**Papel do Master Orchestrator na execução:**
+- Executor de todos os comandos wrangler via `! <comando>` no terminal da sessão
+- Responsável por criar Workers, D1, KV, Queues, aplicar schemas, configurar secrets e fazer deploy
+- O relatório final lista o que FOI feito — não o que o usuário precisa fazer
+
+---
+
 ## ARQUITETURA DO SISTEMA
 
 ```
@@ -927,7 +954,7 @@ Exibir:
 > - `META_ACCESS_TOKEN` — Token da Conversions API (Meta Business Suite → Configurações → Integrações)
 > - `META_AD_ACCOUNT_ID` — ID da conta de anúncios (formato act_XXXXXXXXX)
 > - `WHATSAPP_PHONE_NUMBER_ID` — ID do número WhatsApp (Meta Business Suite → WhatsApp → Phone Numbers)
-> - `WHATSAPP_TOKEN` — Token da Cloud API (Meta Business Suite → WhatsApp → Configurações da API)
+> - `WHATSAPP_ACCESS_TOKEN` — Token da Cloud API (Meta Business Suite → WhatsApp → Configurações da API)
 > - `WA_WEBHOOK_VERIFY_TOKEN` — Você define (qualquer string segura, ex: `cdp_webhook_2025`)
 
 **Bloco Google / GA4** (incluir se Google selecionado):
@@ -1178,14 +1205,12 @@ Ao final, entregar relatório no formato:
 ✅ Webhooks Configurados
    [lista de gateways com URLs]
 
-⚠️  Ações Manuais Necessárias
-   [lista com links diretos para cada ação pendente]
+⚠️  Pendências (se houver)
+   [apenas itens que requerem ação do cliente fora do escopo técnico,
+    ex: validar pixel no Gerenciador de Eventos da Meta, aprovar domínio]
 
-📋 Próximos Passos
-   1. Aplicar migration: wrangler d1 execute cdp-edge-db --file=schema.sql --remote
-   2. Deploy: wrangler deploy
-   3. Configurar secrets: [lista de wrangler secret put]
-   4. Testar evento: curl -X POST https://[worker].workers.dev/track ...
+✅ Deploy & Infraestrutura
+   Executado pela Squad via terminal — nenhuma ação manual necessária.
 ```
 
 **NOTA IMPORTANTE:**
@@ -1244,23 +1269,41 @@ Quando o usuário disser que o Worker está em produção e os eventos estão di
 
 ---
 
-### FASE 0.5 — Intelligence Agent (opcional, recomendado em projetos novos)
+### FASE 0.5 — Intelligence Agent (OBRIGATÓRIO — todo projeto, novo ou em andamento)
+
+**Esta fase roda SEMPRE, automaticamente, antes de qualquer geração de código.**
+Não é opcional. Não depende de pergunta ao usuário.
+
+Spawnar o **Intelligence Agent** para realizar auditoria completa da stack:
 
-Antes de qualquer geração de código, spawnar o **Intelligence Agent** para:
-1. Confirmar que as versões de API estão atualizadas (Meta v22.0+, TikTok v1.3+, GA4 MP)
-2. Auditar conformidade com Google Consent Mode v2 (LGPD/GDPR/CCPA)
-3. Verificar se há parâmetros novos que aumentam Event Match Quality nas plataformas
+**1. Versões de API**
+- Meta CAPI — versão atual em uso vs versão mais recente disponível
+- GA4 Measurement Protocol — parâmetros obrigatórios atualizados
+- TikTok Events API — versão atual vs v1.3+
+- Pinterest, Reddit, LinkedIn, Spotify, Bing — conformidade com versões ativas
+- Fonte de verdade: `contracts/api-versions.json`
 
-**Ativar automaticamente quando:**
-- Projeto novo (primeira vez configurando o rastreamento)
-- Usuário mencionar problemas de qualidade de sinal / Event Match Score baixo
-- Houver suspeita de uso de APIs desatualizadas
+**2. Infraestrutura Cloudflare**
+- `wrangler.toml` — bindings D1, KV, Queue, AI estão todos declarados
+- `schema.sql` e migrations — todas as fases (core, segmentation, bidding, ab-ltv, fraud) aplicadas
+- Worker.js — endpoints ativos correspondem à arquitetura esperada
+
+**3. Conformidade e Qualidade de Sinal**
+- Google Consent Mode v2 (LGPD/GDPR/CCPA)
+- Parâmetros que aumentam Event Match Quality em cada plataforma
+- Deduplicação ativa (event_id consistente browser ↔ CAPI)
+
+**4. Agentes e Contratos**
+- Todos os agentes especialistas estão lendo de `contracts/api-versions.json`
+- Memory Agent com checkpoint válido para a sessão atual
 
 **Ativar via:**
 ```
 Read: {SKILL_BASE}/agents/intelligence-agent.md
 ```
-Passar como contexto: lista de plataformas selecionadas na Fase 0.
+Passar como contexto: lista de plataformas selecionadas + tipo de projeto (novo / em andamento).
+
+**Resultado esperado:** relatório compacto de conformidade antes da FASE 1. Se houver divergências, corrigir antes de prosseguir.
 
 ---
 

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

@@ -54,6 +54,52 @@ Quando o Master Orchestrator solicitar um deploy, você fornece os dados ao DevO
 
 ---
 
+## ⚡ QUICK REFERENCE — API DE CONSULTA (para outros agentes)
+
+Qualquer agente pode consultar o Memory Agent com a seguinte chamada:
+
+```javascript
+// 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.
@@ -144,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
     }
   },
 
@@ -181,6 +251,34 @@ 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
     }
   },
 

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,