npm - cdp-edge - Versions diffs - 1.0.0 - Mend

cdp-edge 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (176) hide show

package/templates/afiliado-sem-landing.md ADDED Viewed

@@ -0,0 +1,312 @@
+# Template: Afiliado Sem Landing Page Própria
+> Você é afiliado de um produto e envia tráfego direto para o checkout da plataforma
+> (Hotmart, Kiwify, Eduzz, Monetizze, CartPanda, Ticto).
+> Não tem domínio próprio — o link de afiliado é a URL de destino dos seus anúncios.
+> Infraestrutura: Cloudflare Workers + D1 (100% Native)
+**Quando usar este modelo:**
+- Afiliado que divulga link de produto de terceiros
+- Sem landing page: o anúncio aponta direto para `pay.hotmart.com/XXXXX`
+- Quer rastrear vendas no Meta/TikTok/Google sem pixel na página do produtor
+**O problema central:**
+O pixel do Meta está no seu gerenciador, mas o checkout é do produtor — você não tem acesso à página. O produtor te dá um webhook de compra, mas esse webhook não tem fbp/fbc/UTMs porque o pixel nunca rodou na página de checkout.
+**A solução:**
+Criar uma página de ponte (bridge page) mínima no seu domínio. O usuário passa por ela, o CDP Edge captura todos os dados e injeta o `cdp_uid` no link de checkout. Quando o webhook de compra chegar, o D1 faz o lookup e envia o evento com atribuição completa.
+---
+## Arquitetura
+```
+Anúncio Meta/TikTok/Google
+        │
+        ▼
+┌───────────────────────────────┐
+│  Bridge Page (seu domínio)    │  ← leva 2s, redireciona auto
+│  bridge.seudominio.com        │
+│                               │
+│  1. Gera cdp_uid              │
+│  2. Captura fbclid/ttclid     │
+│  3. Salva fbp/fbc/UTMs no D1  │
+│  4. Injeta cdp_uid no link    │
+│  5. Redireciona para checkout │
+└───────────────────────────────┘
+        │
+        ▼
+┌──────────────────────────────────┐
+│  Checkout da Plataforma          │
+│  pay.hotmart.com/XXXXX?xcod=uid  │
+│                                  │
+│  Usuário compra                  │
+│  Plataforma envia webhook →      │
+│    Worker → D1 lookup(uid)       │
+│    Meta Purchase CAPI ✅          │
+└──────────────────────────────────┘
+```
+---
+## Passo 1 — Bridge Page (index.html)
+Crie uma página mínima no seu domínio. Pode ser hospedada no Cloudflare Pages (grátis).
+```html
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Redirecionando...</title>
+  <!-- Pixel Meta browser (para ViewContent + fbp/fbc) -->
+  <script>
+    !function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
+    n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
+    n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
+    t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
+    document,'script','https://connect.facebook.net/en_US/fbevents.js');
+    fbq('init', 'SEU_PIXEL_ID');
+    fbq('track', 'PageView');
+  </script>
+</head>
+<body>
+  <p style="font-family:sans-serif;text-align:center;margin-top:40px">
+    Aguarde, você está sendo redirecionado...
+  </p>
+  <script type="module">
+    import { init, track, getUserIdWithFallback, getUTMsWithFallback } from '/js/cdpTrack.js';
+    await init();
+    const uid     = getUserIdWithFallback();
+    const utms    = getUTMsWithFallback();
+    // Disparar ViewContent (sinal de interesse antes do checkout)
+    await track('ViewContent', {
+      content_name: 'Bridge Page - Afiliado',
+      content_type: 'product',
+      uid,
+    });
+    // Construir URL de checkout com cdp_uid injetado
+    // passCheckoutParams() já faz isso para os links na página,
+    // mas para redirect direto usamos a função abaixo:
+    const checkoutUrl = buildCheckoutUrl('https://pay.hotmart.com/SEU_LINK_DE_AFILIADO', uid, utms);
+    // Redireciona após 800ms (tempo suficiente para o evento ser enviado)
+    setTimeout(() => { window.location.href = checkoutUrl; }, 800);
+    /**
+     * Constrói a URL de checkout com parâmetros de atribuição
+     */
+    function buildCheckoutUrl(baseUrl, uid, utms) {
+      const url = new URL(baseUrl);
+      // Hotmart: xcod = user_id, sck = UTMs pipe-separados
+      if (baseUrl.includes('hotmart.com')) {
+        if (uid) url.searchParams.set('xcod', uid);
+        const sck = [utms.utm_source, utms.utm_medium, utms.utm_campaign, utms.utm_content, utms.utm_term]
+          .map(v => v || 'direto').join('|');
+        if (utms.utm_source) url.searchParams.set('sck', sck);
+      }
+      // Kiwify: src = utm_source
+      else if (baseUrl.includes('kiwify.com.br')) {
+        if (utms.utm_source) url.searchParams.set('src', utms.utm_source);
+        if (utms.utm_medium) url.searchParams.set('utm_medium', utms.utm_medium);
+        if (utms.utm_campaign) url.searchParams.set('utm_campaign', utms.utm_campaign);
+      }
+      // Eduzz / Monetizze: src = utm_source
+      else if (baseUrl.includes('eduzz.com') || baseUrl.includes('monetizze.com.br')) {
+        if (utms.utm_source) url.searchParams.set('src', utms.utm_source);
+      }
+      // CartPanda: utm_* direto
+      else if (baseUrl.includes('cartpanda.com')) {
+        Object.entries(utms).forEach(([k, v]) => { if (v) url.searchParams.set(k, v); });
+      }
+      // Ticto: utm_* + user_id
+      else if (baseUrl.includes('ticto.app')) {
+        Object.entries(utms).forEach(([k, v]) => { if (v) url.searchParams.set(k, v); });
+        if (uid) url.searchParams.set('user_id', uid);
+      }
+      // Genérico: repassa tudo
+      else {
+        Object.entries(utms).forEach(([k, v]) => { if (v) url.searchParams.set(k, v); });
+        if (uid) url.searchParams.set('cdp_uid', uid);
+      }
+      return url.toString();
+    }
+  </script>
+</body>
+</html>
+```
+---
+## Passo 2 — Worker Route (Same-Domain)
+O Worker precisa estar no mesmo domínio da bridge page para capturar fbp/fbc como first-party cookies.
+```toml
+# wrangler.toml — adicionar route da bridge page
+[[routes]]
+pattern = "bridge.seudominio.com/*"
+zone_name = "seudominio.com"
+```
+```bash
+wrangler deploy
+```
+---
+## Passo 3 — Configurar Webhook na Plataforma
+### Hotmart
+```
+Hotmart → Ferramentas → Webhooks → Adicionar Webhook
+URL: https://bridge.seudominio.com/webhook/hotmart
+Eventos: Compra Aprovada, Compra Cancelada, Reembolso
+```
+### Kiwify
+```
+Kiwify → Configurações → Webhooks
+URL: https://bridge.seudominio.com/webhook/kiwify
+Status: Ativo
+```
+### Ticto
+```
+Ticto → Configurações → Webhook
+URL: https://bridge.seudominio.com/webhook/ticto
+Eventos: purchase_approved
+```
+O Worker (`worker.js`) já tem handlers para `/webhook/hotmart`, `/webhook/kiwify` e `/webhook/ticto`. Eles:
+1. Extraem `xcod`/`sck`/`user_id` do payload
+2. Fazem D1 lookup pelo `cdp_uid`
+3. Recuperam `fbp`, `fbc`, `ttp`, UTMs
+4. Enviam `Purchase` para Meta CAPI + GA4 + TikTok
+---
+## Passo 4 — Fallback de Fingerprint (Automático)
+O SDK já salva automaticamente uid + UTMs no `localStorage` (`_cdp_aff`).
+**Cenário coberto:** usuário vê o anúncio, clica, a página de bridge abre em nova aba — o cookie pode não ser lido em alguns navegadores nesse contexto.
+```javascript
+// Automaticamente chamado em init():
+_saveAffiliateContext(); // salva uid + UTMs no localStorage
+// Ao montar a bridge page:
+const uid  = getUserIdWithFallback();  // cookie → localStorage → ''
+const utms = getUTMsWithFallback();    // URL params → localStorage → {}
+```
+O `getUserIdWithFallback()` tenta em ordem:
+1. Cookie `_cdp_uid` (primeira opção)
+2. localStorage `_cdp_aff.uid` (fallback — 30 dias de validade)
+3. String vazia (sem identificação)
+---
+## Passo 5 — Anúncio Meta: URL de Destino
+Configure o anúncio apontando para a bridge page, não para o checkout direto:
+```
+URL de Destino do Anúncio:
+  https://bridge.seudominio.com/?utm_source=meta&utm_medium=paid&utm_campaign=NOME_CAMP&utm_content=NOME_AD
+❌ NÃO usar:
+  https://pay.hotmart.com/XXXXX (perde fbp/fbc/UTMs)
+```
+O Meta injeta o `fbclid` automaticamente na URL. O SDK captura e salva no D1.
+---
+## Passo 6 — Verificar Atribuição
+Após uma venda de teste:
+```bash
+# Ver se o cdp_uid chegou no webhook e fez lookup
+wrangler d1 execute cdp-edge-db --command="
+  SELECT
+    w.raw_payload,
+    l.fbp,
+    l.fbc,
+    l.utm_source,
+    l.utm_campaign
+  FROM webhook_events w
+  LEFT JOIN leads l ON l.user_id = json_extract(w.raw_payload, '$.xcod')
+  ORDER BY w.created_at DESC
+  LIMIT 1;
+"
+# Confirmar evento no Meta Events Manager
+# Gerenciador de Eventos → filtrar por Purchase → verificar match_keys
+```
+---
+## Checklist de Verificação
+```
+[ ] Bridge page no seu domínio (Cloudflare Pages recomendado — grátis)
+[ ] Worker Route configurado: bridge.seudominio.com/*
+[ ] SDK instalado na bridge page com getUserIdWithFallback()
+[ ] URL de destino do anúncio aponta para bridge page (não checkout direto)
+[ ] UTMs na URL do anúncio (utm_source, utm_medium, utm_campaign)
+[ ] Webhook configurado na plataforma para o Worker
+[ ] Teste: compra de desenvolvimento → D1 lookup → Purchase no Meta Events Manager
+[ ] Verificar fbp no D1 (confirma que fbclid foi capturado)
+[ ] Verificar utm_source no D1 (confirma que UTMs chegaram)
+[ ] Meta Events Manager: compra com match_keys email/phone (se plataforma enviar no webhook)
+```
+---
+## Fluxo Completo
+```
+1. Anúncio Meta clicado
+   └─ URL: bridge.seudominio.com/?fbclid=XXX&utm_source=meta&utm_campaign=CAMP
+2. Bridge Page carrega (800ms)
+   └─ cdp_uid gerado (cookie 365 dias + localStorage backup)
+   └─ fbclid capturado → _fbc calculado
+   └─ UTMs salvos no localStorage (_cdp_aff)
+   └─ PageView → Worker → D1 salva {fbp, fbc, utm_source, utm_campaign, ip, ua}
+   └─ ViewContent → Worker → Meta ViewContent CAPI
+3. Redirect para checkout
+   └─ URL: pay.hotmart.com/XXX?xcod=cdp_uid&sck=meta|paid|CAMP||
+4. Usuário compra
+   └─ Hotmart webhook → Worker /webhook/hotmart
+   └─ Extrai xcod = cdp_uid
+   └─ D1 lookup(cdp_uid) → fbp, fbc, utm_source, utm_campaign, ip
+   └─ Meta Purchase CAPI: fbp + fbc + utm_source → atribuição completa ✅
+   └─ GA4 Purchase + TikTok CompletePayment
+```
+---
+## Notas de Privacidade / LGPD
+- A bridge page não coleta email ou telefone
+- Apenas identifica a sessão com um ID anônimo (`cdp_uid`)
+- Os dados de compra (email, telefone) chegam pelo webhook da plataforma e são hasheados antes de enviar ao CAPI
+- O redirecionamento automático é transparente — nenhum dado sensível é exposto na URL

