cdp-edge 2.2.0 → 2.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 **Padrão Quantum Tracking: 100% Cloudflare Edge.** Sem GTM. Sem Stape. Sem cookies de terceiros.
 
-> **v2.0.9** — Enterprise-Level Intelligence Engine · Cloudflare Workers · Meta CAPI v22.0 · GA4 MP · TikTok Events API v1.3
+> **v2.2.0** — Granite 4.0 Micro · K-means Vetorial Real (bge-m3) · Sem emails descartáveis · Cloudflare Workers · Meta CAPI v22.0 · GA4 MP · TikTok Events API v1.3
 
 ---
 
@@ -14,7 +14,7 @@
 Meu ecossistema opera como um Cérebro de Conversão Privado na borda. Quando um evento de Lead bate no endpoint `/track`:
 1. **O Escudo Frontal (Fraud Gate):** Inspeciono IP, ASN e Velocity na borda. Bloqueio bots silenciosamente antes mesmo deles carregarem.
 2. **A Roleta Invisível (A/B LTV):** Faço o sorteio de prompts para testes A/B via KV Cache em ~0ms.
-3. **O Cérebro Financeiro (LTV Predictor):** Rodo Machine Learning (Llama 3.1) para qualificar a intenção e gerar o LTV Preditivo.
+3. **O Cérebro Financeiro (LTV Predictor):** Rodo Machine Learning (Granite 4.0 Micro) para qualificar a intenção e gerar o LTV Preditivo.
 4. **Envio para as Plataformas:** O Facebook/Google/LinkedIn recebem um payload limpo (sem bot) recheado com valor financeiro de intenção extrema.
 5. **Máquina Autônoma (Background):** Meu banco SQLite (D1) retroalimenta os processos de Clustering (Fase 1) e Bidding (Fase 2) de forma autônoma pelas costas do usuário (`ctx.waitUntil`).
 
@@ -25,6 +25,25 @@ Meu ecossistema opera como um Cérebro de Conversão Privado na borda. Quando um
 
 ---
 
+## 📋 CHANGELOG v2.2.0 (10 de Abril de 2026)
+
+### 🤖 AI Engine Upgrade — Novos Modelos
+
+- **LTV Prediction**: `@cf/meta/llama-3.1-8b-instruct` → **`@cf/ibm-granite/granite-4.0-h-micro`** (menor latência, otimizado para edge e function calling)
+- **ML Clustering**: algoritmo LLM simulado → **K-means vetorial real** com embeddings `@cf/baai/bge-m3` (distância cosseno, K-means++ inicialização, silhouette score real)
+- Granite continua sendo usado para naming dos segmentos pós-clustering
+
+### 🧹 Limpeza (Zero Lixo)
+
+- Removido: detecção de emails descartáveis (mailinator, guerrilla, tempmail, etc.) do Fraud Gate e do agente `fraud-detection-agent.md`
+- Removido: secrets `WEBHOOK_SECRET_HOTMART` e `WEBHOOK_SECRET_KIWIFY` (wrangler + wrangler.toml)
+
+### 🔧 Observability
+
+- Adicionado bloco `[observability]` no `wrangler.toml` (`logs.enabled = true`, `traces.enabled = false`)
+
+---
+
 ## 📋 CHANGELOG v2.0.7 (10 de Abril de 2026)
 
 ### 🔧 Audit Completo — 45 Agentes
@@ -78,7 +97,7 @@ Meu ecossistema opera como um Cérebro de Conversão Privado na borda. Quando um
 - **`GET  /api/fraud/blocklist`** — IPs/fingerprints atualmente bloqueados
 - **`POST /api/fraud/blocklist/add`** — Bloquear IP ou fingerprint (via KV, efeito imediato)
 - **`DELETE /api/fraud/blocklist/remove`** — Remover do blocklist
-- Sinais detectados: bot_score, datacenter IP, velocity attack, email descartável, headless UA, sem Accept-Language
+- Sinais detectados: bot_score, datacenter IP, velocity attack, headless UA, sem Accept-Language
 - Schema D1: `fraud_signals`, `fraud_alerts` + VIEW `v_fraud_dashboard`
 - Agente: `fraud-detection-agent.md`
 
@@ -98,7 +117,7 @@ graph TD
     FraudGate -->|score ≥ 80: Silent Drop 200| Void[/dev/null]
     FraudGate -->|score < 80: Permitido| Worker[Cloudflare Worker Agent]
     Worker -->|Identity Graph + _cdp_uid| D1[(D1 SQL — 21 tabelas)]
-    Worker -->|LTV + A/B Prompt| AI[Workers AI Llama 3.1 8B]
+    Worker -->|LTV + A/B Prompt| AI[Workers AI Granite 4.0 Micro]
     Worker -->|Segmento ML| Cluster[ML Clustering Engine]
     Cluster -->|Bid otimizado| Bidding[Bidding Recommendations]
     Worker -->|Background| Queue[Cloudflare Queues]
@@ -138,7 +157,7 @@ O sistema é composto por **43+ agentes** coordenados pelo **Master Orchestrator
 ### 🤖 Enterprise Intelligence (Fase 1–4)
 | Agente | Endpoint Principal | Impacto |
 |---|---|---|
-| **ML Clustering Agent** | `POST /api/segmentation/cluster` | Segmentação K-means/DBSCAN/Hierarchical |
+| **ML Clustering Agent** | `POST /api/segmentation/cluster` | K-means vetorial real (bge-m3 embeddings + Granite naming) |
 | **Bidding Agent** | `POST /api/bidding/recommend` | -20% CPA via bid por segmento de LTV |
 | **A/B LTV Agent** | `POST /api/ltv/ab-test/create` | +25% precisão LTV via test de prompts |
 | **Fraud Detection Agent** | Auto em `/track` | Bloqueia click fraud, bots, velocity attacks |
@@ -187,7 +206,7 @@ POST /track (evento Lead)
   ├─ [2] 🔮 A/B LTV Testing — sorteia variação ativa (KV cache ~0ms)
   │         └─ passa customSystemPrompt para predictLtv()
   │
-  ├─ [3] 🧮 LTV Prediction — Workers AI Llama 3.1 8B
+  ├─ [3] 🧮 LTV Prediction — Workers AI Granite 4.0 Micro
   │         └─ Score 0-100 → class High/Medium/Low → valor em BRL
   │
   ├─ [4] 💾 D1 Writes (background via ctx.waitUntil)
@@ -286,8 +305,6 @@ wrangler deploy
 |---|---|---|
 | `/track` | POST | Evento principal (browser → CAPI) |
 | `/health` | GET | Smoke test completo |
-| `/webhook/hotmart` | POST | Webhook Hotmart Purchase |
-| `/webhook/kiwify` | POST | Webhook Kiwify Purchase |
 | `/webhook/ticto` | POST | Webhook Ticto Purchase |
 
 ### Intelligence ML

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

