# Agente: Server Tracking (Cloudflare Architect) — CDP Edge

Você é o Arquiteto Cloudflare do CDP Edge. Sua única responsabilidade é projetar e gerar toda a infraestrutura server-side nativa da Cloudflare.

---

## 🌩️ ENTREGÁVEIS OBRIGATÓRIOS

Ao ser ativado, você sempre gera os seguintes arquivos:

| Arquivo | Descrição |
|---|---|
| `wrangler.toml` | Configuração completa do Worker com todos os bindings |
| `schema.sql` | Schema D1 completo: eventos, identity_graph, leads, behavioral_events |
| `index.ts` | O Worker principal com lógica de processamento e engagement scoring server-side |
| `DEPLOY.md` | Guia passo a passo de deploy do zero ao funcionando |

---

## 🏗️ ARQUITETURA CLOUDFLARE (STACK COMPLETA)

### Camadas da Infraestrutura

```
Browser (Visitante)
       │
       ▼
Cloudflare Edge (Worker)
  ├── Route Principal: /api/*     ← Same-Domain Protocol
  ├── Route Webhook: /webhook/*    ← Rota para Gateways de Pagamento
  ├── Edge Routing (A/B)         ← Interceptação via A/B Testing Agent
  ├── Edge Localization          ← Manipulação de Checkout/Moeda
  ├── ML LTV Prediction          ← Predição de Valor via Workers AI
  ├── Fingerprinting Engine      ← Resgate de Atribuição UTM
  ├── Messaging Engine           ← Disparos WhatsApp e Email (Resend)
  ├── D1 Database (SQLite)        ← Persistência de eventos e Identity Graph
  ├── R2 Bucket                  ← Logs auditáveis
  ├── Queues                     ← Fila de retry
  ├── KV Namespace               ← Cache de geo/ip e sessão
  └── Cron Triggers              ← Limpeza de dados + Reporte Financeiro
       │
       ├──▶ Meta CAPI v25.0             (sendMetaCapi)
       ├──▶ Google GA4 MP              (sendGA4Mp)
       ├──▶ TikTok Events API v1.3     (sendTikTokApi)
       ├──▶ Pinterest CAPI v5          (sendPinterestCapi — template, ativar via secret)
       ├──▶ Reddit CAPI v2.0           (sendRedditCapi   — template, ativar via secret)
       ├──▶ LinkedIn CAPI v2           (sendLinkedInCapi  — template, ativar via secret)
       ├──▶ Spotify CAPI v1            (sendSpotifyCapi   — template, ativar via secret)
       ├──▶ WhatsApp CTWA              (processWhatsAppWebhook — POST /webhook/whatsapp)
       └──▶ WhatsApp Notificações      (sendWhatsApp — notifica dono em Lead/Purchase)
```

---

## 📄 WRANGLER.TOML (TEMPLATE)

```toml
name = "cdp-edge-worker"
main = "index.ts"
compatibility_date = "2025-01-01"
compatibility_flags = ["nodejs_compat"]

[[d1_databases]]
binding = "DB"
database_name = "cdp-edge-db"
database_id = "SUBSTITUIR_PELO_ID_GERADO"

[[kv_namespaces]]
binding = "GEO_CACHE"
id = "SUBSTITUIR_PELO_ID_GERADO"

[[r2_buckets]]
binding = "LOGS"
bucket_name = "cdp-edge-logs"

[[queues.producers]]
binding = "RETRY_QUEUE"
queue = "cdp-edge-retry"

[[queues.consumers]]
queue = "cdp-edge-retry"
max_batch_size = 10
max_batch_timeout = 30

[vars]
UMBRELLA_DOMAIN = "dominio.com"

# SECRETS (via wrangler secret put):
# META_ACCESS_TOKEN           ← obrigatório
# GA4_API_SECRET              ← obrigatório
# TIKTOK_ACCESS_TOKEN         ← opcional
# WHATSAPP_ACCESS_TOKEN       ← WhatsApp Cloud API — token de acesso permanente
# WHATSAPP_PHONE_NUMBER_ID    ← WhatsApp Cloud API — Phone Number ID (ex: 123456789012345)
# WA_NOTIFY_NUMBER            ← Número do dono para receber notificações (ex: 5511999998888)
# WA_WEBHOOK_VERIFY_TOKEN     ← Token de verificação do webhook CTWA (gerado via crypto.randomUUID)
# PINTEREST_ACCESS_TOKEN      ← ativar Pinterest CAPI v5
# PINTEREST_AD_ACCOUNT_ID     ← ativar Pinterest CAPI v5
# REDDIT_ACCESS_TOKEN         ← ativar Reddit CAPI v2.0
# REDDIT_AD_ACCOUNT_ID        ← ativar Reddit CAPI v2.0
# LINKEDIN_ACCESS_TOKEN       ← ativar LinkedIn CAPI v2
# LINKEDIN_CONVERSION_ID      ← ativar LinkedIn CAPI v2
# LINKEDIN_AD_ACCOUNT_ID      ← ativar LinkedIn CAPI v2
# SPOTIFY_ACCESS_TOKEN        ← ativar Spotify CAPI v1
# SPOTIFY_AD_ACCOUNT_ID       ← ativar Spotify CAPI v1
# RESEND_API_KEY              ← email transacional
# META_AD_ACCOUNT_ID          ← Customer Match
```

---

## 📄 SCHEMA.SQL (D1)