package/templates/captura-de-lead.md ADDED Viewed

@@ -0,0 +1,78 @@
+# Modelo: Captura de Lead (Cloudflare Native)
+Este modelo é destinado a páginas de captura de leads (Opt-in), onde o objetivo principal é coletar o e-mail e/ou telefone do usuário antes de redirecioná-lo para a próxima etapa do funil.
+---
+## 🏗️ ARQUITETURA TÉCNICA (Quantum Tier)
+O rastreamento é realizado de forma síncrona com o envio do formulário:
+1. **Página**: Captura os dados do formulário e envia via `cdpTrack.track()`.
+2. **Servidor (Worker)**: Recebe os dados, realiza o hashing SHA-256 e envia para as APIs.
+3. **Database (D1)**: Armazena o lead e vincula aos IDs de rastreamento (`fbp`, `fbc`).
+---
+## 📘 EVENTOS PRINCIPAIS
+| Evento | Gatilho | PII (Dados Pessoais) |
+|---|---|---|
+| **PageView** | Carregamento da página | IP, User-Agent, URL |
+| **Lead** | Clique no botão de enviar | E-mail, Telefone, Nome (crus) |
+---
+## 🛠️ PASSO 1: CONFIGURAÇÃO DO SITE
+### 1.1 SDK de Rastreamento (Header)
+```html
+<script src="/js/cdpTrack.js" async></script>
+<script>
+  window.cdpConfig = {
+    metaId: 'SEU_PIXEL_ID',
+    ttId: 'SEU_TIKTOK_ID'
+  };
+</script>
+```
+### 1.2 Captura do Formulário
+Este script deve ser inserido antes da tag `</body>`. Ele garante que o evento seja enviado antes do redirecionamento.
+```javascript
+<script>
+document.querySelector('#meu-formulario').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const leadData = {
+    email: e.target.email.value,
+    phone: e.target.phone.value,
+    first_name: e.target.name.value,
+    event_id: cdpTrack.generateId() // ID único para deduplicação
+  };
+  // Envia para o Worker (Cloudflare)
+  await cdpTrack.track('Lead', leadData);
+  // Prossegue com o envio real do formulário
+  e.target.submit();
+});
+</script>
+```
+---
+## ⚡ PASSO 2: SERVIDOR (CLOUDFLARE WORKER)
+O PlayerBuilder Quantum Tier processa o evento via Cloudflare Worker:
+1. **Deduplicação**: Utiliza o `event_id` do browser para 100% de precisão na Meta CAPI.
+2. **Advanced Matching**: Aplica SHA256 em `email`, `phone`, `first_name` e `last_name` (WebCrypto native).
+3. **D1 Store**: Salva o lead e o Identity Graph na tabela `leads`.
+4. **API Dispatch**: Envia assincronamente para Meta CAPI (v22.0) e TikTok Events API (v1.3).
+---
+## ✅ VALIDAÇÃO TÉCNICA
+- **Deduplicação**: Verifique se o `event_id` gerado no site é o mesmo recebido no Gerenciador de Eventos.
+- **Match Quality**: O envio de e-mail e telefone hasheados pelo servidor garante a máxima pontuação de qualidade.
+- **Persistência**: O lead deve aparecer no banco D1 imediatamente após o envio.