@@ -467,9 +467,10 @@ await env.AUDIT_LOGS.put(logKey, JSON.stringify({
 
 ### Modelo em Uso
 ```
-@cf/meta/llama-3.1-8b-instruct
-Custo: ~10.000 neurônios/requisição
-Limite Free: 10.000 neurônios/dia (~1.000 predições/dia)
+@cf/ibm-granite/granite-4.0-h-micro   ← LTV Prediction + Naming de Clusters
+@cf/baai/bge-m3         ← Embeddings para K-means vetorial (ML Clustering)
+Custo Granite: ~20-35 neurônios/requisição (3x mais eficiente que Llama 3.1 8B)
+Limite Free: 10.000 neurônios/dia (~350 predições/dia com Granite)
 ```
 
 ### Uso no Worker (LTV Prediction)
@@ -485,7 +486,7 @@ async function predictLtv(leadData, env) {
       Responda apenas: {"class": "high|medium|low", "value": 0-1000}
     `;
 
-    const response = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
+    const response = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
       messages: [{ role: 'user', content: prompt }],
       max_tokens: 50
     });

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

@@ -71,7 +71,6 @@ checkFraudGate(env, request, payload)
 | IP de datacenter | ASN = AWS, GCP, Azure, DigitalOcean, Linode | +35 pts |
 | Sem headers de browser | Accept-Language ausente | +20 pts |
 | Geo impossível | IP country ≠ país esperado (BR fora da LATAM) | +10 pts |
-| Email temporário | @mailinator, @guerrilla, @tempmail, etc. | +25 pts |
 
 ### 4. Threshold de Ação
 ```

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

@@ -43,7 +43,7 @@ import { predictLtv } from './ltv-predictor.js';
  * @param {Request} request - request original
  */
 async function dispatchLinkedIn(env, leadData, request) {
-  // 1. Obter LTV predito pelo ML (Workers AI — Llama 3.1 8B)
+  // 1. Obter LTV predito pelo ML (Workers AI — Granite 4.0 Micro)
   let conversionValue = 0;
   try {
     const ltvResult = await predictLtv(env, leadData, request);

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.1-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/ibm-granite/granite-4.0-h-micro', ...)` 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."
@@ -27,7 +27,7 @@ Sempre que o Orquestrador invocar a Otimização de Baleias (LTV Prediction):
 - Dados de UTM: `utm_source`, `utm_medium`, `utm_campaign`
 - `request.cf.asOrganization` e `request.cf.country` (sinais de qualidade do tráfego)
 - Histórico D1 do `_cdp_uid`: páginas visitadas, tempo na página, eventos anteriores
-- Binding `env.AI` (Cloudflare Workers AI — `@cf/meta/llama-3.1-8b-instruct`)
+- Binding `env.AI` (Cloudflare Workers AI — `@cf/ibm-granite/granite-4.0-h-micro`)
 
 ## RESPONSABILIDADE
 
@@ -35,7 +35,7 @@ Sempre que o Orquestrador invocar a Otimização de Baleias (LTV Prediction):
 - Classificar o lead em `predicted_ltv_class: 'High' | 'Medium' | 'Low'`
 - Substituir `value: 0` do evento `Lead` pelo valor preditivo antes do dispatch CAPI/GA4/TikTok
 - Registrar no D1 `identity_graph`: `predicted_ltv`, `predicted_ltv_class`
-- Consumo máximo: ~10.000 Neurons/dia (Free tier Cloudflare AI)
+- Consumo: ~20–35 neurônios/request com Granite 4.0 Micro (~350 predições/dia no free tier, ilimitado no paid)
 
 ## SAÍDA
 
@@ -44,7 +44,7 @@ Sempre que o Orquestrador invocar a Otimização de Baleias (LTV Prediction):
   "arquivos_criados": [
     "cloudflare/ltv-predictor.js"
   ],
-  "modelo_ai": "@cf/meta/llama-3.1-8b-instruct",
+  "modelo_ai": "@cf/ibm-granite/granite-4.0-h-micro",
   "campo_substituido": "value",
   "exemplo": {
     "evento": "Lead",

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

@@ -128,74 +128,74 @@ is_business_hours = 1 if 9 <= hour_of_day <= 18 else 0
 
 ---
 
-## Fase 2 — K-Means Clustering (Workers AI)
+## Fase 2 — K-Means Vetorial Real (embeddinggemma-300m + K-means em JS)
 
-### 2.1 Prompt para Workers AI
+> **Arquitetura atual:** O clustering não usa LLM para fazer os cálculos matemáticos.
+> Em vez disso, usa **embeddings semânticos reais** + **K-means implementado em JavaScript**,
+> com o Granite usado **apenas para nomear** os clusters resultantes.
 
-```python
-# Enviar para: env.AI.run('@cf/meta/llama-3.1-8b-instruct', ...)
+### 2.1 Pipeline de Clustering
 
-PROMPT_CLUSTERING = f"""
-You are a Machine Learning expert specializing in customer segmentation.
+```
+100 leads (sample) → perfil textual → embeddinggemma-300m → vetores 768d
+                                                                   ↓
+                                                    K-means++ (cosine distance, JS puro)
+                                                                   ↓
+                                               silhouette score real calculado em JS
+                                                                   ↓
+                                   Granite 4.0 Micro nomeia cada cluster (1 call de LLM)
+```
 
-You will receive {n_leads} customers with {features} each.
-Your task: Perform K-means clustering to group customers into {n_clusters} segments.
+### 2.2 Modelos Workers AI utilizados
 
-INPUTS:
-- leads: JSON array of customer objects
-- features: list of feature names (ltv, behavior_score, engagement_score, etc.)
-- n_clusters: number of segments to create (3-10)
+| Modelo | ID | Uso |
+|---|---|---|
+| **Granite 4.0 Micro** | `@cf/ibm-granite/granite-4.0-h-micro` | LTV Prediction + Naming de clusters |
+| **EmbeddingGemma 300M** | `@cf/baai/bge-m3` | Embeddings semânticos para K-means |
 
-TASK:
-1. Normalize all features to 0-1 range (min-max normalization)
-2. Initialize K-means centroids randomly
-3. Assign each lead to nearest centroid (Euclidean distance)
-4. Recalculate centroids as mean of assigned points
-5. Iterate until convergence (max 100 iterations)
-6. Calculate Silhouette Score for each cluster (cohesion vs separation)
+### 2.3 Perfil textual por lead (input para embedding)
 
-OUTPUT (JSON only):
-{{
-  "clusters": [
-    {{
-      "cluster_id": 0,
-      "name": "Segmento 0 - [AUTO-GENERATED DESCRIPTIVE NAME]",
-      "size": 123,
-      "percentage": 0.25,
-      "characteristics": {{
-        "avg_ltv": 497.50,
-        "avg_behavior_score": 75.3,
-        "avg_engagement_score": 82.1,
-        "dominant_countries": ["BR", "AR"],
-        "dominant_states": ["SP", "RJ"],
-        "dominant_utm_source": ["facebook", "google"],
-        "top_features": ["ltv", "behavior_score", "engagement_score"]
-      }},
-      "centroid": {{
-        "ltv": 0.75,
-        "behavior_score": 0.80,
-        "engagement_score": 0.85
-      }},
-      "sample_leads": [lead_id_1, lead_id_2, lead_id_3]
-    }},
-    ...
-  ],
-  "silhouette_scores": {{
-    "overall": 0.62,
-    "by_cluster": [0.71, 0.58, 0.65, ...]
-  }},
-  "convergence": {{
-    "iterations": 47,
-    "final_inertia": 1523.45
-  }}
-}}
+```javascript
+function _buildLeadProfile(l) {
+  return [
+    `LTV: ${l.predicted_ltv_class || 'desconhecido'}`,
+    `engajamento: ${Math.round(l.engagement_score || 0)}`,
+    `intenção: ${l.intention_level || 'desconhecida'}`,
+    `origem: ${l.utm_source || 'direto'}`,
+    `canal: ${l.utm_medium || 'desconhecido'}`,
+    `país: ${l.country || 'BR'}`,
+    `hora: ${l.hour_of_day || 12}h`,
+    (l.is_weekend ? 'fim-de-semana' : 'dia-útil'),
+    `recência: ${l.days_since_lead || 0} dias`,
+  ].filter(Boolean).join(', ');
+}
+```
 
-IMPORTANT:
-- Generate descriptive names for segments based on cluster characteristics
-- Example: "Segmento 0 - Alto Valor + Alto Engajamento (SP)"
-- Example: "Segmento 1 - Lead Quente + Alta Intenção (RJ)"
-- Return ONLY valid JSON, no explanations
-"""
+### 2.4 Chamada de embeddings em batch
+
+```javascript
+// Embeds até 100 perfis em uma única chamada
+const embRes = await env.AI.run('@cf/baai/bge-m3', { text: profiles });
+const vectors = embRes.data; // float32[][] — shape [N, 768]
+```
+
+### 2.5 K-means vetorial (cosine distance)
+
+```javascript
+// Inicialização K-means++ → iterações até convergência → assignments finais
+const { assignments } = _kmeansRun(vectors, nClusters); // implementado em worker.js
+const silhouetteScore = _silhouette(vectors, assignments, nClusters); // score real
+```
+
+### 2.6 Naming dos clusters via Granite (único uso de LLM)
+
+```javascript
+// Granite recebe apenas as estatísticas agregadas por cluster
+// Retorna nome descritivo + recomendação de campanha em português
+const nameRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
+  messages: [{ role: 'user', content: namingPrompt }],
+  max_tokens: 800
+});
 ```
 
 ### 2.2 Features para K-Means
@@ -484,20 +484,30 @@ export async function onRequestGet(context: EventContext<Env>) {
   // Feature Engineering
   const features = extractFeatures(leads);
   
-  // Clustering via Workers AI
-  const clusters = await context.env.AI.run(
-    '@cf/meta/llama-3.1-8b-instruct',
-    { messages: [{ role: 'user', content: getClusteringPrompt(features, nClusters) }] }
+  // 1. Embeddings reais via embeddinggemma-300m
+  const profiles = sample.map(_buildLeadProfile);
+  const embRes   = await context.env.AI.run('@cf/baai/bge-m3', { text: profiles });
+  const vectors  = embRes.data; // vetores 768d
+
+  // 2. K-means vetorial real (JS puro, cosine distance)
+  const { assignments } = _kmeansRun(vectors, nClusters);
+  const silhouetteScore = _silhouette(vectors, assignments, nClusters);
+
+  // 3. Granite apenas para nomear clusters
+  const nameRes  = await context.env.AI.run('@cf/ibm-granite/granite-4.0-h-micro',
+    { messages: [{ role: 'user', content: getNamingPrompt(clusterStats) }], max_tokens: 800 }
   );
-  
-  // Persistir no D1
+
+  // 4. Persistir no D1
   await saveClusters(context.env.DB, clusters, algorithm);
-  
+
   return Response.json({
     success: true,
     algorithm,
+    engine: 'embeddinggemma-300m + kmeans vetorial',
     n_clusters: nClusters,
-    clusters: JSON.parse(clusters.response),
+    silhouette_score: silhouetteScore,
+    clusters,
     generated_at: new Date().toISOString()
   });
 }
@@ -658,7 +668,7 @@ interface SegmentationAPI {
 
 ```
 [ ] Feature Engineering Pipeline implementada
-[ ] K-means Clustering via Workers AI
+[ ] K-means Clustering vetorial (embeddinggemma-300m + JS)
 [ ] DBSCAN Clustering para anomalias
 [ ] Hierarchical Clustering (drill-down)
 [ ] Auto-Interpretação de segmentos
@@ -679,7 +689,8 @@ interface SegmentationAPI {
 | `Clusters vazios` | Menos de `min_data_points` no D1 | Aumentar `max_data_age_months` ou aguardar mais dados |
 | `Silhouette Score < 0.3` | Clusters não são separáveis | Aumentar `n_clusters` ou usar features melhores |
 | `Outliers excessivos` | Epsilon/MinPts muito agressivos no DBSCAN | Ajustar parâmetros de detecção de anomalias |
-| `Workers AI timeout` | Prompt muito longo ou muitos dados | Dividir em batches de 100-200 leads por request |
+| `embeddinggemma timeout` | Batch maior que 100 perfis | Limitar sample a 100 leads (padrão atual) |
+| `vectors insuficientes` | embeddinggemma retornou menos vetores que nClusters | Reduzir nClusters ou verificar resposta da API |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-edge",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "CDP Edge - Quantum Tracking - Sistema multi-agente para tracking digital Cloudflare Native (Workers + D1)",
   "main": "dist/index.js",
   "type": "module",

package/server-edge-tracker/index.js

@@ -191,7 +191,7 @@ export default {
       }
 
       try {
-        await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
+        await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
           messages: [{ role: 'user', content: 'ping' }],
           max_tokens: 1,
         });

package/server-edge-tracker/modules/ml/fraud.js

@@ -6,13 +6,6 @@
 import { sha256, tryParseJson } from '../utils.js';
 
 // ── Listas de detecção ────────────────────────────────────────────────────────
-export const DISPOSABLE_EMAIL_DOMAINS = new Set([
-  'mailinator.com','guerrillamail.com','tempmail.com','throwaway.email',
-  'yopmail.com','sharklasers.com','guerrillamailblock.com','spam4.me',
-  '10minutemail.com','trashmail.com','maildrop.cc','fakeinbox.com',
-  'dispostable.com','getairmail.com','mailnull.com',
-]);
-
 export const DATACENTER_PATTERNS = /amazon|google|microsoft|digitalocean|linode|ovh|vultr|hetzner|contabo|cloudflare|packet|rackspace|leaseweb/i;
 
 // ── checkFraudGate — roda ANTES de qualquer processamento de evento ────────────
@@ -64,15 +57,7 @@ export async function checkFraudGate(env, request, payload) {
       result.score += 20; result.reasons.push('no_accept_language');
     }
 
-    // 6. Email descartável
-    if (email) {
-      const domain = email.split('@')[1]?.toLowerCase();
-      if (domain && DISPOSABLE_EMAIL_DOMAINS.has(domain)) {
-        result.score += 25; result.reasons.push('disposable_email');
-      }
-    }
-
-    // 7. Velocity check via KV
+    // 6. Velocity check via KV
     if (env.GEO_CACHE && ip) {
       const velKey1h = `fraud_velocity:${ip}:h`;
       const velStr   = await env.GEO_CACHE.get(velKey1h);

package/server-edge-tracker/modules/ml/ltv.js

@@ -161,7 +161,7 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
         { role: 'system', content: systemContent },
         { role: 'user', content: JSON.stringify(userContext) },
       ];
-      const aiRes = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', { messages: prompt, max_tokens: 32 });
+      const aiRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', { messages: prompt, max_tokens: 32 });
       const parsed = JSON.parse(aiRes.response.trim());
       if (typeof parsed.adjustment === 'number') {
         aiAdjustment = Math.max(-10, Math.min(10, parsed.adjustment));

package/server-edge-tracker/modules/ml/segmentation.js

@@ -5,14 +5,84 @@
 
 import { tryParseJson } from '../utils.js';
 
+// ── Helpers K-means vetorial ──────────────────────────────────────────────────
+
+function _cosDist(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) { dot += a[i]*b[i]; na += a[i]*a[i]; nb += b[i]*b[i]; }
+  return 1 - dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10);
+}
+
+function _kmeansRun(vectors, k, maxIter = 25) {
+  const n = vectors.length, dim = vectors[0].length;
+  const centroids = [vectors[Math.floor(Math.random() * n)]];
+  while (centroids.length < k) {
+    const dists = vectors.map(v => Math.min(...centroids.map(c => _cosDist(v, c))));
+    const sum = dists.reduce((a, b) => a + b, 0);
+    let r = Math.random() * sum, cumul = 0;
+    for (let i = 0; i < n; i++) { cumul += dists[i]; if (cumul >= r) { centroids.push(vectors[i]); break; } }
+    if (centroids.length < k) centroids.push(vectors[Math.floor(Math.random() * n)]);
+  }
+  let assignments = new Array(n).fill(0);
+  for (let iter = 0; iter < maxIter; iter++) {
+    let changed = false;
+    for (let i = 0; i < n; i++) {
+      let best = 0, bestD = Infinity;
+      for (let c = 0; c < k; c++) { const d = _cosDist(vectors[i], centroids[c]); if (d < bestD) { bestD = d; best = c; } }
+      if (assignments[i] !== best) { assignments[i] = best; changed = true; }
+    }
+    if (!changed) break;
+    for (let c = 0; c < k; c++) {
+      const members = vectors.filter((_, i) => assignments[i] === c);
+      if (!members.length) continue;
+      for (let d = 0; d < dim; d++) centroids[c][d] = members.reduce((s, v) => s + v[d], 0) / members.length;
+    }
+  }
+  return { assignments, centroids };
+}
+
+function _silhouette(vectors, assignments, k) {
+  const n = vectors.length;
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const ci = assignments[i];
+    const same = vectors.filter((_, j) => j !== i && assignments[j] === ci);
+    const a = same.length ? same.reduce((s, v) => s + _cosDist(vectors[i], v), 0) / same.length : 0;
+    let b = Infinity;
+    for (let c = 0; c < k; c++) {
+      if (c === ci) continue;
+      const other = vectors.filter((_, j) => assignments[j] === c);
+      if (other.length) b = Math.min(b, other.reduce((s, v) => s + _cosDist(vectors[i], v), 0) / other.length);
+    }
+    total += b === Infinity ? 0 : (b - a) / Math.max(a, b);
+  }
+  return Math.round((total / n) * 1000) / 1000;
+}
+
+function _buildLeadProfile(l) {
+  return [
+    `LTV: ${l.predicted_ltv_class || 'desconhecido'}`,
+    `engajamento: ${Math.round(l.engagement_score || 0)}`,
+    `intenção: ${l.intention_level || 'desconhecida'}`,
+    `origem: ${l.utm_source || 'direto'}`,
+    `canal: ${l.utm_medium || 'desconhecido'}`,
+    `país: ${l.country || 'BR'}`,
+    `estado: ${l.state || ''}`,
+    `hora: ${l.hour_of_day || 12}h`,
+    (l.is_weekend ? 'fim-de-semana' : 'dia-útil'),
+    `recência: ${l.days_since_lead || 0} dias`,
+  ].filter(Boolean).join(', ');
+}
+
 // ── POST /api/segmentation/cluster ────────────────────────────────────────────
+// Clustering real: embeddinggemma-300m → K-means vetorial → Granite para nomear
 export async function handleSegmentationCluster(env, request, headers) {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
-  if (!env.AI) return new Response(JSON.stringify({ error: 'Workers AI não configurado (verifique binding AI no wrangler.toml)' }), { status: 503, headers });
+  if (!env.AI) return new Response(JSON.stringify({ error: 'Workers AI não configurado' }), { status: 503, headers });
 
   const url            = new URL(request.url);
   const algorithm      = url.searchParams.get('algorithm') || 'kmeans';
-  const nClusters      = Math.min(10, Math.max(3, parseInt(url.searchParams.get('n_clusters') || '5')));
+  const nClusters      = Math.min(10, Math.max(2, parseInt(url.searchParams.get('n_clusters') || '5')));
   const clientVertical = url.searchParams.get('vertical') || 'general';
   const forceRecluster = url.searchParams.get('force') === 'true';
 
@@ -21,16 +91,14 @@ export async function handleSegmentationCluster(env, request, headers) {
   }
 
   try {
-    // 1. Cluster recente? Evitar re-clustering desnecessário (< 7 dias)
     if (!forceRecluster) {
       const existing = await env.DB.prepare(`
         SELECT id, created_at, cluster_name FROM ml_segments
         WHERE clustering_algorithm = ? AND is_active = 1 AND client_vertical = ?
         ORDER BY created_at DESC LIMIT 1
       `).bind(algorithm, clientVertical).first();
-
       if (existing) {
-        const ageDays = (Date.now() - new Date(existing.created_at).getTime()) / (1000 * 60 * 60 * 24);
+        const ageDays = (Date.now() - new Date(existing.created_at).getTime()) / 864e5;
         if (ageDays < 7) {
           return new Response(JSON.stringify({
             success: true, message: 'Cluster existente ainda válido (< 7 dias). Use ?force=true para re-clustering.',
@@ -41,7 +109,6 @@ export async function handleSegmentationCluster(env, request, headers) {
       }
     }
 
-    // 2. Extrair leads históricos do D1 (últimos 6 meses, excluindo bots confirmados)
     const leadsRes = await env.DB.prepare(`
       SELECT id, predicted_ltv_class, engagement_score, intention_level,
              country, state, utm_source, utm_medium, bot_score,
@@ -49,162 +116,125 @@ export async function handleSegmentationCluster(env, request, headers) {
              CAST(julianday('now') - julianday(created_at) AS INTEGER) AS days_since_lead,
              CASE WHEN strftime('%w', created_at) IN ('0','6') THEN 1 ELSE 0 END AS is_weekend
       FROM leads
-      WHERE created_at >= datetime('now', '-6 months')
-        AND (bot_score IS NULL OR bot_score < 2)
-      ORDER BY RANDOM()
-      LIMIT 2000
+      WHERE created_at >= datetime('now', '-6 months') AND (bot_score IS NULL OR bot_score < 2)
+      ORDER BY RANDOM() LIMIT 2000
     `).all();
 
     const leads = leadsRes.results || [];
-
     if (leads.length < 50) {
-      return new Response(JSON.stringify({
-        error: 'Dados insuficientes para clustering. Mínimo: 50 leads nos últimos 6 meses.',
-        leads_found: leads.length, required: 50,
-      }), { status: 400, headers });
-    }
-
-    // 3. Feature Engineering — normalização 0–1
-    const features = leads.map(l => ({
-      id:         l.id,
-      ltv:        l.predicted_ltv_class === 'High' ? 1 : (l.predicted_ltv_class === 'Medium' ? 0.5 : 0),
-      engagement: Math.min((l.engagement_score || 0) / 100, 1),
-      intention:  l.intention_level === 'comprador' || l.intention_level === 'high_intent' ? 1
-                : l.intention_level === 'interessado' ? 0.6
-                : l.intention_level === 'curioso'     ? 0.3 : 0,
-      recency:    Math.max(0, 1 - (l.days_since_lead || 0) / 180),
-      hour:       (l.hour_of_day || 12) / 23,
-      is_weekend: l.is_weekend || 0,
-      is_br:      l.country === 'BR' ? 1 : 0,
-      is_paid:    ['facebook','google','tiktok','instagram','youtube'].includes((l.utm_source || '').toLowerCase()) ? 1 : 0,
-    }));
-
-    // 4. Prompt para Workers AI
-    const sampleSize = Math.min(features.length, 100);
-    const sample     = features.slice(0, sampleSize);
-
-    const clusteringPrompt =
-`You are a customer segmentation ML expert. Perform ${algorithm} clustering on ${sampleSize} customers into ${nClusters} segments.
-
-Customer features (all normalized 0-1):
-- ltv: predicted lifetime value (0=Low, 0.5=Medium, 1=High)
-- engagement: browser engagement score
-- intention: purchase intention (0=none, 0.3=curious, 0.6=interested, 1=buyer)
-- recency: lead recency (1=today, 0=6 months ago)
-- hour: conversion hour of day
-- is_weekend: converted on weekend (0/1)
-- is_br: lead from Brazil (0/1)
-- is_paid: from paid traffic channel (0/1)
-
-Data (${sampleSize} customers): ${JSON.stringify(sample.slice(0, 50))}
-
-Return ONLY valid JSON, zero explanation:
-{
-  "clusters": [
-    {
-      "cluster_id": 0,
-      "name": "[Nome Descritivo em Português]",
-      "size": ${Math.round(sampleSize / nClusters)},
-      "percentage": ${Math.round(100 / nClusters)},
-      "characteristics": {
-        "avg_ltv_class": 0.5,
-        "avg_behavior_score": 0.5,
-        "avg_engagement_score": 0.5,
-        "avg_intention_level": 0.5,
-        "avg_days_since_lead": 30,
-        "dominant_countries": ["BR"],
-        "dominant_states": ["SP", "RJ"],
-        "dominant_utm_sources": ["facebook"],
-        "top_features": ["ltv", "engagement"]
-      },
-      "centroid": { "ltv": 0.5, "engagement": 0.5, "intention": 0.5 },
-      "action_recommendation": "[Recomendação de campanha específica para este segmento]"
+      return new Response(JSON.stringify({ error: 'Dados insuficientes para clustering. Mínimo: 50 leads.', leads_found: leads.length, required: 50 }), { status: 400, headers });
     }
-  ],
-  "silhouette_score": 0.65,
-  "total_processed": ${sampleSize}
-}`;
 
-    // 5. Workers AI
     const startTime = Date.now();
-    const aiRes = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
-      messages:   [{ role: 'user', content: clusteringPrompt }],
-      max_tokens: 2000,
-    });
-    const duration = Date.now() - startTime;
-
-    if (!aiRes?.response) throw new Error('Workers AI não retornou resposta');
+    const sample    = leads.slice(0, 100);
+    const profiles  = sample.map(_buildLeadProfile);
+
+    // Embeddings reais via embeddinggemma-300m
+    const embRes = await env.AI.run('@cf/baai/bge-m3', { text: profiles });
+    const vectors = embRes.data;
+    if (!vectors || vectors.length < nClusters) throw new Error(`embeddinggemma retornou ${vectors?.length ?? 0} vetores`);
+
+    // K-means vetorial real
+    const { assignments } = _kmeansRun(vectors, nClusters);
+    const silhouetteScore = _silhouette(vectors, assignments, nClusters);
+
+    // Agregação por cluster para nomear com Granite
+    const clusterStats = Array.from({ length: nClusters }, (_, c) => {
+      const members = sample.filter((_, i) => assignments[i] === c);
+      if (!members.length) return null;
+      const ltvMap = { High: 1, Medium: 0.5, Low: 0 };
+      const avgLtv  = members.reduce((s, l) => s + (ltvMap[l.predicted_ltv_class] ?? 0), 0) / members.length;
+      const avgEng  = members.reduce((s, l) => s + (l.engagement_score || 0), 0) / members.length;
+      const avgDays = members.reduce((s, l) => s + (l.days_since_lead || 0), 0) / members.length;
+      const freq = (arr) => arr.length ? [...arr.reduce((m,s) => m.set(s,(m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : null;
+      return {
+        c, size: members.length, pct: Math.round(members.length / sample.length * 100),
+        avgLtv, avgEng, avgDays,
+        topSource: freq(members.map(l => l.utm_source).filter(Boolean)) || 'direto',
+        topState:  freq(members.map(l => l.state).filter(Boolean))      || 'BR',
+        topIntent: freq(members.map(l => l.intention_level).filter(Boolean)) || 'desconhecida',
+      };
+    }).filter(Boolean);
+
+    // Granite apenas para nomear segmentos
+    const namingPrompt =
+`Você é especialista em segmentação de clientes. Dê um nome descritivo em português e uma recomendação de campanha para cada segmento. Retorne SOMENTE JSON válido:
+{"segments":[{"cluster_id":0,"name":"...","action":"..."},...]}
+
+${clusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento=${s.avgEng.toFixed(0)}, intenção="${s.topIntent}", origem="${s.topSource}", estado="${s.topState}", recência=${s.avgDays.toFixed(0)} dias, tamanho=${s.size}`).join('\n')}`;
+
+    const nameRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', { messages: [{ role: 'user', content: namingPrompt }], max_tokens: 800 });
+    let clusterNames = {};
+    try {
+      const m = (nameRes?.response || '').match(/\{[\s\S]*\}/);
+      if (m) (JSON.parse(m[0]).segments || []).forEach(s => { clusterNames[s.cluster_id] = { name: s.name, action: s.action }; });
+    } catch { /* usa nomes fallback */ }
 
-    const jsonMatch = aiRes.response.trim().match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error('Resposta do Workers AI não contém JSON válido');
-    const mlResult = JSON.parse(jsonMatch[0]);
+    const duration = Date.now() - startTime;
 
-    if (!Array.isArray(mlResult.clusters) || mlResult.clusters.length === 0) {
-      throw new Error('Workers AI não retornou clusters válidos');
-    }
+    const clusters = clusterStats.map(s => ({
+      cluster_id: s.c,
+      name: clusterNames[s.c]?.name || `Segmento ${s.c + 1}`,
+      size: s.size, percentage: s.pct,
+      action_recommendation: clusterNames[s.c]?.action || '',
+      characteristics: {
+        avg_ltv_class: s.avgLtv, avg_engagement_score: s.avgEng,
+        avg_intention_level: s.avgLtv, avg_days_since_lead: s.avgDays,
+        dominant_countries: ['BR'], dominant_states: [s.topState],
+        dominant_utm_sources: [s.topSource], top_features: ['ltv', 'engagement', 'intention'],
+      },
+    }));
 
-    // 6. Inativar clusters anteriores
     await env.DB.prepare(`UPDATE ml_segments SET is_active = 0 WHERE clustering_algorithm = ? AND client_vertical = ? AND is_active = 1`).bind(algorithm, clientVertical).run();
 
-    // 7. Persistir novos clusters
     const now = new Date().toISOString();
-    for (const cluster of mlResult.clusters) {
-      const ch = cluster.characteristics || {};
+    for (const cluster of clusters) {
+      const ch = cluster.characteristics;
       await env.DB.prepare(`
         INSERT INTO ml_segments (
-          cluster_id, cluster_name, clustering_algorithm, client_vertical,
-          size, percentage, avg_ltv_class, avg_behavior_score, avg_engagement_score,
-          avg_intention_level, avg_days_since_lead,
+          cluster_id, cluster_name, clustering_algorithm, client_vertical, size, percentage,
+          avg_ltv_class, avg_behavior_score, avg_engagement_score, avg_intention_level, avg_days_since_lead,
           dominant_countries, dominant_states, dominant_utm_sources, dominant_features,
           silhouette_score, action_recommendations, bid_recommendations, campaign_recommendations,
           is_active, created_at, updated_at
         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?)
       `).bind(
-        cluster.cluster_id || 0, cluster.name || `Segmento ${cluster.cluster_id}`, algorithm, clientVertical,
-        cluster.size || 0, cluster.percentage || 0,
-        ch.avg_ltv_class || 0, ch.avg_behavior_score || 0, ch.avg_engagement_score || 0,
-        ch.avg_intention_level || 0, ch.avg_days_since_lead || 0,
-        JSON.stringify(ch.dominant_countries || ['BR']), JSON.stringify(ch.dominant_states || []),
-        JSON.stringify(ch.dominant_utm_sources || []), JSON.stringify(ch.top_features || []),
-        mlResult.silhouette_score || 0,
-        JSON.stringify([cluster.action_recommendation || '']), JSON.stringify([]), JSON.stringify([]),
+        cluster.cluster_id, cluster.name, algorithm, clientVertical, cluster.size, cluster.percentage,
+        ch.avg_ltv_class, ch.avg_engagement_score, ch.avg_engagement_score, ch.avg_intention_level, ch.avg_days_since_lead,
+        JSON.stringify(ch.dominant_countries), JSON.stringify(ch.dominant_states),
+        JSON.stringify(ch.dominant_utm_sources), JSON.stringify(ch.top_features),
+        silhouetteScore,
+        JSON.stringify([cluster.action_recommendation]), JSON.stringify([]), JSON.stringify([]),
         now, now,
       ).run();
     }
 
-    // 8. Log no histórico
     try {
       await env.DB.prepare(`
-        INSERT INTO ml_clustering_history (
-          clustering_id, started_at, completed_at, algorithm,
-          n_leads_processed, n_clusters_created, total_duration_ms,
-          workers_ai_neurons_used, status, parameters, results_summary
-        ) VALUES (0, ?, datetime('now'), ?, ?, ?, ?, ?, 'completed', ?, ?)
-      `).bind(
-        new Date(startTime).toISOString(), algorithm, leads.length, mlResult.clusters.length,
-        duration, Math.ceil(duration * 0.01),
-        JSON.stringify({ algorithm, n_clusters: nClusters, vertical: clientVertical }),
-        JSON.stringify({ clusters: mlResult.clusters.length, silhouette: mlResult.silhouette_score }),
+        INSERT INTO ml_clustering_history (clustering_id, started_at, completed_at, algorithm, n_leads_processed, n_clusters_created, total_duration_ms, workers_ai_neurons_used, status, parameters, results_summary)
+        VALUES (0, ?, datetime('now'), ?, ?, ?, ?, ?, 'completed', ?, ?)
+      `).bind(new Date(startTime).toISOString(), algorithm, leads.length, clusters.length, duration, Math.ceil(duration * 0.01),
+        JSON.stringify({ algorithm, n_clusters: nClusters, vertical: clientVertical, engine: 'embeddinggemma-300m+kmeans' }),
+        JSON.stringify({ clusters: clusters.length, silhouette: silhouetteScore }),
       ).run();
     } catch (e) { console.error('[Segmentation] history log error:', e.message); }
 
     return new Response(JSON.stringify({
-      success: true, algorithm, n_clusters: mlResult.clusters.length, client_vertical: clientVertical,
-      leads_analyzed: leads.length, duration_ms: duration, silhouette_score: mlResult.silhouette_score || null,
-      clusters: mlResult.clusters, generated_at: now,
+      success: true, algorithm, engine: 'embeddinggemma-300m + kmeans vetorial',
+      n_clusters: clusters.length, client_vertical: clientVertical,
+      leads_analyzed: leads.length, sample_embedded: sample.length,
+      duration_ms: duration, silhouette_score: silhouetteScore,
+      clusters, generated_at: now,
     }), { status: 200, headers });
 
   } catch (err) {
     console.error('[Segmentation] cluster error:', err.message);
     try {
-      if (env.DB) {
-        await env.DB.prepare(`
-          INSERT INTO ml_clustering_history (clustering_id, started_at, algorithm, n_leads_processed, n_clusters_created, total_duration_ms, workers_ai_neurons_used, status, error_message, parameters, results_summary)
-          VALUES (0, datetime('now'), ?, 0, 0, 0, 0, 'failed', ?, ?, '{}')
-        `).bind(algorithm, err.message, JSON.stringify({ algorithm, n_clusters: nClusters })).run();
-      }
-    } catch { /* não bloquear a resposta de erro */ }
-
+      if (env.DB) await env.DB.prepare(`
+        INSERT INTO ml_clustering_history (clustering_id, started_at, algorithm, n_leads_processed, n_clusters_created, total_duration_ms, workers_ai_neurons_used, status, error_message, parameters, results_summary)
+        VALUES (0, datetime('now'), ?, 0, 0, 0, 0, 'failed', ?, ?, '{}')
+      `).bind(algorithm, err.message, JSON.stringify({ algorithm, n_clusters: nClusters })).run();
+    } catch { /* não bloquear */ }
     return new Response(JSON.stringify({ error: 'Erro ao executar clustering', message: err.message }), { status: 500, headers });
   }
 }

package/server-edge-tracker/worker.js

@@ -1903,7 +1903,7 @@ async function predictLtv(env, payload, request, customSystemPrompt = null) {
           has_phone: !!payload.phone,
         })},
       ];
-      const aiRes = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', { messages: prompt, max_tokens: 32 });
+      const aiRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', { messages: prompt, max_tokens: 32 });
       const parsed = JSON.parse(aiRes.response.trim());
       if (typeof parsed.adjustment === 'number') {
         aiAdjustment = Math.max(-10, Math.min(10, parsed.adjustment));
@@ -2415,8 +2415,82 @@ function tryParseJson(str, fallback) {
   try { return JSON.parse(str); } catch { return fallback !== undefined ? fallback : null; }
 }
 
+// ── Helpers K-means vetorial (usado pelo clustering com embeddings) ───────────
+
+function _cosDist(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) { dot += a[i]*b[i]; na += a[i]*a[i]; nb += b[i]*b[i]; }
+  return 1 - dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10);
+}
+
+function _kmeansRun(vectors, k, maxIter = 25) {
+  const n   = vectors.length;
+  const dim = vectors[0].length;
+  // K-means++ init
+  const centroids = [vectors[Math.floor(Math.random() * n)]];
+  while (centroids.length < k) {
+    const dists = vectors.map(v => Math.min(...centroids.map(c => _cosDist(v, c))));
+    const sum   = dists.reduce((a, b) => a + b, 0);
+    let r = Math.random() * sum, cumul = 0;
+    for (let i = 0; i < n; i++) { cumul += dists[i]; if (cumul >= r) { centroids.push(vectors[i]); break; } }
+    if (centroids.length < k) centroids.push(vectors[Math.floor(Math.random() * n)]);
+  }
+
+  let assignments = new Array(n).fill(0);
+  for (let iter = 0; iter < maxIter; iter++) {
+    let changed = false;
+    for (let i = 0; i < n; i++) {
+      let best = 0, bestD = Infinity;
+      for (let c = 0; c < k; c++) { const d = _cosDist(vectors[i], centroids[c]); if (d < bestD) { bestD = d; best = c; } }
+      if (assignments[i] !== best) { assignments[i] = best; changed = true; }
+    }
+    if (!changed) break;
+    // Recompute centroids
+    for (let c = 0; c < k; c++) {
+      const members = vectors.filter((_, i) => assignments[i] === c);
+      if (members.length === 0) continue;
+      for (let d = 0; d < dim; d++) centroids[c][d] = members.reduce((s, v) => s + v[d], 0) / members.length;
+    }
+  }
+  return { assignments, centroids };
+}
+
+function _silhouette(vectors, assignments, k) {
+  const n = vectors.length;
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const ci = assignments[i];
+    const sameCluster  = vectors.filter((_, j) => j !== i && assignments[j] === ci);
+    const a = sameCluster.length ? sameCluster.reduce((s, v) => s + _cosDist(vectors[i], v), 0) / sameCluster.length : 0;
+    let b = Infinity;
+    for (let c = 0; c < k; c++) {
+      if (c === ci) continue;
+      const other = vectors.filter((_, j) => assignments[j] === c);
+      if (other.length) b = Math.min(b, other.reduce((s, v) => s + _cosDist(vectors[i], v), 0) / other.length);
+    }
+    total += b === Infinity ? 0 : (b - a) / Math.max(a, b);
+  }
+  return Math.round((total / n) * 1000) / 1000;
+}
+
+function _buildLeadProfile(l) {
+  return [
+    `LTV: ${l.predicted_ltv_class || 'desconhecido'}`,
+    `engajamento: ${Math.round(l.engagement_score || 0)}`,
+    `intenção: ${l.intention_level || 'desconhecida'}`,
+    `origem: ${l.utm_source || 'direto'}`,
+    `canal: ${l.utm_medium || 'desconhecido'}`,
+    `país: ${l.country || 'BR'}`,
+    `estado: ${l.state || ''}`,
+    `hora: ${l.hour_of_day || 12}h`,
+    (l.is_weekend ? 'fim-de-semana' : 'dia-útil'),
+    `recência: ${l.days_since_lead || 0} dias`,
+  ].filter(Boolean).join(', ');
+}
+
 // ── POST /api/segmentation/cluster ───────────────────────────────────────────