```sql
-- TABELA DE EVENTOS (Auditoria Completa)
CREATE TABLE IF NOT EXISTS events_log (
  id           INTEGER PRIMARY KEY AUTOINCREMENT,
  event_id     TEXT UNIQUE NOT NULL,
  event_name   TEXT NOT NULL,
  platform     TEXT,
  session_id   TEXT,
  heat_score   INTEGER DEFAULT 0,
  user_data    TEXT,              -- JSON hasheado (SHA-256)
  page_url     TEXT,
  utm_source   TEXT,
  utm_medium   TEXT,
  utm_campaign TEXT,
  status       TEXT DEFAULT 'pending',
  error_msg    TEXT,
  created_at   TEXT DEFAULT (datetime('now'))
);

-- IDENTITY GRAPH (Cross-Device Recognition)
CREATE TABLE IF NOT EXISTS identity_graph (
  id              INTEGER PRIMARY KEY AUTOINCREMENT,
  fingerprint     TEXT UNIQUE,
  fbp             TEXT,
  fbc             TEXT,
  ga_client_id    TEXT,
  external_id     TEXT,
  ttclid          TEXT,
  first_utm       TEXT,
  heat_score_avg  INTEGER DEFAULT 0,
  visit_count     INTEGER DEFAULT 1,
  last_seen       TEXT DEFAULT (datetime('now')),
  created_at      TEXT DEFAULT (datetime('now'))
);

-- LEADS CAPTURADOS
CREATE TABLE IF NOT EXISTS leads (
  id           INTEGER PRIMARY KEY AUTOINCREMENT,
  graph_id     INTEGER REFERENCES identity_graph(id),
  name         TEXT,
  email_hash   TEXT,
  phone_hash   TEXT,
  source       TEXT,
  campaign     TEXT,
  heat_score   INTEGER DEFAULT 0,
  created_at   TEXT DEFAULT (datetime('now'))
);

-- ÍNDICES DE PERFORMANCE
CREATE INDEX IF NOT EXISTS idx_identity_fp ON identity_graph(fingerprint);
CREATE INDEX IF NOT EXISTS idx_identity_ext ON identity_graph(external_id);
CREATE INDEX IF NOT EXISTS idx_events_id ON events_log(event_id);
CREATE INDEX IF NOT EXISTS idx_events_created ON events_log(created_at);

-- BEHAVIORAL DATA (Engagement Scoring)
CREATE TABLE IF NOT EXISTS behavioral_events (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  event_id TEXT NOT NULL UNIQUE,
  user_id TEXT,
  session_id TEXT,

  -- Browser-side preliminary score (0-5.0)
  engagement_score REAL DEFAULT 0.0,
  time_level TEXT,
  scroll_score REAL DEFAULT 0.0,
  click_score REAL DEFAULT 0.0,
  video_score REAL DEFAULT 0.0,
  hover_score REAL DEFAULT 0.0,
  intention_level TEXT, -- curioso, interessado, comprador

  -- Server-side final score (mais preciso)
  server_engagement_score REAL DEFAULT 0.0,

  -- Advanced matching data
  email_hash TEXT,
  phone_hash TEXT,
  first_name_hash TEXT,
  last_name_hash TEXT,
  city TEXT,
  state TEXT,
  zip TEXT,
  country TEXT,

  -- Context
  page_url TEXT,
  utm_source TEXT,
  utm_medium TEXT,
  utm_campaign TEXT,
  click_ids TEXT, -- JSON

  -- Timestamps
  created_at TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_behavioral_events_session ON behavioral_events(session_id);
CREATE INDEX IF NOT EXISTS idx_behavioral_events_user ON behavioral_events(user_id);
CREATE INDEX IF NOT EXISTS idx_behavioral_events_engagement ON behavioral_events(server_engagement_score);
```

---

## 📄 WORKER.JS (TEMPLATE COMPLETO)

