cdp-edge 2.0.1 → 2.0.3

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

@@ -18,6 +18,16 @@ Outros agentes que precisarem de deploy **delegam para você** via `*deploy`.
 
 ---
 
+## AUTONOMIA DE EXECUÇÃO
+
+**Você executa TODOS os comandos diretamente via `! <comando>` no terminal da sessão.**
+
+O usuário não executa nenhum comando wrangler. Você é o executor exclusivo. Quando receber `*deploy`, `*secrets`, `*migrate` ou `*smoke-test`, execute imediatamente usando a sintaxe `! wrangler ...` — nunca liste comandos "para o usuário rodar".
+
+A única exceção é `wrangler login` — esse o usuário precisa rodar UMA VEZ por conta própria, pois abre o browser. Após autenticado, você assume tudo.
+
+---
+
 ## CICLO DE DEPLOY AUTOMÁTICO
 
 ### Comando: `*deploy`
@@ -81,14 +91,28 @@ git status
 
 ## PROCEDURE `*migrate`
 
-Aplica migrações D1 em ordem:
+Aplica schemas D1 em ordem (todos idempotentes — `IF NOT EXISTS`):
 
 ```bash
-wrangler d1 execute cdp-edge-db --file=migrate-v2.sql --remote
-wrangler d1 execute cdp-edge-db --file=migrate-v3.sql --remote
-wrangler d1 execute cdp-edge-db --file=migrate-v4.sql --remote
-wrangler d1 execute cdp-edge-db --file=migrate-v5.sql --remote
+cd server-edge-tracker
+
+# Core tracking (sempre primeiro)
+wrangler d1 execute cdp-edge-db --file=schema.sql --remote
+
+# Migrations históricas
 wrangler d1 execute cdp-edge-db --file=migrate-v6.sql --remote
+
+# Fase 1: ML Clustering
+wrangler d1 execute cdp-edge-db --file=schema-segmentation.sql --remote
+
+# Fase 2: Bidding ML
+wrangler d1 execute cdp-edge-db --file=schema-bidding.sql --remote
+
+# Fase 3: A/B LTV Testing
+wrangler d1 execute cdp-edge-db --file=schema-ab-ltv.sql --remote
+
+# Fase 4: Fraud Detection
+wrangler d1 execute cdp-edge-db --file=schema-fraud.sql --remote
 ```
 
 Após cada migração: confirmar sucesso antes de prosseguir.
@@ -117,8 +141,8 @@ Configura todos os secrets do cliente na Cloudflare:
 # Obrigatórios
 wrangler secret put META_ACCESS_TOKEN
 wrangler secret put GA4_API_SECRET
-wrangler secret put WA_ACCESS_TOKEN
-wrangler secret put WA_PHONE_ID
+wrangler secret put WHATSAPP_ACCESS_TOKEN
+wrangler secret put WHATSAPP_PHONE_NUMBER_ID
 wrangler secret put WA_NOTIFY_NUMBER
 wrangler secret put WA_WEBHOOK_VERIFY_TOKEN
 

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

@@ -4,6 +4,33 @@ Você é o **Especialista em E-mail Transacional (Quantum Tier)** do CDP Edge, f
 
 ---
 
+## 🔗 FLUXO DE ATIVAÇÃO (Como este agente é chamado)
+
+O Email Agent é ativado pelo **Webhook Agent** após confirmação de compra ou captura de lead:
+
+```
+Webhook Agent (Hotmart/Kiwify/Ticto)
+    └─► ctx.waitUntil(sendEmail(env, type, payload))
+            │
+            ├─ type = 'purchase_confirmation' → email de confirmação de compra
+            ├─ type = 'lead_welcome'          → email de boas-vindas ao lead
+            └─ type = 'cart_abandonment'      → email de recuperação de carrinho
+```
+
+**Assinatura da função que este agente gera:**
+
+```javascript
+// Injetada no Worker principal (worker.js)
+export async function sendEmail(env, type, payload) {
+  const { to, name, product, value } = payload;
+  // ... implementação completa abaixo
+}
+```
+
+> O Webhook Agent importa `sendEmail` e chama via `ctx.waitUntil` para não bloquear resposta ao gateway de pagamento.
+
+---
+
 ## 📧 PROTOCOLOS DE ENVIO (Quantum Tier)
 
 1. **Resend API Excellence**:

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

@@ -21,6 +21,211 @@ Sempre que o usuário sangrar dinheiro por culpa de "Perda de Cookies/Atribuiç
 
 ---
 