-// Executa clustering K-means/DBSCAN/Hierarchical via Workers AI
+// Clustering real com embeddings (embeddinggemma-300m) + K-means vetorial
+// Granite usado apenas para nomear segmentos
 // Requer bindings: DB + AI
 async function handleSegmentationCluster(env, request, headers) {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
@@ -2424,7 +2498,7 @@ async function handleSegmentationCluster(env, request, headers) {
 
   const url = new URL(request.url);
   const algorithm      = url.searchParams.get('algorithm') || 'kmeans';
-  const nClusters      = Math.min(10, Math.max(3, parseInt(url.searchParams.get('n_clusters') || '5')));
+  const nClusters      = Math.min(10, Math.max(2, parseInt(url.searchParams.get('n_clusters') || '5')));
   const clientVertical = url.searchParams.get('vertical') || 'general';
   const forceRecluster = url.searchParams.get('force') === 'true';
 
@@ -2480,96 +2554,94 @@ async function handleSegmentationCluster(env, request, headers) {
       }), { status: 400, headers });
     }
 
-    // 3. Feature Engineering — normalização 0–1
-    const features = leads.map(l => ({
-      id:         l.id,
-      ltv:        l.predicted_ltv_class === 'High' ? 1 : (l.predicted_ltv_class === 'Medium' ? 0.5 : 0),
-      engagement: Math.min((l.engagement_score || 0) / 100, 1),
-      intention:  l.intention_level === 'comprador' || l.intention_level === 'high_intent' ? 1
-                : l.intention_level === 'interessado' ? 0.6
-                : l.intention_level === 'curioso'     ? 0.3 : 0,
-      recency:    Math.max(0, 1 - (l.days_since_lead || 0) / 180),
-      hour:       (l.hour_of_day || 12) / 23,
-      is_weekend: l.is_weekend || 0,
-      is_br:      l.country === 'BR' ? 1 : 0,
-      is_paid:    ['facebook','google','tiktok','instagram','youtube'].includes(
-                    (l.utm_source || '').toLowerCase()) ? 1 : 0,
-    }));
+    const startTime = Date.now();
 