package/templates/captura-lead-evento-externo.md ADDED Viewed

@@ -0,0 +1,99 @@
+# Modelo: Captura com Evento Externo (Cloudflare Native)
+Este modelo combina a captura de leads no site com o recebimento de eventos externos (Webhooks) de plataformas de vendas (Ticto, Hotmart, Kiwify, Eduzz, etc.). Os dados são cruzados no banco **D1** para garantir uma atribuição de alta qualidade.
+---
+## 🏗️ ARQUITETURA TÉCNICA (Quantum Tier)
+O fluxo de dados segue o enriquecimento de identidade:
+1. **Site**: Captura o lead e gera o `event_id` inicial, disparando para o Worker.
+2. **Servidor (Worker)**: Salva o lead no D1 vinculando e-mail aos cookies (`fbp`, `fbc`, `ttp`).
+3. **Webhook**: O Worker recebe a venda, busca o lead no D1 e dispara a CAPI com todos os dados recuperados.
+---
+## 🛠️ PASSO 1: CONFIGURAÇÃO DO SITE
+### 1.1 SDK de Rastreamento
+```html
+<script src="/js/cdpTrack.js" async></script>
+<script>
+  window.cdpConfig = {
+    metaId: 'SEU_PIXEL_ID',
+    ttId: 'SEU_TIKTOK_ID'
+  };
+</script>
+```
+### 1.2 Captura de Lead
+```javascript
+document.querySelector('#form-lead').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const leadData = {
+    email: e.target.email.value,
+    phone: e.target.phone.value,
+    first_name: e.target.name.value,
+    event_id: cdpTrack.generateId()
+  };
+  await cdpTrack.track('Lead', leadData);
+  e.target.submit();
+});
+```
+---
+## 🖥️ PASSO 2: RECEBIMENTO DE WEBHOOK
+O Worker recebe o Webhook da plataforma de vendas, busca o lead no D1 e dispara as APIs.
+### 2.1 Exemplo de Lógica no Worker
+```javascript
+export default {
+  async fetch(request, env, ctx) {
+    if (request.method === 'POST') {
+      const payload = await request.json();
+      const email = payload.email || payload.customer?.email;
+      // Busca o lead no banco D1
+      const lead = await env.DB.prepare(
+        "SELECT * FROM leads WHERE email = ?"
+      ).bind(email).first();
+      if (lead) {
+        const capiData = {
+          event_name: 'Purchase',
+          event_id: payload.transaction_id,
+          user_data: {
+            em: lead.email,
+            ph: lead.phone,
+            fbp: lead.fbp,
+            fbc: lead.fbc,
+            client_ip_address: lead.ip,
+            client_user_agent: lead.ua
+          },
+          custom_data: {
+            value: payload.price,
+            currency: 'BRL'
+          }
+        };
+        ctx.waitUntil(dispatchCAPI(capiData, env));
+      }
+      return new Response('OK', { status: 200 });
+    }
+  }
+}
+```
+---
+## ✅ VALIDAÇÃO TÉCNICA
+- **Enriquecimento**: Verifique se a CAPI está enviando os campos `fbp` e `fbc` mesmo em eventos que vêm de Webhook.
+- **Match Quality**: O cruzamento via e-mail no D1 deve garantir uma pontuação máxima de qualidade no Gerenciador de Eventos.
+- **Deduplicação**: O `event_id` da venda deve ser o ID de transação da plataforma.