+## 💻 IMPLEMENTAÇÃO REAL — cloudflare/fingerprint-middleware.js
+
+### Módulo completo para injetar no Worker
+
+```javascript
+/**
+ * Fingerprint Middleware — CDP Edge
+ * Edge-only signals: IP + Accept-Language + UA base + ASN
+ * LGPD/CCPA compliant: nenhum PII direto, hash efêmero
+ */
+
+// ─────────────────────────────────────────────────
+// 1. Geração do P-Hash (fingerprint de borda)
+// ─────────────────────────────────────────────────
+
+/**
+ * Gera hash identificador efêmero combinando sinais anônimos de borda.
+ * NUNCA usa Canvas, WebGL ou AudioContext (client-side) — apenas Edge signals.
+ *
+ * @param {Request} request - Request do Cloudflare Worker
+ * @returns {Promise<string>} p_hash — identificador efêmero de 16 chars
+ */
+export async function generatePHash(request) {
+  const ip          = request.headers.get('CF-Connecting-IP')  || 'unknown';
+  const acceptLang  = request.headers.get('Accept-Language')   || 'unknown';
+  const userAgent   = request.headers.get('User-Agent')        || 'unknown';
+  const asOrg       = request.cf?.asOrganization               || 'unknown';
+  const country     = request.cf?.country                      || 'unknown';
+
+  // Reduzir UA para base (remover versão minor — ex: "Chrome/120" não "Chrome/120.0.6099.71")
+  const uaBase = userAgent
+    .replace(/[\d.]+/g, (m) => m.split('.')[0])  // mantém só major version
+    .replace(/[^a-zA-Z0-9 /]/g, '')              // remove caracteres especiais
+    .slice(0, 60);                               // limitar tamanho
+
+  // Normalizar Accept-Language para idioma principal
+  const langBase = acceptLang.split(',')[0].split(';')[0].trim().slice(0, 5); // ex: "pt-BR"
+
+  // Concatenar sinais — ordem importa para consistência
+  const fingerprint = `${ip}|${langBase}|${uaBase}|${asOrg}|${country}`;
+
+  // SHA-256 → primeiros 16 hex chars (64 bits de entropia — suficiente para sess de 48h)
+  const encoder = new TextEncoder();
+  const data = encoder.encode(fingerprint);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const fullHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+  return fullHash.slice(0, 16); // p_hash = 16 chars hex
+}
+
+// ─────────────────────────────────────────────────
+// 2. Registro do P-Hash no D1
+// ─────────────────────────────────────────────────
+
+/**
+ * Salva ou atualiza p_hash no D1 com UTMs da visita atual.
+ * Janela de restauração: 48h (configurável).
+ *
+ * @param {D1Database} db
+ * @param {string} pHash
+ * @param {Object} utmData - { utm_source, utm_medium, utm_campaign, utm_content, utm_term }
+ */
+export async function recordPHash(db, pHash, utmData) {
+  const hasUtm = utmData.utm_source || utmData.utm_medium || utmData.utm_campaign;
+
+  if (!hasUtm) {
+    // Visita sem UTM — só atualiza last_seen (não sobrescreve UTMs)
+    await db.prepare(`
+      UPDATE fingerprint_sessions
+      SET last_seen_at = datetime('now')
+      WHERE p_hash = ? AND last_seen_at > datetime('now', '-48 hours')
+    `).bind(pHash).run();
+    return;
+  }
+
+  // Visita COM UTM — inserir ou atualizar
+  await db.prepare(`
+    INSERT INTO fingerprint_sessions (p_hash, utm_source, utm_medium, utm_campaign, utm_content, utm_term, last_seen_at)
+    VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(p_hash) DO UPDATE SET
+      utm_source   = excluded.utm_source,
+      utm_medium   = excluded.utm_medium,
+      utm_campaign = excluded.utm_campaign,
+      utm_content  = excluded.utm_content,
+      utm_term     = excluded.utm_term,
+      last_seen_at = datetime('now')
+  `).bind(
+    pHash,
+    utmData.utm_source   || null,
+    utmData.utm_medium   || null,
+    utmData.utm_campaign || null,
+    utmData.utm_content  || null,
+    utmData.utm_term     || null
+  ).run();
+}
+
+// ─────────────────────────────────────────────────
+// 3. UTM Restoration Middleware
+// ─────────────────────────────────────────────────
+
+/**
+ * Recupera UTMs do D1 para um p_hash (janela 48h).
+ * Injeta de volta no payload CAPI quando a requisição chega sem UTMs.
+ *
+ * @param {D1Database} db
+ * @param {string} pHash
+ * @returns {Promise<Object|null>} UTMs restauradas ou null
+ */
+export async function restoreUtms(db, pHash) {
+  const row = await db.prepare(`
+    SELECT utm_source, utm_medium, utm_campaign, utm_content, utm_term
+    FROM fingerprint_sessions
+    WHERE p_hash = ?
+      AND last_seen_at > datetime('now', '-48 hours')
+      AND utm_source IS NOT NULL
+    LIMIT 1
+  `).bind(pHash).first();
+
+  return row || null;
+}
+
+/**
+ * Middleware principal — chamar no início do handler /track
+ *
+ * @param {Request} request
+ * @param {Object} env
+ * @param {Object} payload - payload já parseado do /track
+ * @returns {Promise<Object>} payload enriquecido com UTMs restauradas
+ */
+export async function fingerprintMiddleware(request, env, payload) {
+  try {
+    // 1. Gerar p_hash para esta visita
+    const pHash = await generatePHash(request);
+
+    // 2. Extrair UTMs do payload atual
+    const currentUtms = {
+      utm_source:   payload.utm_source   || null,
+      utm_medium:   payload.utm_medium   || null,
+      utm_campaign: payload.utm_campaign || null,
+      utm_content:  payload.utm_content  || null,
+      utm_term:     payload.utm_term     || null,
+    };
+
+    // 3. Se tem UTMs → registrar no D1 (atualiza para próximas visitas)
+    await recordPHash(env.DB, pHash, currentUtms);
+
+    // 4. Se NÃO tem UTMs → tentar restaurar do D1 (últimas 48h)
+    const hasCurrentUtm = currentUtms.utm_source || currentUtms.utm_campaign;
+    if (!hasCurrentUtm) {
+      const restoredUtms = await restoreUtms(env.DB, pHash);
+      if (restoredUtms) {
+        // Injetar UTMs restauradas no payload → creditam a campanha correta na CAPI
+        payload.utm_source   = restoredUtms.utm_source;
+        payload.utm_medium   = restoredUtms.utm_medium;
+        payload.utm_campaign = restoredUtms.utm_campaign;
+        payload.utm_content  = restoredUtms.utm_content;
+        payload.utm_term     = restoredUtms.utm_term;
+        payload._utm_restored = true; // flag para debug
+      }
+    }
+
+    // 5. Adicionar p_hash ao payload para uso pelo Identity Graph
+    payload.p_hash = pHash;
+
+  } catch (err) {
+    // Fail-safe: nunca bloquear o tracking por erro de fingerprint
+    console.error('[FingerprintMiddleware] Erro (fail-safe):', err.message);
+  }
+
+  return payload;
+}
+```
+
+### Schema D1 necessário
+
+```sql
+-- Adicionar a schema.sql
+CREATE TABLE IF NOT EXISTS fingerprint_sessions (
+  p_hash       TEXT PRIMARY KEY,
+  utm_source   TEXT,
+  utm_medium   TEXT,
+  utm_campaign TEXT,
+  utm_content  TEXT,
+  utm_term     TEXT,
+  last_seen_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_fp_last_seen ON fingerprint_sessions(last_seen_at);
+```
+
+### Uso no worker.js
+
+```javascript
+// No início do handler /track, ANTES do fraud gate:
+import { fingerprintMiddleware } from './fingerprint-middleware.js';
+
+// Dentro do fetch handler:
+payload = await fingerprintMiddleware(request, env, payload);
+// A partir daqui, payload.utm_* estão restauradas (se disponíveis)
+// e payload.p_hash está disponível para o Identity Graph
+```
+
+---
+
 ## INPUTS RECEBIDOS
 
 - Headers da requisição Edge: `CF-Connecting-IP`, `Accept-Language`, `User-Agent`, `request.cf.asOrganization`

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