-    // 4. Prompt para Workers AI
-    const sampleSize = Math.min(features.length, 100);
-    const sample     = features.slice(0, sampleSize);
-
-    const clusteringPrompt =
-`You are a customer segmentation ML expert. Perform ${algorithm} clustering on ${sampleSize} customers into ${nClusters} segments.
-
-Customer features (all normalized 0-1):
-- ltv: predicted lifetime value (0=Low, 0.5=Medium, 1=High)
-- engagement: browser engagement score
-- intention: purchase intention (0=none, 0.3=curious, 0.6=interested, 1=buyer)
-- recency: lead recency (1=today, 0=6 months ago)
-- hour: conversion hour of day
-- is_weekend: converted on weekend (0/1)
-- is_br: lead from Brazil (0/1)
-- is_paid: from paid traffic channel (0/1)
-
-Data (${sampleSize} customers): ${JSON.stringify(sample.slice(0, 50))}
-
-Return ONLY valid JSON, zero explanation:
-{
-  "clusters": [
-    {
-      "cluster_id": 0,
-      "name": "[Nome Descritivo em Português]",
-      "size": ${Math.round(sampleSize / nClusters)},
-      "percentage": ${Math.round(100 / nClusters)},
-      "characteristics": {
-        "avg_ltv_class": 0.5,
-        "avg_behavior_score": 0.5,
-        "avg_engagement_score": 0.5,
-        "avg_intention_level": 0.5,
-        "avg_days_since_lead": 30,
-        "dominant_countries": ["BR"],
-        "dominant_states": ["SP", "RJ"],
-        "dominant_utm_sources": ["facebook"],
-        "top_features": ["ltv", "engagement"]
-      },
-      "centroid": { "ltv": 0.5, "engagement": 0.5, "intention": 0.5 },
-      "action_recommendation": "[Recomendação de campanha específica para este segmento]"
+    // 3. Gerar perfis textuais e embeddings via embeddinggemma-300m
+    const sample   = leads.slice(0, 100); // max 100 por batch
+    const profiles = sample.map(_buildLeadProfile);
+
+    const embRes = await env.AI.run('@cf/baai/bge-m3', { text: profiles });
+    const vectors = embRes.data; // float32[][] shape [N, 768]
+
+    if (!vectors || vectors.length < nClusters) {
+      throw new Error(`embeddinggemma retornou ${vectors?.length ?? 0} vetores — insuficiente para ${nClusters} clusters`);
     }
-  ],
-  "silhouette_score": 0.65,
-  "total_processed": ${sampleSize}
-}`;
 
