cdp-edge 1.23.1 → 1.23.3

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

@@ -8,6 +8,23 @@ import { extractFeatures, predictWithWeights, loadActiveWeights } from './logist
 // Cache key para o teste ativo (KV — evita hit no D1 a cada request /track)
 const AB_LTV_CACHE_KEY = 'ab_ltv_active_test';
 
+// ── Prompt especializado para imóveis ────────────────────────────────────────
+// Ativado automaticamente quando property_lat/lng estão presentes no payload.
+// Override por A/B test tem prioridade sobre este prompt.
+const REAL_ESTATE_PROMPT = `You are a real estate lead scoring expert for the Brazilian market.
+Reply ONLY with a JSON object {"adjustment": <integer between -15 and 15>} based on the lead data.
+Scoring rules (apply additively):
+- distance_km < 5:  +12 (lives nearby, buys fast)
+- distance_km 5-15: +8
+- distance_km 15-30: +3
+- distance_km > 30:  0
+- distance_km unknown: +3 (gave intent signal without geo)
+- event = Schedule or route click: +5 (physical visit intent)
+- scroll_score >= 3 AND time_level = comprador: +4 (deep engagement)
+- hour_brt between 18-22 (weekday): +3 (active decision window)
+- has_phone = true: +2 (reachable for follow-up)
+No explanation. JSON only.`;
+
 // ── predictLtv — Heurística em 5 dimensões (0-100 pts) ───────────────────────
 export async function predictLtv(env, payload, request, customSystemPrompt = null) {
   // ── Tentar modelo treinado (regressão logística real) ─────────────────────
@@ -83,6 +100,25 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
   if (payload.phone) score += 4;
   if (payload.firstName) score += 2;
 
+  // 5b. Tipo de evento imobiliário (0–15) — sinais de intenção de compra física
+  const evType = (payload.eventType || '').toLowerCase();
+  if (evType === 'customizeproduct') score += 15; // simulação de financiamento → intenção máxima
+  else if (evType === 'findlocation')  score += 10; // viu mapa/localização → visita física iminente
+  else if (evType === 'addtowishlist') score += 8;  // favoritou → interesse persistente
+
+  // 6. Proximidade ao imóvel físico (0–15) — apenas quando distância calculada
+  const distKm = parseFloat(payload.distanceKm ?? payload.user_distance_km ?? -1);
+  if (distKm >= 0) {
+    if      (distKm <  5)  score += 15;
+    else if (distKm < 15)  score += 10;
+    else if (distKm < 30)  score += 6;
+    else if (distKm < 60)  score += 3;
+    // > 60km: sem bônus — lead distante precisa de argumento diferente
+  } else if (payload.property_lat || payload.propertyLat) {
+    // Coords no payload mas distância não resolvida: pequeno bônus por intenção de rota
+    score += 3;
+  }
+
   score = Math.min(100, score);
 
   let ltvClass, ltvMultiplier;
@@ -102,21 +138,36 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
   let aiAdjustment = 0;
   if (env.AI && score >= 40) {
     try {
+      const isRealEstate = !!(payload.property_lat || payload.propertyLat);
       const systemContent = customSystemPrompt ||
-        'You are a conversion rate expert. Reply ONLY with a JSON object {"adjustment": <number between -10 and 10>} based on the lead data provided. No explanation.';
+        (isRealEstate
+          ? REAL_ESTATE_PROMPT
+          : 'You are a conversion rate expert. Reply ONLY with a JSON object {"adjustment": <number between -10 and 10>} based on the lead data provided. No explanation.');
+
+      const userContext = {
+        utm_source:  payload.utmSource,
+        intention:   intentionLevel,
+        engagement:  engScore,
+        hour_utc:    hour,
+        country,
+        has_email:   !!payload.email,
+        has_phone:   !!payload.phone,
+      };
+      if (isRealEstate) {
+        userContext.event_type     = 'real_estate_schedule';
+        userContext.distance_km    = payload.distanceKm ?? payload.user_distance_km ?? 'unknown';
+        userContext.distance_bucket = payload.distanceBucket ?? 'unknown';
+        userContext.scroll_score   = payload.scrollScore || payload.scroll_score || 0;
+        userContext.time_level     = payload.timeLevel || payload.time_level || 'unknown';
+        userContext.intent_score   = payload.intent_score || 'high';
+        userContext.hour_brt       = (hour - 3 + 24) % 24; // UTC-3 aproximado
+      }
+
       const prompt = [
         { role: 'system', content: systemContent },
-        { role: 'user', content: JSON.stringify({
-          utm_source:  payload.utmSource,
-          intention:   intentionLevel,
-          engagement:  engScore,
-          hour_utc:    hour,
-          country,
-          has_email:   !!payload.email,
-          has_phone:   !!payload.phone,
-        })},
+        { 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/modules/utils.js

@@ -86,4 +86,82 @@ export const VALID_EVENT_NAMES = new Set([
   'AddToCart','CompleteRegistration','Contact','Schedule',
   'StartTrial','Subscribe','SubmitApplication','Search',
   'video_start','video_25','video_50','video_75','video_complete',
+  // Imóveis — intenção de visita física, financiamento e favoritar
+  'FindLocation','CustomizeProduct','AddToWishlist',
 ]);
+
+// ── Taxonomia de funil (funnel_stage → profundidade semântica) ────────────────
+// Fonte de verdade para interpretar funnel_stage em qualquer ponto do sistema.
+export const FUNNEL_TAXONOMY = {
+  top:        ['scroll_50', 'time_30s', 'page_view', 'gallery_view', 'AddToWishlist'],
+  mid:        ['map_view', 'gallery_click', 'price_hover', 'time_3min', 'FindLocation'],
+  bottom:     ['route_click', 'whatsapp_click', 'cta_hover', 'CustomizeProduct'],
+  conversion: ['schedule_confirmed', 'lead_form', 'purchase', 'visit_booked'],
+};
+
+// Índice invertido: funnel_stage → depth (construído uma vez, zero custo em runtime)
+const _STAGE_TO_DEPTH = Object.entries(FUNNEL_TAXONOMY).reduce((acc, [depth, stages]) => {
+  stages.forEach(s => { acc[s] = depth; });
+  return acc;
+}, {});
+
+/**
+ * Resolve funnel_stage em funnelDepth semântico.
+ * bottom_intent  = intenção forte (route_click, whatsapp_click)
+ * bottom_conversion = ação confirmada (schedule_confirmed, lead_form)
+ */
+export function resolveFunnelStage(funnel_stage) {
+  const depth = _STAGE_TO_DEPTH[funnel_stage] || 'unknown';
+  const funnelDepth = depth === 'conversion' ? 'bottom_conversion'
+                    : depth === 'bottom'     ? 'bottom_intent'
+                    : depth;
+  return { depth, funnelDepth };
+}
+
+// ── Normalização de intent_score → 0.0–1.0 ───────────────────────────────────
+// Aceita: string ('high'/'medium'/'low'), numérico 0-1 ou numérico 0-100
+const _INTENT_STRING_MAP = { high: 0.92, medium: 0.65, low: 0.30 };
+
+export function resolveIntentScore(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return _INTENT_STRING_MAP[value.toLowerCase()] ?? null;
+  const num = parseFloat(value);
+  if (isNaN(num)) return null;
+  const normalized = num > 1 ? num / 100 : num;  // escala 0-100 → 0-1
+  return Math.min(1, Math.max(0, Math.round(normalized * 100) / 100));
+}
+
+/**
+ * Distância (distanceBucket) → peso numérico para meta_signal.
+ * very_close=1.0 ... far=0.1 ... sem dado=0.3 (neutro)
+ */
+export function distanceBucketWeight(bucket) {
+  const map = { very_close: 1.0, close: 0.75, nearby: 0.5, moderate: 0.25, far: 0.1 };
+  return map[bucket] ?? 0.3;
+}
+
+/**
+ * Pesos dinâmicos do meta_signal por profundidade de funil.
+ * Fundo: comportamento pesa mais (intent + dist).
+ * Topo: perfil pesa mais (ltv).
+ * Default (mid/unknown): balanceado.
+ */
+export function computeMetaSignalWeights(funnelLevel) {
+  if (funnelLevel === 'bottom' || funnelLevel === 'conversion') {
+    return { intent: 0.5, ltv: 0.2, dist: 0.3 };
+  }
+  if (funnelLevel === 'top') {
+    return { intent: 0.2, ltv: 0.6, dist: 0.2 };
+  }
+  return { intent: 0.4, ltv: 0.4, dist: 0.2 };
+}
+
+/**
+ * Quantiza meta_signal contínuo em bucket legível.
+ * Usado em criação de públicos e leitura de BI.
+ */
+export function metaSignalBucket(score) {
+  if (score >= 0.8) return 'hot';
+  if (score >= 0.6) return 'warm';
+  return 'cold';
+}

package/server-edge-tracker/schema-ltv-feedback.sql

@@ -0,0 +1,11 @@
+-- CDP Edge — Schema LTV Feedback Loop
+-- Fecha o ciclo preditivo: Purchase real → corrige predicted_ltv_value
+-- Execução: wrangler d1 execute cdp-edge-db --file=schema-ltv-feedback.sql --remote
+--
+-- Idempotência: ALTER TABLE não suporta IF NOT EXISTS no SQLite.
+-- Se a coluna já existir, o comando gera erro mas não afeta dados existentes.
+-- Seguro executar mais de uma vez.
+
+ALTER TABLE user_profiles ADD COLUMN real_ltv_value  REAL;
+ALTER TABLE user_profiles ADD COLUMN ltv_accuracy    REAL;   -- 1 - |pred-real|/real  (0–1, maior = melhor)
+ALTER TABLE user_profiles ADD COLUMN ltv_feedback_at TEXT;   -- timestamp do último feedback

package/server-edge-tracker/wrangler.toml

@@ -4,6 +4,7 @@ name = "server-edge-tracker"
 main = "index.js"
 compatibility_date = "2025-01-01"
 compatibility_flags = ["nodejs_compat"]
+workers_dev = true
 
 # ── Worker Routes — same-domain tracking (imune a bloqueios) ─────────────────
 # Substituir SEU_DOMINIO pelo domínio do cliente antes do deploy
@@ -16,18 +17,18 @@ compatibility_flags = ["nodejs_compat"]
 # zone_name = "SEU_DOMINIO"
 
 [[routes]]
-pattern  = "lancamentosabc.com.br/track*"
-zone_name = "lancamentosabc.com.br"
+pattern  = "SEU_DOMINIO/track*"
+zone_name = "SEU_DOMINIO"
 
 [[routes]]
-pattern  = "*.lancamentosabc.com.br/track*"
-zone_name = "lancamentosabc.com.br"
+pattern  = "*.SEU_DOMINIO/track*"
+zone_name = "SEU_DOMINIO"
 
 # ── 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"
+META_PIXEL_ID      = ""
+GA4_MEASUREMENT_ID = ""
+TIKTOK_PIXEL_ID    = ""
 SITE_DOMAIN        = "SEU_DOMINIO"
 
 # ── Banco D1 ──────────────────────────────────────────────────────────────────
@@ -36,7 +37,7 @@ SITE_DOMAIN        = "SEU_DOMINIO"
 [[d1_databases]]
 binding      = "DB"
 database_name = "cdp-edge-db"
-database_id  = "7867d38f-5fa8-4c17-b465-386211422c09"
+database_id  = "SEU_DATABASE_ID"
 
 # ── Queues — Retry + Dead Letter Queue ───────────────────────────────────────
 # Produtor: worker envia eventos com falha para cdp-edge-retry
@@ -95,6 +96,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 +124,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