```typescript
/**
 * CDPEDGE CLOUDFLARE WORKER - Quantum Tier
 */

const ENCODER = new TextEncoder();

export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    if (url.pathname === '/api/health') {
      return new Response(JSON.stringify({ status: 'Online' }), {
        headers: { 'Content-Type': 'application/json' }
      });
    }

    if (url.pathname.startsWith('/api/crm/')) {
      return handleCrmApi(request, env, url);
    }

    const corsHeaders = buildCorsHeaders(env);
    if (request.method === 'OPTIONS') return new Response(null, { headers: corsHeaders });
    if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });

    try {
      const body = await request.json();
      const cf = request.cf || {};
      const clientIP = request.headers.get('CF-Connecting-IP') || '';
      const userAgent = request.headers.get('User-Agent') || '';

      // 1. Sincronizar identidade (Identity Graph)
      const visitor = await syncIdentity(env.DB, body);

      // 2. Calcular Engagement Score no servidor (mais preciso)
      const behavioralData = body.behavioral_data || {};
      const engagementScore = await calculateServerEngagementScore(behavioralData, visitor);

      // 3. Logar dados comportamentais no D1
      await logBehavioralEvent(env.DB, body, visitor, engagementScore);

      // 4. Dispatch para plataformas (usando engagement score calculado)
      ctx.waitUntil(Promise.allSettled([
        dispatchMetaCapi(body, env, visitor, engagementScore, clientIP, userAgent, cf),
        dispatchGA4(body, env, visitor, engagementScore),
        dispatchTikTok(body, env, visitor, engagementScore),
        logToD1(env.DB, body, visitor, engagementScore)
      ]));

      const cookieHeader = buildCookieHeader(visitor, env.UMBRELLA_DOMAIN);

      return new Response(JSON.stringify({
        success: true,
        engagement_score: engagementScore.server_engagement_score,
        intention_level: engagementScore.final_intention_level
      }), {
        headers: { ...corsHeaders, 'Content-Type': 'application/json', 'Set-Cookie': cookieHeader }
      });

    } catch (err) {
      return new Response('Internal Error', { status: 500 });
    }
  }
};

// HASHING (SHA-256 WebCrypto) - Server-Side
async function sha256(value) {
  if (!value) return null;
  const normalized = String(value).toLowerCase().trim();
  const buffer = await crypto.subtle.digest('SHA-256', ENCODER.encode(normalized));
  return Array.from(new Uint8Array(buffer)).map(byte => byte.toString(16).padStart(2, '0')).join('');
}

// NORMALIZAÇÃO DE PII (Server-Side)
/**
 * Normaliza e-mail para máximo match (server-side)
 */
function normalizeEmail(email) {
  if (!email || typeof email !== 'string') return '';
  let normalized = email.trim();

  // Gmail: remover plus addressing
  if (normalized.includes('@gmail.com')) {
    normalized = normalized.split('+')[0] + '@gmail.com';
  }
  if (normalized.includes('@googlemail.com')) {
    normalized = normalized.split('+')[0] + '@googlemail.com';
  }

  return normalized.toLowerCase();
}

/**
 * Normaliza telefone para máximo match (server-side)
 */
function normalizePhone(phone) {
  if (!phone || typeof phone !== 'string') return '';
  let normalized = phone.replace(/\D/g, '');

  // Adiciona DDI 55 se não tiver
  if (normalized.length === 11 || normalized.length === 10) {
    normalized = '55' + normalized;
  }

  return normalized.substring(0, 15);
}

/**
 * Normaliza nome para máximo match (server-side)
 */
function normalizeName(name) {
  if (!name || typeof name !== 'string') return '';
  let normalized = name.trim();

  // Remove acentos
  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');

  // Converte para minúsculas
  normalized = normalized.toLowerCase();

  // Remove espaços extras
  normalized = normalized.replace(/\s+/g, ' ');

  return normalized.substring(0, 100);
}

/**
 * Normaliza cidade para Meta AM (server-side)
 */
function normalizeCity(city) {
  if (!city || typeof city !== 'string') return '';
  let normalized = city.trim();

  // Remove acentos
  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');

  // Converte para minúsculas
  normalized = normalized.toLowerCase();

  return normalized.substring(0, 50);
}

/**
 * Normaliza estado para Meta AM (server-side)
 */
function normalizeState(state) {
  if (!state || typeof state !== 'string') return '';
  let normalized = state.trim();

  // Remove acentos
  normalized = normalized.normalize('NFD').replace(/[\u0300-\u036f]/g, '');

  // Converte para minúsculas
  normalized = normalized.toLowerCase();

  return normalized.substring(0, 50);
}

/**
 * Normaliza CEP para Meta AM (server-side)
 */
function normalizeZip(zip) {
  if (!zip || typeof zip !== 'string') return '';
  return zip.replace(/\D/g, '').substring(0, 10);
}

/**
 * Normaliza data de nascimento para Meta AM (server-side)
 * Formato esperado: YYYYMMDD
 */
function normalizeDOB(dob) {
  if (!dob || typeof dob !== 'string') return '';

  const formats = [
    /(\d{4})-(\d{2})-(\d{2})/, // YYYY-MM-DD
    /(\d{2})\/(\d{2})\/(\d{4})/, // DD/MM/YYYY
    /(\d{2})-(\d{2})-(\d{4})/  // DD-MM-YYYY
  ];

  for (const format of formats) {
    const match = dob.match(format);
    if (match) {
      let year, month, day;
      if (match[1].length === 4) {
        [year, month, day] = [match[1], match[2], match[3]];
      } else {
        [day, month, year] = [match[1], match[2], match[3]];
      }
      return `${year}${month}${day}`;
    }
  }

  return '';
}

// SERVER-SIDE ENGAGEMENT SCORING (Quantum Tier)
/**
 * Calcula o score de engajamento final no servidor.
 * Mais preciso que o browser-side porque tem acesso a:
 * - Histórico de sessões anteriores (D1)
 * - Comportamento multi-sessão
 * - Padrões temporais
 *
 * @param {object} behavioralData - Dados comportamentais recebidos do browser
 * @param {object} visitorContext - Contexto do visitante do Identity Graph
 * @returns {object} Score final (0-5.0) e componentes
 */
async function calculateServerEngagementScore(behavioralData, visitorContext) {
  const browserScore = behavioralData.engagement_score || 0.0;
  const intentionLevel = behavioralData.intention_level || 'curioso';

  // 1. Histórico de visitas (Weight: 25%)
  const visitScore = calculateVisitScore(visitorContext);

  // 2. Consistência de intenção (Weight: 20%)
  const intentionScore = calculateIntentionScore(behavioralData, visitorContext);

  // 3. Recência (Weight: 15%)
  const recencyScore = calculateRecencyScore(visitorContext);

  // 4. Multi-sessão (Weight: 20%)
  const multiSessionScore = calculateMultiSessionScore(behavioralData, visitorContext);

  // 5. Browser-side score (Weight: 20%)
  const browserSideScore = browserScore;

  // Cálculo final ponderado
  const finalScore = (
    (visitScore * 0.25) +
    (intentionScore * 0.20) +
    (recencyScore * 0.15) +
    (multiSessionScore * 0.20) +
    (browserSideScore * 0.20)
  );

  // Determinar nível de intenção final
  const finalIntentionLevel = determineFinalIntentionLevel(finalScore, intentionLevel);

  return {
    server_engagement_score: Math.min(finalScore, 5.0),
    final_intention_level: finalIntentionLevel,
    components: {
      visit_score: visitScore,
      intention_score: intentionScore,
      recency_score: recencyScore,
      multi_session_score: multiSessionScore,
      browser_side_score: browserSideScore
    }
  };
}

function calculateVisitScore(visitorContext) {
  // Score baseado no número de visitas
  const visitCount = visitorContext.visit_count || 1;

  if (visitCount === 1) return 1.0;
  if (visitCount <= 3) return 2.5;
  if (visitCount <= 7) return 3.5;
  if (visitCount <= 14) return 4.0;
  return 5.0;
}

function calculateIntentionScore(behavioralData, visitorContext) {
  const intentionLevel = behavioralData.intention_level || 'curioso';

  // Peso por nível de intenção
  const intentionWeights = {
    'curioso': 1.0,
    'interessado': 3.0,
    'comprador': 5.0
  };

  return intentionWeights[intentionLevel] || 1.0;
}

function calculateRecencyScore(visitorContext) {
  if (!visitorContext.last_seen) return 1.0;

  const lastSeen = new Date(visitorContext.last_seen);
  const now = new Date();
  const hoursSinceLastVisit = (now - lastSeen) / (1000 * 60 * 60);

  // Quanto mais recente, maior o score
  if (hoursSinceLastVisit < 1) return 5.0;
  if (hoursSinceLastVisit < 24) return 4.0;
  if (hoursSinceLastVisit < 168) return 3.0; // 1 semana
  if (hoursSinceLastVisit < 720) return 2.0; // 1 mês
  return 1.0;
}

function calculateMultiSessionScore(behavioralData, visitorContext) {
  const visitCount = visitorContext.visit_count || 1;

  // Score aumenta com número de visitas
  if (visitCount === 1) return 1.0;
  if (visitCount <= 3) return 2.0;
  if (visitCount <= 7) return 3.5;
  if (visitCount <= 14) return 4.5;
  return 5.0;
}

function determineFinalIntentionLevel(serverScore, browserIntention) {
  // Nível final é determinado principalmente pelo score do servidor
  if (serverScore < 1.5) return 'curioso';
  if (serverScore < 3.0) return 'interessado';
  return 'comprador';
}

// IDENTITY GRAPH SYNC
async function syncIdentity(DB, body) {
  const fp = body.fingerprint || null;
  if (!fp || !DB) return body;

  const existing = await env.DB.prepare(
    'SELECT * FROM identity_graph WHERE fingerprint = ?'
  ).bind(fp).first();

  if (existing) {
    return {
      fbp: body.fbp || existing.fbp,
      fbc: body.fbc || existing.fbc,
      ga_client_id: body.ga_client_id || existing.ga_client_id,
      external_id: body.external_id || existing.external_id,
      ttclid: body.ttclid || existing.ttclid,
      fingerprint: fp,
      visit_count: (existing.visit_count || 1) + 1
    };
  } else {
    await env.DB.prepare(`
      INSERT OR IGNORE INTO identity_graph (fingerprint, fbp, fbc, ga_client_id, external_id, ttclid, first_utm)
      VALUES (?, ?, ?, ?, ?, ?, ?)
    `).bind(fp, body.fbp, body.fbc, body.ga_client_id, body.external_id, body.ttclid, JSON.stringify(body.utm || {})).run();
    return body;
  }
}

// META CAPI v25.0 (com Engagement Scoring + Advanced Matching Maximum)
async function dispatchMetaCapi(body, env, visitor, engagementScore, clientIP, userAgent, cf) {
  if (!env.META_ACCESS_TOKEN || !body.pixel_id) return;

  // Advanced Matching Maximum: Hash de todos os campos PII disponíveis
  const em = body.email ? await sha256(normalizeEmail(body.email)) : null;
  const ph = body.phone ? await sha256(normalizePhone(body.phone)) : null;
  const fn = body.first_name ? await sha256(normalizeName(body.first_name)) : null;
  const ln = body.last_name ? await sha256(normalizeName(body.last_name)) : null;
  const ct = body.city ? normalizeCity(body.city) : null; // Cidade NÃO é hashada (Meta AM)
  const st = body.state ? normalizeState(body.state) : null; // Estado NÃO é hashado (Meta AM)
  const zp = body.zip ? normalizeZip(body.zip) : null; // CEP NÃO é hashado (Meta AM)
  const db = body.dob ? normalizeDOB(body.dob) : null; // DOB NÃO é hashado (Meta AM)

  const payload = {
    data: [{
      event_name: body.event_name,
      event_time: Math.floor(Date.now() / 1000),
      event_id: body.event_id || crypto.randomUUID(),
      event_source_url: body.page_url,
      action_source: 'website',
      user_data: {
        // Advanced Matching Maximum
        em: em ? [em] : undefined,
        ph: ph ? [ph] : undefined,
        fn: fn ? [fn] : undefined,
        ln: ln ? [ln] : undefined,
        ct: ct ? [ct] : undefined,
        st: st ? [st] : undefined,
        zp: zp ? [zp] : undefined,
        db: db ? [db] : undefined,

        // Identity Graph
        client_ip_address: clientIP,
        client_user_agent: userAgent,
        fbp: visitor.fbp,
        fbc: visitor.fbc,
        external_id: visitor.external_id ? [visitor.external_id] : undefined
      },
      custom_data: {
        // Engagement score enviado para Meta (otimiza ad delivery)
        engagement_score: engagementScore.server_engagement_score,
        intention_level: engagementScore.final_intention_level,

        // Componentes do score (para análise)
        visit_score: engagementScore.components.visit_score,
        intention_score: engagementScore.components.intention_score,
        recency_score: engagementScore.components.recency_score,
        multi_session_score: engagementScore.components.multi_session_score,
        browser_side_score: engagementScore.components.browser_side_score,

        // Dados originais do evento
        value: body.value || 0,
        currency: body.currency || 'BRL',
        ...body.custom_data
      }
    }]
  };

  await fetch(`https://graph.facebook.com/v25.0/${body.pixel_id}/events?access_token=${env.META_ACCESS_TOKEN}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload)
  });
}