package/templates/checkout-proprio.md ADDED Viewed

@@ -0,0 +1,111 @@
+# Modelo: Checkout Próprio (Cloudflare Native)
+Este modelo é destinado a checkouts integrados diretamente no seu site (WooCommerce, Shopify, ou checkouts customizados). O rastreamento cobre desde a entrada no checkout até a confirmação de compra na infraestrutura Cloudflare.
+---
+## 🏗️ ARQUITETURA TÉCNICA (Quantum Tier)
+Fluxo de conversão:
+1. **Site**: Captura de passos (`InitiateCheckout`, `AddPaymentInfo`) via Fetch direto.
+2. **Servidor (Worker)**: Processamento e despacho para as APIs.
+3. **D1 Database**: Repositório de pedidos e perfis de compradores.
+---
+## 📘 IDENTIFICADORES
+| Evento | Gatilho | Dados Enviados |
+|---|---|---|
+| `InitiateCheckout` | Entrada na página de checkout | `email`, `phone` (se preenchidos) |
+| `AddPaymentInfo` | Seleção da forma de pagamento | `email`, `payment_type` |
+| `Purchase` | Clique no botão de finalizar | `email`, `value`, `order_id` |
+---
+## 🛠️ PASSO 1: CONFIGURAÇÃO DO SITE
+### 1.1 Script de Tracking de Checkout
+Este script captura dados à medida que o usuário preenche o formulário.
+```javascript
+<script>
+(function() {
+  const WORKER_URL = 'https://api.seusite.com/api/tracking';
+  // Atualização de identidade ao sair do campo (Blur Event)
+  const inputs = document.querySelectorAll('input[type="email"], input[type="tel"]');
+  inputs.forEach(input => {
+    input.addEventListener('blur', function() {
+      window.cdpTrack('IdentityUpdate', {
+        email: document.querySelector('[name="email"]')?.value || '',
+        phone: document.querySelector('[name="phone"]')?.value || ''
+      });
+    });
+  });
+  // Evento: Entrada no Checkout
+  window.cdpTrack('InitiateCheckout', {
+    num_items: 1,
+    content_name: 'Produto Premium'
+  });
+  // Evento: Finalizar Compra
+  const purchaseBtn = document.querySelector('#btn-finalizar');
+  purchaseBtn?.addEventListener('click', function() {
+    window.cdpTrack('Purchase', {
+      value: 197.00,
+      currency: 'BRL',
+      order_id: 'ord_' + Date.now()
+    });
+  });
+})();
+</script>
+```
+---
+## ⚡ PASSO 2: SERVIDOR (CLOUDFLARE WORKER)
+O Worker gerencia o estado da transação e a persistência.
+### 2.1 Persistência de Pedido
+Ao receber o evento `Purchase`, o Worker salva na tabela `leads` com o status correspondente.
+### 2.2 Despacho para APIs
+- O Worker envia `Purchase` para as APIs (Meta CAPI v22.0, TikTok v1.3).
+- O `InitiateCheckout` prévio no D1 permite automação de recuperação de carrinho.
+---
+## 📊 PASSO 3: BANCO DE DADOS D1
+```sql
+INSERT INTO leads (
+  event_name, event_id, email, value, currency, utm_source, page_url
+) VALUES (?, ?, ?, ?, ?, ?, ?);
+```
+---
+## ✅ VALIDAÇÃO TÉCNICA
+- **Captura Intermediária**: Verifique se o e-mail é enviado ao Worker antes do clique final (evento Blur).
+- **Deduplicação**: O `order_id` deve ser utilizado como `event_id`.
+- **Integridade D1**: O valor da compra e moeda devem ser gravados corretamente no banco.
+---
+## 🔄 EXEMPLOS DE INTEGRAÇÃO
+### Stripe
+```javascript
+stripe.confirmPayment({ ... }).then(result => {
+  if (!result.error) {
+    cdpTrack.track('Purchase', { value: 197.0, order_id: result.paymentIntent.id });
+  }
+});
+```
+### Mercado Pago / PagSeguro
+Chamar o disparo de `Purchase` no callback de `status === 'approved'`.