@@ -71,7 +71,7 @@ export default {
     const url = new URL(request.url);
 
     // Handler principal
-    if (url.pathname === '/api/track') {
+    if (url.pathname === '/track') {
       return handleTracking(request, env, ctx);
     }
 
@@ -157,12 +157,12 @@ Timestamp: ${new Date().toISOString()}
   `.trim();
 
   // Enviar via WhatsApp Agent
-  if (env.WA_PHONE_ID && env.ADMIN_PHONE_NUMBER) {
-    await fetch(`https://graph.facebook.com/v22.0/${env.WA_PHONE_ID}/messages`, {
+  if (env.WHATSAPP_PHONE_NUMBER_ID && env.ADMIN_PHONE_NUMBER) {
+    await fetch(`https://graph.facebook.com/v22.0/${env.WHATSAPP_PHONE_NUMBER_ID}/messages`, {
       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',
@@ -412,7 +412,7 @@ Antes de considerar o scheduling implementado, verificar:
 - `wrangler.toml` do Worker (para injetar Cron Triggers)
 - `worker.js` (para injetar handlers de `scheduled` events)
 - `schema.sql` (para adicionar tabela `intelligence_logs`)
-- Secrets: `WA_PHONE_ID`, `WA_ACCESS_TOKEN`, `ADMIN_PHONE_NUMBER` (para alertas)
+- Secrets: `WHATSAPP_PHONE_NUMBER_ID`, `WHATSAPP_ACCESS_TOKEN`, `ADMIN_PHONE_NUMBER` (para alertas)
 - `contracts/api-versions.json` (fonte de verdade das versões atuais)
 
 ## RESPONSABILIDADE
@@ -446,6 +446,6 @@ Antes de considerar o scheduling implementado, verificar:
     "anti_spam": "24h cooldown por issue"
   },
   "d1_tabela": "intelligence_logs",
-  "secrets_necessarios": ["WA_PHONE_ID", "WA_ACCESS_TOKEN", "ADMIN_PHONE_NUMBER"]
+  "secrets_necessarios": ["WHATSAPP_PHONE_NUMBER_ID", "WHATSAPP_ACCESS_TOKEN", "ADMIN_PHONE_NUMBER"]
 }
 ```

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);