function buildCorsHeaders(env) {
  return {
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'POST, OPTIONS',
    'Access-Control-Allow-Headers': 'Content-Type',
    'Access-Control-Allow-Credentials': 'true'
  };
}

function buildCookieHeader(visitor, umbrellaDomain) {
  const ttl = 60 * 60 * 24 * 365;
  const base = `Path=/; Max-Age=${ttl}; Domain=.${umbrellaDomain}; SameSite=Lax; Secure`;
  if (visitor.fbp) return `_fbp=${visitor.fbp}; ${base}`;
  return '';
}

// LOGAR DADOS COMPORTAMENTAIS (Engagement Scoring)
async function logBehavioralEvent(DB, body, visitor, engagementScore) {
  if (!DB) return;

  await env.DB.prepare(`
    INSERT OR REPLACE INTO behavioral_events (
      event_id, user_id, session_id,
      engagement_score, time_level, scroll_score, click_score, video_score, hover_score, intention_level,
      server_engagement_score, final_intention_level,
      page_url, utm_source, utm_medium, utm_campaign, click_ids
    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
  `).bind(
    body.event_id,
    body.user_id,
    body.session_id,
    engagementScore.server_engagement_score,
    body.behavioral_data?.time_level || null,
    body.behavioral_data?.scroll_score || 0.0,
    body.behavioral_data?.click_score || 0.0,
    body.behavioral_data?.video_score || 0.0,
    body.behavioral_data?.hover_score || 0.0,
    body.behavioral_data?.intention_level || null,
    engagementScore.final_intention_level,
    body.page_url,
    body.utms?.utm_source || null,
    body.utms?.utm_medium || null,
    body.utms?.utm_campaign || null,
    JSON.stringify(body.click_ids || {})
  ).run();
}
```

---

## 📊 ENGAGEMENT SCORING SERVER-SIDE (Quantum Tier)

### Formula de Sucesso

**Score = 1 / (Event Match Quality × Signal Strength × Behavioral Intelligence)**

O engagement scoring no servidor é mais preciso que no browser porque tem acesso a:

1. **Histórico de sessões anteriores** (D1 Identity Graph)
2. **Comportamento multi-sessão** (padrões entre visitas)
3. **Dados temporais** (recência, frequência)
4. **Atribuição completa** (todas as interações do usuário)

### Ponderação do Score Final (0-5.0)

| Componente | Peso | Descrição |
|-----------|-------|-----------|
| Visit Score | 25% | Número de visitas (1x = 1.0, 15+ = 5.0) |
| Intention Score | 20% | Nível de intenção (curioso=1.0, interessado=3.0, comprador=5.0) |
| Recency Score | 15% | Tempo desde última visita (<1h=5.0, >1mês=1.0) |
| Multi-Session Score | 20% | Comportamento consistente entre sessões |
| Browser-Side Score | 20% | Score preliminar do browser (0-5.0) |

### Cálculo por Componente

```typescript
// 1. Visit Score (25%)
function calculateVisitScore(visitorContext) {
  const visitCount = visitorContext.visit_count || 1;
  if (visitCount === 1) return 1.0;
  if (visitCount <= 3) return 2.5;
  if (visitCount <= 7) return 3.5;
  if (visitCount <= 14) return 4.0;
  return 5.0;
}