package/templates/install/.claude/commands/cdp.md ADDED Viewed

	@@ -0,0 +1 @@
1	+ Leia o arquivo `cdp-edge/extracted-skill/tracking-events-generator/agents/master-orchestrator.md` e ative o Master Orchestrator exibindo a mensagem de boas-vindas completa.

package/templates/install/CLAUDE.md ADDED Viewed

@@ -0,0 +1,65 @@
+# [NOME DO PROJETO] — CDP Edge Quantum Tracking
+## Ativação automática do CDP Edge
+**Ao iniciar esta sessão, execute imediatamente:**
+1. Leia o arquivo: `cdp-edge/extracted-skill/tracking-events-generator/agents/master-orchestrator.md`
+2. Ative o **Master Orchestrator** exibindo a mensagem de boas-vindas
+3. Aguarde as instruções do usuário para iniciar o setup
+> Se o CDP Edge estiver em outro caminho, ajuste o path acima conforme a estrutura do projeto.
+---
+## Sobre este projeto
+Este projeto usa o **CDP Edge — Quantum Tracking** para rastreamento server-side 100% Cloudflare Native, imune a Ad-Blockers e iOS 14.5+.
+**Stack:** Cloudflare Workers + D1 + KV + Queues + R2 + Workers AI
+---
+## Localização dos arquivos CDP Edge
+```
+cdp-edge/
+├── extracted-skill/tracking-events-generator/
+│   ├── agents/              ← 39 agentes especializados
+│   │   ├── master-orchestrator.md    ← PONTO DE ENTRADA
+│   │   ├── server-tracking.md
+│   │   ├── database-agent.md
+│   │   ├── whatsapp-ctwa-setup-agent.md
+│   │   └── ...
+│   ├── cdpTrack.js          ← SDK browser
+│   └── micro-events.js      ← eventos de engajamento
+├── server-edge-tracker/
+│   ├── worker.js            ← Cloudflare Worker principal
+│   ├── schema.sql           ← schema D1
+│   └── wrangler.toml        ← configuração Cloudflare
+├── templates/               ← templates por cenário de uso
+└── docs/                    ← documentação
+    ├── quick-start.md
+    ├── events-reference.md
+    └── sdk-reference.md
+```
+---
+## Comandos rápidos
+| Comando | O que faz |
+|---|---|
+| `/cdp` | Ativa o Master Orchestrator |
+| `/cdp setup` | Inicia o wizard de configuração completo |
+| `/cdp status` | Verifica saúde do projeto atual |
+---
+## Regras obrigatórias (CDP Edge)
+- **Nunca usar GTM, Stape.io ou VPS** — sempre Cloudflare Native
+- **Same-domain only** — o Worker deve rodar no domínio do funil
+- **SHA256 no Worker** — nunca hashar no browser
+- **event_id idêntico** entre browser e server para deduplicação
+- **Promise.allSettled** — nenhuma plataforma bloqueia outra