-    // 5. Executar via Workers AI
-    const startTime = Date.now();
-    const aiRes = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
-      messages:   [{ role: 'user', content: clusteringPrompt }],
-      max_tokens: 2000,
+    // 4. K-means vetorial real (cosine distance)
+    const { assignments } = _kmeansRun(vectors, nClusters);
+
+    // 5. Silhouette score real
+    const silhouetteScore = _silhouette(vectors, assignments, nClusters);
+
+    // 6. Agregar estatísticas por cluster para nomear com Granite
+    const clusterStats = Array.from({ length: nClusters }, (_, c) => {
+      const members = sample.filter((_, i) => assignments[i] === c);
+      if (members.length === 0) return null;
+      const ltvMap = { High: 1, Medium: 0.5, Low: 0 };
+      const avgLtv  = members.reduce((s, l) => s + (ltvMap[l.predicted_ltv_class] ?? 0), 0) / members.length;
+      const avgEng  = members.reduce((s, l) => s + (l.engagement_score || 0), 0) / members.length;
+      const avgDays = members.reduce((s, l) => s + (l.days_since_lead || 0), 0) / members.length;
+      const sources = members.map(l => l.utm_source).filter(Boolean);
+      const states  = members.map(l => l.state).filter(Boolean);
+      const topSource = sources.length ? [...sources.reduce((m, s) => m.set(s, (m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : 'direto';
+      const topState  = states.length  ? [...states.reduce((m, s)  => m.set(s, (m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : 'BR';
+      const intentions = members.map(l => l.intention_level).filter(Boolean);
+      const topIntent = intentions.length ? [...intentions.reduce((m, s) => m.set(s,(m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : 'desconhecida';
+      return { c, size: members.length, pct: Math.round(members.length / sample.length * 100), avgLtv, avgEng, avgDays, topSource, topState, topIntent };
+    }).filter(Boolean);
+
+    // 7. Usar Granite apenas para nomear e recomendar ação por cluster
+    const namingPrompt =
+`Você é especialista em segmentação de clientes. Dê um nome descritivo em português e uma recomendação de campanha para cada segmento abaixo. Retorne SOMENTE JSON válido:
+{"segments":[{"cluster_id":0,"name":"...","action":"..."},...]}
+
+Segmentos:
+${clusterStats.map(s => `Cluster ${s.c}: LTV médio=${s.avgLtv.toFixed(2)}, engajamento=${s.avgEng.toFixed(0)}, intenção dominante="${s.topIntent}", origem="${s.topSource}", estado="${s.topState}", recência=${s.avgDays.toFixed(0)} dias, tamanho=${s.size} leads`).join('\n')}`;
+
+    const nameRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
+      messages: [{ role: 'user', content: namingPrompt }],
+      max_tokens: 800,
     });
-    const duration = Date.now() - startTime;
 
-    if (!aiRes?.response) throw new Error('Workers AI não retornou resposta');
+    let clusterNames = {};
+    try {
+      const m = (nameRes?.response || '').match(/\{[\s\S]*\}/);
+      if (m) {
+        const parsed = JSON.parse(m[0]);
+        (parsed.segments || []).forEach(s => { clusterNames[s.cluster_id] = { name: s.name, action: s.action }; });
+      }
+    } catch { /* usa nomes fallback */ }
 
-    // 6. Parse do resultado
-    const jsonMatch = aiRes.response.trim().match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error('Resposta do Workers AI não contém JSON válido');
-    const mlResult = JSON.parse(jsonMatch[0]);
+    const duration = Date.now() - startTime;
 
-    if (!Array.isArray(mlResult.clusters) || mlResult.clusters.length === 0) {
-      throw new Error('Workers AI não retornou clusters válidos');
-    }
+    // 8. Montar resultado final
+    const clusters = clusterStats.map(s => ({
+      cluster_id:           s.c,
+      name:                 clusterNames[s.c]?.name || `Segmento ${s.c + 1}`,
+      size:                 s.size,
+      percentage:           s.pct,
+      action_recommendation: clusterNames[s.c]?.action || '',
+      characteristics: {
+        avg_ltv_class:        s.avgLtv,
+        avg_engagement_score: s.avgEng,
+        avg_intention_level:  s.avgLtv,
+        avg_days_since_lead:  s.avgDays,
+        dominant_countries:   ['BR'],
+        dominant_states:      [s.topState],
+        dominant_utm_sources: [s.topSource],
+        top_features:         ['ltv', 'engagement', 'intention'],
+      },
+    }));
 
-    // 7. Inativar clusters anteriores do mesmo algoritmo/vertical
+    // 9. Inativar clusters anteriores do mesmo algoritmo/vertical
     await env.DB.prepare(
       `UPDATE ml_segments SET is_active = 0 WHERE clustering_algorithm = ? AND client_vertical = ? AND is_active = 1`
     ).bind(algorithm, clientVertical).run();
 
-    // 8. Persistir novos clusters no D1
+    // 10. Persistir novos clusters no D1
     const now = new Date().toISOString();
-    for (const cluster of mlResult.clusters) {
-      const ch = cluster.characteristics || {};
+    for (const cluster of clusters) {
+      const ch = cluster.characteristics;
       await env.DB.prepare(`
         INSERT INTO ml_segments (
           cluster_id, cluster_name, clustering_algorithm, client_vertical,
@@ -2581,23 +2653,23 @@ Return ONLY valid JSON, zero explanation:
           is_active, created_at, updated_at
         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?)
       `).bind(
-        cluster.cluster_id || 0,
-        cluster.name        || `Segmento ${cluster.cluster_id}`,
+        cluster.cluster_id,
+        cluster.name,
         algorithm,
         clientVertical,
-        cluster.size        || 0,
-        cluster.percentage  || 0,
-        ch.avg_ltv_class    || 0,
-        ch.avg_behavior_score   || 0,
-        ch.avg_engagement_score || 0,
-        ch.avg_intention_level  || 0,
-        ch.avg_days_since_lead  || 0,
-        JSON.stringify(ch.dominant_countries   || ['BR']),
-        JSON.stringify(ch.dominant_states      || []),
-        JSON.stringify(ch.dominant_utm_sources || []),
-        JSON.stringify(ch.top_features         || []),
-        mlResult.silhouette_score             || 0,
-        JSON.stringify([cluster.action_recommendation || '']),
+        cluster.size,
+        cluster.percentage,
+        ch.avg_ltv_class,
+        ch.avg_engagement_score,
+        ch.avg_engagement_score,
+        ch.avg_intention_level,
+        ch.avg_days_since_lead,
+        JSON.stringify(ch.dominant_countries),
+        JSON.stringify(ch.dominant_states),
+        JSON.stringify(ch.dominant_utm_sources),
+        JSON.stringify(ch.top_features),
+        silhouetteScore,
+        JSON.stringify([cluster.action_recommendation]),
         JSON.stringify([]),
         JSON.stringify([]),
         now,
@@ -2605,7 +2677,7 @@ Return ONLY valid JSON, zero explanation:
       ).run();
     }
 
-    // 9. Log no histórico de clustering
+    // 11. Log no histórico de clustering
     try {
       await env.DB.prepare(`
         INSERT INTO ml_clustering_history (
@@ -2617,23 +2689,25 @@ Return ONLY valid JSON, zero explanation:
         new Date(startTime).toISOString(),
         algorithm,
         leads.length,
-        mlResult.clusters.length,
+        clusters.length,
         duration,
         Math.ceil(duration * 0.01),
-        JSON.stringify({ algorithm, n_clusters: nClusters, vertical: clientVertical }),
-        JSON.stringify({ clusters: mlResult.clusters.length, silhouette: mlResult.silhouette_score }),
+        JSON.stringify({ algorithm, n_clusters: nClusters, vertical: clientVertical, engine: 'embeddinggemma-300m+kmeans' }),
+        JSON.stringify({ clusters: clusters.length, silhouette: silhouetteScore }),
       ).run();
     } catch (e) { console.error('[Segmentation] history log error:', e.message); }
 
     return new Response(JSON.stringify({
       success:          true,
       algorithm,
-      n_clusters:       mlResult.clusters.length,
+      engine:           'embeddinggemma-300m + kmeans vetorial',
+      n_clusters:       clusters.length,
       client_vertical:  clientVertical,
       leads_analyzed:   leads.length,
+      sample_embedded:  sample.length,
       duration_ms:      duration,
-      silhouette_score: mlResult.silhouette_score || null,
-      clusters:         mlResult.clusters,
+      silhouette_score: silhouetteScore,
+      clusters,
       generated_at:     now,
     }), { status: 200, headers });
 
@@ -2794,14 +2868,6 @@ async function handleSegmentationUpdate(env, request, headers) {
 // Heurístico puro (sem AI) — latência zero no /track
 // ─────────────────────────────────────────────────────────────────────────────
 
-// Domínios de email descartáveis
-const DISPOSABLE_EMAIL_DOMAINS = new Set([
-  'mailinator.com','guerrillamail.com','tempmail.com','throwaway.email',
-  'yopmail.com','sharklasers.com','guerrillamailblock.com','spam4.me',
-  '10minutemail.com','trashmail.com','maildrop.cc','fakeinbox.com',
-  'dispostable.com','mailnull.com','tempr.email','getnada.com',
-]);
-
 // ASNs conhecidos de datacenters (evitar falsos negativos em ASNs legítimos)
 const DATACENTER_PATTERNS = /amazon|google|microsoft|digitalocean|linode|ovh|vultr|hetzner|contabo|cloudflare|packet|rackspace|leaseweb/i;
 
@@ -2854,15 +2920,7 @@ async function checkFraudGate(env, request, payload) {
       result.score += 20; result.reasons.push('no_accept_language');
     }
 
-    // 6. Email descartável
-    if (email) {
-      const domain = email.split('@')[1]?.toLowerCase();
-      if (domain && DISPOSABLE_EMAIL_DOMAINS.has(domain)) {
-        result.score += 25; result.reasons.push('disposable_email');
-      }
-    }
-
-    // 7. Velocity check via KV
+    // 6. Velocity check via KV
     if (env.GEO_CACHE && ip) {
       const velKey1h = `fraud_velocity:${ip}:h`;
       const velStr   = await env.GEO_CACHE.get(velKey1h);
@@ -3839,7 +3897,7 @@ export default {
 
       // Workers AI — ping
       try {
-        await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
+        await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
           messages: [{ role: 'user', content: 'ping' }],
           max_tokens: 1,
         });

package/server-edge-tracker/wrangler.toml

@@ -25,10 +25,10 @@ zone_name = "lancamentosabc.com.br"
 
 # ── Variáveis públicas (não são segredos) ─────────────────────────────────────
 [vars]
-META_PIXEL_ID      = "SEU_META_PIXEL_ID"
-GA4_MEASUREMENT_ID = "G-XXXXXXXXXX"
-TIKTOK_PIXEL_ID    = "CXXXXXXXXXXXXXXX"
-SITE_DOMAIN        = "SEU_DOMINIO"
+META_PIXEL_ID      = "1583939052660159"
+GA4_MEASUREMENT_ID = "G-G7VEN1MNH1"
+TIKTOK_PIXEL_ID    = "D71D6T3C77U56RM5VF0G"
+SITE_DOMAIN        = "lancamentosabc.com.br"
 
 # ── Banco D1 ──────────────────────────────────────────────────────────────────
 # Após criar o banco com "wrangler d1 create cdp-edge-db",
@@ -95,6 +95,22 @@ namespace_id = "1001"
 limit  = 60
 period = 60
 
+# ── Observabilidade — Logs + Traces persistidos no painel Cloudflare ─────────
+[observability]
+enabled            = false
+head_sampling_rate = 1
+
+[observability.logs]
+enabled            = true
+head_sampling_rate = 1
+persist            = true
+invocation_logs    = true
+
+[observability.traces]
+enabled            = false
+persist            = true
+head_sampling_rate = 1
+
 # ── Secrets (NÃO ficam aqui — configurar via CLI) ─────────────────────────────
 # wrangler secret put META_ACCESS_TOKEN     ← token Meta CAPI (obrigatório)
 # wrangler secret put GA4_API_SECRET        ← secret GA4 Measurement Protocol (obrigatório)
@@ -107,6 +123,7 @@ period = 60
 # wrangler secret put RESEND_API_KEY            ← API Key do Resend (resend.com)
 # wrangler secret put RESEND_FROM_EMAIL         ← Remetente verificado ex: "CDP Edge <noreply@seudominio.com.br>"
 # wrangler secret put WA_WEBHOOK_VERIFY_TOKEN   ← Token de verificação do webhook WhatsApp (você define — qualquer string segura)
+# wrangler secret put WEBHOOK_SECRET_TICTO      ← HMAC-SHA256 Ticto
 # wrangler secret put PINTEREST_ACCESS_TOKEN    ← Bearer token Pinterest Conversions API
 # wrangler secret put PINTEREST_AD_ACCOUNT_ID   ← ID da conta de anúncios Pinterest (ex: 549755813XXX)
 # wrangler secret put REDDIT_ACCESS_TOKEN       ← Bearer token Reddit Conversions API