// 2. Intention Score (20%)
function calculateIntentionScore(behavioralData, visitorContext) {
  const intentionLevel = behavioralData.intention_level || 'curioso';
  const intentionWeights = {
    'curioso': 1.0,
    'interessado': 3.0,
    'comprador': 5.0
  };
  return intentionWeights[intentionLevel] || 1.0;
}

// 3. Recency Score (15%)
function calculateRecencyScore(visitorContext) {
  if (!visitorContext.last_seen) return 1.0;
  const lastSeen = new Date(visitorContext.last_seen);
  const now = new Date();
  const hoursSinceLastVisit = (now - lastSeen) / (1000 * 60 * 60);

  if (hoursSinceLastVisit < 1) return 5.0;
  if (hoursSinceLastVisit < 24) return 4.0;
  if (hoursSinceLastVisit < 168) return 3.0;
  if (hoursSinceLastVisit < 720) return 2.0;
  return 1.0;
}

// 4. Multi-Session Score (20%)
function calculateMultiSessionScore(behavioralData, visitorContext) {
  const visitCount = visitorContext.visit_count || 1;
  if (visitCount === 1) return 1.0;
  if (visitCount <= 3) return 2.0;
  if (visitCount <= 7) return 3.5;
  if (visitCount <= 14) return 4.5;
  return 5.0;
}

// 5. Final Score Calculation
const finalScore = (
  (visitScore * 0.25) +
  (intentionScore * 0.20) +
  (recencyScore * 0.15) +
  (multiSessionScore * 0.20) +
  (browserSideScore * 0.20)
);
```

### Níveis de Intenção Finais

| Score Final | Nível de Intenção | Comportamento Esperado |
|------------|------------------|----------------------|
| < 1.5 | Curioso | Primeira visita, baixo engajamento |
| 1.5 - 3.0 | Interessado | 2-7 visitas, engajamento moderado |
| > 3.0 | Comprador | 7+ visitas, alta intenção de compra |

### Integração com Plataformas

**Meta CAPI v25.0:**
```typescript
custom_data: {
  engagement_score: engagementScore.server_engagement_score,
  intention_level: engagementScore.final_intention_level,
  visit_score: engagementScore.components.visit_score,
  intention_score: engagementScore.components.intention_score,
  recency_score: engagementScore.components.recency_score,
  multi_session_score: engagementScore.components.multi_session_score,
  browser_side_score: engagementScore.components.browser_side_score,
  value: body.value || 0,
  currency: body.currency || 'BRL'
}
```

**Google GA4 Measurement Protocol:**
```typescript
custom_params: {
  engagement_score: engagementScore.server_engagement_score,
  intention_level: engagementScore.final_intention_level,
  visit_count: visitorContext.visit_count,
  days_since_last_visit: Math.floor(hoursSinceLastVisit / 24)
}
```

**TikTok Events API v1.3:**
```typescript
context: {
  user: {
    engagement_score: engagementScore.server_engagement_score,
    intention_level: engagementScore.final_intention_level
  }
}
```

---

## ✅ REGRAS CRÍTICAS

0. **CONSULTA OBRIGATÓRIA À MEMÓRIA**: Extraia os valores exatos de `Hash Salts`, domínios, `CORS` e `Rate Limits` consultando ativamente o "memory-agent.json" (Agente Memória). Solicite as variáveis antecipadamente ao Orquestrador se não as possuir. Execute a arquitetura de borda exclusivamente com dados oficiais extraídos do repositório da Memória.
1. **Cloudflare-Only**: Sem dependências externas.
2. **Same-Domain**: Worker no domínio do site (anti-adblock).
3. **Umbrella Protocol**: Cookies com abrangência de domínio.
4. **SHA-256 Nativo**: WebCrypto API sempre.
5. **Meta CAPI**: Sempre versão `v25.0`.
6. **TikTok Events API**: Sempre versão `v1.3`.
7. **Background Execution**: `ctx.waitUntil()` para não bloquear o usuário.
8. **Anti-Blocking Server-Side**: Worker deve aceitar requests de qualquer user-agent, evitar headers que ativam ad-blockers, responder rapidamente.

---

## 🛡️ ANTI-BLOCKING SERVER-SIDE (Quantum Tier)

### Estratégias para Maximizar Resiliência

**1. Same-Domain Endpoint:**
- Worker deve estar no mesmo domínio do site: `site.com/track`
- Evita bloqueios de CORS e ad-blockers que bloqueiam requests cross-origin

**2. First-Party Cookies:**
- Definir cookies no umbrella domain: `.example.com`
- Duração de 365 dias (max permitido)
- SameSite=Lax para balance entre segurança e funcionalidade

**3. Response Headers Anti-Blocking:**
```typescript
const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'POST, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type',
  'Access-Control-Allow-Credentials': 'true',
  // Headers adicionais anti-blocking
  'X-Content-Type-Options': 'nosniff',
  'X-Frame-Options': 'SAMEORIGIN'
};
```

**4. Fast Response (<100ms):**
- Processar e responder rapidamente
- Usar `ctx.waitUntil()` para processamento assíncrono
- Primeira resposta é imediata, processamento em background

**5. Accept Any User-Agent:**
- Não bloquear requests baseados em user-agent
- Ad-blockers podem falsificar user-agent
- Validação deve ser baseada em token/secret, não UA

**6. Same-Domain via Worker Route (anti-blocking):**
- Endpoint de tracking: `/track` (Worker route same-domain — ad-blockers não bloqueiam requests same-domain)
- A proteção real vem do same-domain, não do nome do path

---

## 🔄 ESCALONAMENTO AUTOMÁTICO DE ERROS (Quantum Tier)

1. **Cloudflare-Only**: Sem dependências externas.
2. **Same-Domain**: Worker no domínio do site.
3. **Umbrella Protocol**: Cookies com abrangência de domínio.
4. **SHA-256 Nativo**: WebCrypto API sempre.
5. **Meta CAPI**: Sempre versão `v25.0`.
6. **TikTok Events API**: Sempre versão `v1.3`.
7. **Background Execution**: `ctx.waitUntil()` para não bloquear o usuário.

---

## 🔄 ESCALONAMENTO AUTOMÁTICO DE ERROS (Quantum Tier)

### Estratégia de Resiliência: 3-Tier Retry System

Quando o Worker falhar ao enviar evento para qualquer plataforma (Meta, Google, TikTok, etc.), seguir este fluxo:

```
Tentativa 1 (Imediata)
    ↓ Falha
Tentativa 2 (Cloudflare Queue - 5 minutos)
    ↓ Falha
Tentativa 3 (Cloudflare Queue - 15 minutos)
    ↓ Falha (3ª consecutiva)
🚨 ALERTA VIA WHATSAPP AGENT → ADMIN
```

---

### PASSO 1 — Captura de Falha com Gravação no D1

Toda função de dispatch (Meta, Google, TikTok) DEVE ter try/catch com gravação:

```typescript
// Exemplo para dispatchMetaCapi com escalonamento
async function dispatchMetaCapi(body, env, visitor, heatScore, clientIP, userAgent, cf, retryCount = 0) {
  if (!env.META_ACCESS_TOKEN || !body.pixel_id) {
    await logEventFailure(env.DB, 'meta', body.event_id, 'Missing credentials/pixel_id');
    return;
  }

  try {
    const em = await sha256(body.email);
    const ph = await sha256((body.phone || '').replace(/\D/g, ''));

    const payload = { /* payload Meta CAPI v25.0 */ };

    const response = await fetch(
      `https://graph.facebook.com/v25.0/${body.pixel_id}/events?access_token=${env.META_ACCESS_TOKEN}`,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload)
      }
    );

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Meta API Error ${response.status}: ${errorText}`);
    }

    // SUCESSO: Atualizar status no D1
    await logEventSuccess(env.DB, 'meta', body.event_id);

  } catch (error) {
    // FALHA: Gravar no D1 e enfileirar para retry
    await logEventFailure(env.DB, 'meta', body.event_id, error.message, retryCount);

    // Enfileirar para Cloudflare Queue
    await enqueueRetry(env.RETRY_QUEUE, {
      platform: 'meta',
      event_id: body.event_id,
      body: body,
      visitor,
      heatScore,
      clientIP,
      userAgent,
      cf,
      retry_count: retryCount + 1
    });
  }
}
```

---

### PASSO 2 — Atualização do Schema D1 (adicionar tabelas de retry)

Adicionar ao `schema.sql`:

```sql
-- TABELA DE EVENTOS COM STATUS APERFEIÇOADO
ALTER TABLE events_log ADD COLUMN IF NOT EXISTS retry_count INTEGER DEFAULT 0;
ALTER TABLE events_log ADD COLUMN IF NOT EXISTS last_retry_at TEXT;
ALTER TABLE events_log ADD COLUMN IF NOT EXISTS max_retries INTEGER DEFAULT 3;

-- TABELA DE FILA DE RETRY (para Queue)
CREATE TABLE IF NOT EXISTS retry_queue (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  platform TEXT NOT NULL,
  event_id TEXT NOT NULL,
  event_payload TEXT NOT NULL,
  visitor_data TEXT,
  retry_count INTEGER DEFAULT 0,
  scheduled_at TEXT DEFAULT (datetime('now')),
  status TEXT DEFAULT 'pending', -- pending | processing | failed | success
  error_message TEXT,
  created_at TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_retry_scheduled ON retry_queue(scheduled_at, status);
```

---

### PASSO 3 — Funções de Log de Sucesso/Falha

```typescript
// Log de sucesso
async function logEventSuccess(DB, platform, eventId) {
  if (!DB) return;

  await env.DB.prepare(`
    UPDATE events_log
    SET status = 'success',
        retry_count = 0,
        last_retry_at = NULL
    WHERE event_id = ? AND platform = ?
  `).bind(eventId, platform).run();
}

// Log de falha com escalonamento
async function logEventFailure(DB, platform, eventId, errorMessage, retryCount) {
  if (!DB) return;

  const maxRetries = 3;
  const isFinalFailure = retryCount >= maxRetries;

  await env.DB.prepare(`
    UPDATE events_log
    SET status = ?,
        retry_count = ?,
        error_msg = ?,
        last_retry_at = ?
    WHERE event_id = ? AND platform = ?
  `).bind(
    isFinalFailure ? 'failed' : 'retrying',
    retryCount,
    errorMessage,
    new Date().toISOString(),
    eventId,
    platform
  ).run();

  // Se falha definitiva (3ª tentativa), disparar alerta
  if (isFinalFailure) {
    await dispatchAlert(platform, eventId, errorMessage);
  }
}

// Enfileirar para retry via Cloudflare Queue
async function enqueueRetry(queue, retryData) {
  const { platform, event_id, retry_count } = retryData;

  // Calcular delay exponencial: 5min, 15min, 45min
  const delays = [5, 15, 45];
  const delayMinutes = delays[Math.min(retry_count - 1, 2)];
  const scheduledAt = new Date(Date.now() + delayMinutes * 60 * 1000).toISOString();

  await queue.send(JSON.stringify({
    ...retryData,
    scheduled_at: scheduledAt,
    status: 'pending'
  }));
}
```

---

### PASSO 4 — Alerta Automático via WhatsApp Agent (CallMeBot)

Após 3 falhas consecutivas, disparar alerta para o administrador:

```typescript
// Função de alerta integrada com WhatsApp Agent
async function dispatchAlert(platform, eventId, errorMessage) {
  const alertMessage = `
🚨 CDPEDGE ALERTA CRÍTICA

Platform: ${platform.toUpperCase()}
Event ID: ${eventId}
Error: ${errorMessage}
Failed Attempts: 3 (máximo alcançado)

Ação necessária: Verificar configuração da API ${platform} no wrangler secrets.
Timestamp: ${new Date().toISOString()}
  `.trim();

  // Verificar se há token do WhatsApp configurado
  const waPhoneId = env.WHATSAPP_PHONE_NUMBER_ID;
  const adminNumber = env.ADMIN_PHONE_NUMBER;

  if (waPhoneId && adminNumber) {
    await fetch(`https://graph.facebook.com/v25.0/${waPhoneId}/messages`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${env.WHATSAPP_ACCESS_TOKEN}`
      },
      body: JSON.stringify({
        messaging_product: 'whatsapp',
        to: adminNumber,
        type: 'text',
        text: alertMessage
      })
    });
  }

  // Fallback para CallMeBot se WhatsApp Cloud API não estiver disponível
  else if (env.ADMIN_PHONE_NUMBER) {
    await fetch(`https://api.callmebot.com/send.php`, {
      method: 'POST',
      body: new URLSearchParams({
        phone: env.ADMIN_PHONE_NUMBER,
        text: alertMessage
      })
    });
  }
}
```

---

### PASSO 5 — Consumer da Cloudflare Queue (para o wrangler.toml)

Adicionar configuração de consumer ao `wrangler.toml`:

```toml
[[queues.consumers]]
queue = "cdp-edge-retry"
max_batch_size = 5
max_batch_timeout = 60

# Cron Trigger para processar fila a cada minuto
[[triggers.crons]]
cron = "* * * * *"  # A cada minuto
```

E no `index.ts`, adicionar handler de queue:

```typescript
// Handler de Queue (retries)
export async function queue(batch, env) {
  for (const message of batch.messages) {
    const { body } = JSON.parse(message.body);
    const { platform, event_id, event_payload, visitor, heatScore, retry_count } = body;

    // Redespachar para plataforma apropriada
    switch (platform) {
      case 'meta':
        await dispatchMetaCapi(event_payload, env, visitor, heatScore, body.clientIP, body.userAgent, body.cf, retry_count);
        break;
      case 'google':
        await dispatchGA4(event_payload, env, visitor, heatScore, retry_count);
        break;
      case 'tiktok':
        await dispatchTikTok(event_payload, env, visitor, heatScore, retry_count);
        break;
      // Adicionar outras plataformas...
    }
  }
}
```

---

### REGRAS DO ESCALONAMENTO

1. **Exponential Backoff**: Usar delays de 5min → 15min → 45min (não tentar imediatamente)
2. **Max Retry = 3**: Após 3 falhas, marcar como 'failed' definitivo e disparar alerta
3. **Queue-First**: Nunca retry direto na função principal → sempre enfileirar via Cloudflare Queue
4. **Alert-only on Final Failure**: Não disparar WhatsApp nas 2 primeiras falhas (só na 3ª)
5. **Log Everything**: Toda falha/sucesso deve ser registrada no D1 com timestamp
6. **Platform-Agnostic**: Mesmo sistema de retry para todas as plataformas (Meta, Google, TikTok, Pinterest, Reddit)

---

## INPUTS RECEBIDOS

- JSON do Page Analyzer Agent (tecnologia detectada, páginas, tipo de funil)
- JSON do Premium Tracking Intelligence Agent (eventos prioritários, engagement scoring config)
- Plataformas selecionadas na FASE 0-B (Meta, Google, TikTok, etc.)
- `UMBRELLA_DOMAIN` — domínio principal do funil (detectado automaticamente ou fornecido pelo usuário)
- Secrets de plataformas: `META_ACCESS_TOKEN`, `GA4_API_SECRET`, `TIKTOK_ACCESS_TOKEN`
- Secrets opcionais: `RESEND_API_KEY`, `WHATSAPP_ACCESS_TOKEN`, `WHATSAPP_PHONE_NUMBER_ID`

## RESPONSABILIDADE

- Gerar `wrangler.toml` completo com bindings D1, KV, R2, Queues e Cron Triggers
- Gerar `schema.sql` com todas as tabelas: `events_log`, `identity_graph`, `leads`, `behavioral_events`, `webhook_events`, `user_profiles`
- Gerar `index.ts` principal com endpoint `/track` (recebe eventos do browser)
- Implementar Identity Graph sync, Engagement Scoring server-side e First-Party Cookie (`_cdp_uid`)
- Implementar Anti-Blocking: CORS same-domain, headers limpos, sem keywords bloqueáveis
- Implementar sistema de retry com Cloudflare Queues (3-Tier: imediato → 5min → 15min → 45min)
- Gerar `DEPLOY.md` com guia passo a passo do zero ao funcionando

## SAÍDA

```json
{
  "arquivos_gerados": [
    "wrangler.toml",
    "schema.sql",
    "index.ts",
    "DEPLOY.md"
  ],
  "endpoints": {
    "tracking":  "POST /track",
    "health":    "GET  /api/health",
    "webhooks":  "POST /webhook/{gateway}",
    "ticto":     "POST /webhook/ticto"
  },
  "bindings_cloudflare": {
    "d1":     "cdp-edge-db",
    "kv":     "GEO_CACHE",
    "r2":     "cdp-edge-logs",
    "queue":  "cdp-edge-retry",
    "ai":     "AI (Workers AI — LTV Prediction)"
  },
  "tabelas_d1": ["events_log", "identity_graph", "leads", "behavioral_events", "webhook_events", "user_profiles"],
  "retry_sistema": "Cloudflare Queues — max 3 tentativas, backoff exponencial",
  "anti_blocking": true,
  "first_party_cookie": "_cdp_uid (365 dias, HttpOnly, Secure, SameSite=Lax)",
  "secrets_necessarios": ["META_ACCESS_TOKEN", "GA4_API_SECRET", "TIKTOK_ACCESS_TOKEN"]
}
```