spine-framework-cortex 0.1.13 → 0.1.15

package/functions/custom_funnel-signal.ts

@@ -1,55 +1,37 @@
 // Funnel Signal Handler
-// Processes incoming funnel signals using ONLY Spine APIs (ctx.db)
-// NO direct database access
+// Ingests, scores, and persists funnel signals end-to-end.
 //
 // Handler Signature (per integration-routes.ts):
 // scriptHandler(sanitizedData, scriptContext, scriptEvent)
-// - sanitizedData: request body
+// - sanitizedData: request body (sanitized by integration-routes)
 // - scriptContext: { integrationId, accountId, slug, principal, requestId, headers }
 // - scriptEvent: { httpMethod, headers, body, path, queryStringParameters }
+//
+// Uses adminDb for type-resolution lookups and all CRUD writes.
+// Scoring is inline — the Core trigger/pipeline engine cannot directly invoke
+// a custom function, so scoring is done synchronously here.
 
+import { adminDb } from './_shared/db'
 import {
   calculateEngagement,
   calculateRecency,
   calculateRawScore,
   inferOpportunityType,
   categorizeReferrer,
-  EngagementResult,
-  RecencyResult,
-  RawScoreResult
 } from './custom_funnel-scoring'
-import { adminDb } from './_shared/db'
-import { resolveTypeIds, resolveLinkTypeIds, resolveAccountId } from './_shared/resolve-ids'
-
-// IDs resolved at request time — never hardcoded
-async function resolveIds() {
-  const [types, linkTypes, unidentifiedVisitorsAccountId] = await Promise.all([
-    resolveTypeIds([
-      { kind: 'item', slug: 'funnel_signal' },
-      { kind: 'item', slug: 'anonymous_session' },
-      { kind: 'item', slug: 'opportunity_queue' },
-    ]),
-    resolveLinkTypeIds(['account_signals', 'account_opportunities']),
-    resolveAccountId('unidentified-visitors'),
-  ])
-  return {
-    TYPE_IDS: {
-      funnel_signal: types['item/funnel_signal'],
-      anonymous_session: types['item/anonymous_session'],
-      opportunity_queue: types['item/opportunity_queue'],
-    },
-    LINK_TYPE_IDS: {
-      account_signals: linkTypes['account_signals'],
-      account_opportunities: linkTypes['account_opportunities'],
-    },
-    UNIDENTIFIED_VISITORS_ACCOUNT_ID: unidentifiedVisitorsAccountId,
-  }
-}
 
 // ============================================
 // SIGNAL HANDLER (Integration Routes Compatible)
 // ============================================
 
+export default async function handler(
+  sanitizedData: any,
+  scriptContext: any,
+  _scriptEvent: any
+) {
+  return processSignal(sanitizedData, scriptContext, _scriptEvent)
+}
+
 export async function processSignal(
   sanitizedData: any,
   scriptContext: any,
@@ -57,53 +39,124 @@ export async function processSignal(
 ) {
   const receivedAt = new Date().toISOString()
 
-  // 1. VALIDATE PAYLOAD
-  const signal = validateSignalPayload(sanitizedData)
-  if (!signal.valid) {
-    return { status: 'error', error: (signal as { valid: false; error: string }).error }
+  // 1. VALIDATE
+  const validation = validateSignalPayload(sanitizedData)
+  if (!validation.valid) {
+    return { status: 'error', error: (validation as { valid: false; error: string }).error }
+  }
+  const payload = validation.data
+
+  // 2. RESOLVE IDs (read-only type/account lookups)
+  const [signalTypeId, sessionTypeId, queueTypeId, signalLinkTypeId, opportunityLinkTypeId, unidentifiedAccountId] =
+    await Promise.all([
+      resolveTypeId('funnel_signal'),
+      resolveTypeId('anonymous_session'),
+      resolveTypeId('opportunity_queue'),
+      resolveLinkTypeId('account_signals'),
+      resolveLinkTypeId('account_opportunities'),
+      resolveUnidentifiedAccountId(),
+    ])
+
+  if (!signalTypeId) {
+    return { status: 'error', error: 'funnel_signal type not found — run install-app cortex' }
   }
 
-  const payload = signal.data
+  // 3. ENRICH — fetch prior signals for this identity
+  const priorSignals = await fetchPriorSignals(payload, signalTypeId)
 
-  // Resolve IDs at request time — never hardcoded
-  const ids = await resolveIds()
+  // 4. SCORE
+  const occurredAt = payload.occurred_at ? new Date(payload.occurred_at) : new Date()
+  const referrerDomain = extractDomain(payload.referrer)
+  const referrerCategory = categorizeReferrer(referrerDomain)
+  const engagement = calculateEngagement(priorSignals, payload.session_id || 'default', occurredAt.toISOString(), payload.stage)
+  const recency = calculateRecency(occurredAt, new Date(), payload.stage)
+  const scoring = recency.divisor === null
+    ? { calculated: 0, max_possible: 25, rating: 1 as const }
+    : calculateRawScore(payload.action_value, engagement.type, recency.divisor)
+  const scoredAt = new Date().toISOString()
 
-  // 2. ENRICH (using adminDb Spine APIs)
-  const enrichment = await enrichSignal(payload, ids)
+  // 5. INSERT SIGNAL ITEM
+  const signalData = {
+    identity: {
+      anonymous_id: payload.anonymous_id || null,
+      person_id: payload.person_id || null,
+      account_id: payload.account_id || null,
+      session_id: payload.session_id || null,
+    },
+    classification: {
+      stage: payload.stage,
+      source: payload.source,
+      pipeline_slug: payload.pipeline_slug || null,
+    },
+    action: {
+      action_type: payload.action_type,
+      action_value: payload.action_value,
+      action_description: payload.action_description || null,
+      url: payload.url || null,
+    },
+    scoring_components: {
+      engagement: { type: engagement.type, context: engagement.context, session_depth: engagement.session_depth, prior_session_count: engagement.prior_session_count || 0 },
+      recency: { divisor: recency.divisor, age_days: recency.age_days, window: recency.window },
+      raw_score: { calculated: scoring.calculated, max_possible: scoring.max_possible, rating: scoring.rating },
+    },
+    attribution: {
+      immediate_referrer: payload.referrer || null,
+      first_touch_referrer_domain: referrerDomain,
+      utm_source: payload.utm_source || null,
+      utm_medium: payload.utm_medium || null,
+      utm_campaign: payload.utm_campaign || null,
+    },
+    processing: {
+      received_at: receivedAt,
+      enriched_at: scoredAt,
+      scored_at: scoredAt,
+      stitched_at: null,
+      stitched_to_account_id: null,
+    },
+    source_metadata: {
+      instance_id: payload.instance_id || null,
+      environment: payload.environment || null,
+    },
+  }
 
-  // 3. SCORE
-  const scoring = scoreSignal(payload, enrichment)
+  const { data: signalItem, error: signalErr } = await adminDb
+    .from('items')
+    .insert({
+      type_id: signalTypeId,
+      title: `${payload.action_type} - ${payload.action_value}`,
+      account_id: payload.account_id || unidentifiedAccountId,
+      data: signalData,
+    })
+    .select('id')
+    .single()
 
-  // 4. CREATE SIGNAL ITEM (adminDb.from('items').insert())
-  const signalItem = await createSignalItem(payload, enrichment, scoring, receivedAt, ids)
+  if (signalErr || !signalItem) {
+    console.error('[FunnelSignal] Failed to insert signal:', signalErr?.message)
+    return { status: 'error', error: 'Failed to create signal record' }
+  }
 
-  // 5. UPDATE ACCOUNT OR CREATE ANONYMOUS SESSION
-  let accountUpdate = null
-  let sessionItem = null
+  const signalId = signalItem.id
 
+  // 6. UPDATE ACCOUNT or UPSERT ANONYMOUS SESSION
   if (payload.account_id) {
-    accountUpdate = await updateAccountFunnel(payload.account_id, payload.stage, scoring)
-
-    // Create link between account and signal
-    await createAccountSignalLink(payload.account_id, signalItem.id, ids)
-  } else if (payload.anonymous_id) {
-    sessionItem = await upsertAnonymousSession(payload, enrichment, scoring, signalItem.id, ids)
+    await updateAccountFunnel(payload.account_id, payload.stage, scoring, payload.pipeline_slug, referrerDomain, referrerCategory, scoredAt)
+    if (signalLinkTypeId) {
+      await createLink(signalLinkTypeId, 'account', payload.account_id, 'item', signalId)
+    }
+  } else if (payload.anonymous_id && sessionTypeId) {
+    await upsertAnonymousSession(payload, sessionTypeId, signalId, scoring, engagement, referrerDomain, referrerCategory, scoredAt)
   }
 
-  // 6. EVALUATE QUEUE (if rating >= 4)
-  let queueEntry = null
-  if (scoring.rating >= 4) {
-    queueEntry = await evaluateQueueEntry(payload, scoring, signalItem.id, ids)
+  // 7. EVALUATE QUEUE — if rating >= 4
+  if (scoring.rating >= 4 && queueTypeId) {
+    await evaluateQueueEntry(payload, queueTypeId, opportunityLinkTypeId, signalId, scoring, scoredAt)
   }
 
   return {
     status: 'success',
-    signal_id: signalItem.id,
+    signal_id: signalId,
     rating: scoring.rating,
     raw_score: scoring.calculated,
-    account_updated: !!accountUpdate,
-    session_created: !!sessionItem,
-    queue_entry: queueEntry
   }
 }
 
@@ -111,41 +164,6 @@ export async function processSignal(
 // VALIDATION
 // ============================================
 
-function validateSignalPayload(body: any): { valid: true; data: SignalPayload } | { valid: false; error: string } {
-  if (!body) {
-    return { valid: false, error: 'Missing request body' }
-  }
-
-  // Check required fields
-  if (!body.stage || !['anonymous', 'identified', 'installed'].includes(body.stage)) {
-    return { valid: false, error: 'Invalid or missing stage' }
-  }
-
-  if (!body.source || !['mar', 'int', 'use', 'manual'].includes(body.source)) {
-    return { valid: false, error: 'Invalid or missing source' }
-  }
-
-  if (!body.action_type) {
-    return { valid: false, error: 'Missing action_type' }
-  }
-
-  if (!body.action_value || ![1, 2, 5].includes(body.action_value)) {
-    return { valid: false, error: 'Invalid action_value (must be 1, 2, or 5)' }
-  }
-
-  // Check identity - must have at least one
-  if (!body.anonymous_id && !body.person_id && !body.account_id) {
-    return { valid: false, error: 'Must provide anonymous_id, person_id, or account_id' }
-  }
-
-  // For 'mar' source, session_id is required
-  if (body.source === 'mar' && !body.session_id) {
-    return { valid: false, error: 'session_id required for marketing signals' }
-  }
-
-  return { valid: true, data: body as SignalPayload }
-}
-
 interface SignalPayload {
   anonymous_id?: string
   person_id?: string
@@ -166,513 +184,246 @@ interface SignalPayload {
   utm_campaign?: string
   instance_id?: string
   environment?: 'dev' | 'staging' | 'production'
+  pipeline_slug?: string
+}
+
+function validateSignalPayload(body: any): { valid: true; data: SignalPayload } | { valid: false; error: string } {
+  if (!body) return { valid: false, error: 'Missing request body' }
+  if (!body.stage || !['anonymous', 'identified', 'installed'].includes(body.stage)) return { valid: false, error: 'Invalid or missing stage' }
+  if (!body.source || !['mar', 'int', 'use', 'manual'].includes(body.source)) return { valid: false, error: 'Invalid or missing source' }
+  if (!body.action_type) return { valid: false, error: 'Missing action_type' }
+  if (!body.action_value || ![1, 2, 5].includes(body.action_value)) return { valid: false, error: 'Invalid action_value (must be 1, 2, or 5)' }
+  if (!body.anonymous_id && !body.person_id && !body.account_id) return { valid: false, error: 'Must provide anonymous_id, person_id, or account_id' }
+  if (body.source === 'mar' && !body.session_id) return { valid: false, error: 'session_id required for marketing signals' }
+  return { valid: true, data: body as SignalPayload }
 }
 
 // ============================================
-// ENRICHMENT (using adminDb Spine APIs)
+// ID RESOLUTION HELPERS
 // ============================================
 
-async function enrichSignal(payload: SignalPayload, ids: Awaited<ReturnType<typeof resolveIds>>): Promise<EnrichmentResult> {
-  const occurredAt = payload.occurred_at ? new Date(payload.occurred_at) : new Date()
-
-  // Query prior signals for engagement calculation
-  let priorSignals: any[] = []
-
-  if (payload.anonymous_id) {
-    // Query by anonymous_id using adminDb
-    const { data } = await adminDb
-      .from('items')
-      .select('data->>session_id as session_id, data->processing->>scored_at as occurred_at')
-      .eq('type_id', ids.TYPE_IDS.funnel_signal)
-      .eq('data->identity->>anonymous_id', payload.anonymous_id)
-      .order('created_at', { ascending: true })
-      .limit(100)
-
-    priorSignals = (data as any[]) || []
-  } else if (payload.account_id) {
-    // Query by account_id using adminDb
-    const { data } = await adminDb
-      .from('items')
-      .select('data->>session_id as session_id, data->processing->>scored_at as occurred_at')
-      .eq('type_id', ids.TYPE_IDS.funnel_signal)
-      .eq('account_id', payload.account_id)
-      .order('created_at', { ascending: true })
-      .limit(100)
-
-    priorSignals = (data as any[]) || []
-  }
-
-  // Calculate engagement
-  const engagement = calculateEngagement(
-    priorSignals,
-    payload.session_id || 'default',
-    occurredAt.toISOString(),
-    payload.stage
-  )
-
-  // Calculate recency
-  const recency = calculateRecency(occurredAt, new Date(), payload.stage)
-
-  // Extract referrer
-  const referrerDomain = extractDomain(payload.referrer)
-  const referrerCategory = categorizeReferrer(referrerDomain)
-
-  return {
-    engagement,
-    recency,
-    referrer_domain: referrerDomain,
-    referrer_category: referrerCategory,
-    occurred_at: occurredAt.toISOString()
-  }
+async function resolveUnidentifiedAccountId(): Promise<string | null> {
+  const { data } = await adminDb.from('accounts').select('id').eq('slug', 'unidentified-visitors').maybeSingle()
+  return data?.id || null
 }
 
-interface EnrichmentResult {
-  engagement: EngagementResult
-  recency: RecencyResult
-  referrer_domain: string
-  referrer_category: string
-  occurred_at: string
+async function resolveTypeId(slug: string): Promise<string | null> {
+  const { data } = await adminDb.from('types').select('id').eq('slug', slug).eq('is_active', true).maybeSingle()
+  return data?.id || null
 }
 
-// ============================================
-// SCORING
-// ============================================
-
-function scoreSignal(payload: SignalPayload, enrichment: EnrichmentResult): RawScoreResult {
-  if (enrichment.recency.divisor === null) {
-    // Expired signal gets minimum score
-    return { calculated: 0, max_possible: 25, rating: 1 }
-  }
-
-  return calculateRawScore(
-    payload.action_value,
-    enrichment.engagement.type,
-    enrichment.recency.divisor
-  )
+async function resolveLinkTypeId(slug: string): Promise<string | null> {
+  const { data } = await adminDb.from('link_types').select('id').eq('slug', slug).maybeSingle()
+  return data?.id || null
 }
 
 // ============================================
-// CREATE SIGNAL ITEM (adminDb.from('items').insert())
+// ENRICHMENT
 // ============================================
 
-async function createSignalItem(
-  payload: SignalPayload,
-  enrichment: EnrichmentResult,
-  scoring: RawScoreResult,
-  receivedAt: string,
-  ids: Awaited<ReturnType<typeof resolveIds>>
-): Promise<{ id: string }> {
-  const scoredAt = new Date().toISOString()
-
-  const signalData = {
-    identity: {
-      anonymous_id: payload.anonymous_id || null,
-      person_id: payload.person_id || null,
-      account_id: payload.account_id || null,
-      session_id: payload.session_id || null
-    },
-    classification: {
-      stage: payload.stage,
-      source: payload.source
-    },
-    action: {
-      action_type: payload.action_type,
-      action_value: payload.action_value,
-      action_description: payload.action_description || null
-    },
-    scoring_components: {
-      engagement: {
-        type: enrichment.engagement.type,
-        context: enrichment.engagement.context,
-        session_depth: enrichment.engagement.session_depth,
-        prior_session_count: enrichment.engagement.prior_session_count || 0
-      },
-      recency: {
-        divisor: enrichment.recency.divisor,
-        age_days: enrichment.recency.age_days,
-        window: enrichment.recency.window
-      },
-      raw_score: {
-        calculated: scoring.calculated,
-        max_possible: scoring.max_possible,
-        rating: scoring.rating
-      }
-    },
-    attribution: {
-      first_touch_referrer_domain: enrichment.referrer_domain,
-      immediate_referrer: payload.referrer || null,
-      utm_source: payload.utm_source || null,
-      utm_medium: payload.utm_medium || null,
-      utm_campaign: payload.utm_campaign || null
-    },
-    processing: {
-      received_at: receivedAt,
-      enriched_at: scoredAt,
-      scored_at: scoredAt,
-      stitched_at: null,
-      stitched_to_account_id: null
-    },
-    source_metadata: {
-      instance_id: payload.instance_id || null,
-      environment: payload.environment || null
-    }
-  }
-
-  const { data, error } = await adminDb
-    .from('items')
-    .insert({
-      type_id: ids.TYPE_IDS.funnel_signal,
-      title: `${payload.action_type} - ${payload.action_value}`,
-      account_id: payload.account_id || ids.UNIDENTIFIED_VISITORS_ACCOUNT_ID,
-      data: signalData
-    })
-    .select('id')
-    .single()
-
-  if (error) {
-    throw new Error(`Failed to create signal: ${error.message}`)
+async function fetchPriorSignals(payload: SignalPayload, signalTypeId: string): Promise<Array<{ session_id: string; occurred_at: string }>> {
+  let query = adminDb.from('items').select('data').eq('type_id', signalTypeId).order('created_at', { ascending: true }).limit(100)
+  if (payload.anonymous_id) {
+    query = query.eq('data->identity->>anonymous_id' as any, payload.anonymous_id)
+  } else if (payload.account_id) {
+    query = query.eq('account_id', payload.account_id)
+  } else {
+    return []
   }
-
-  return { id: data.id }
+  const { data } = await query
+  return (data || []).map((r: any) => ({
+    session_id: r.data?.identity?.session_id || 'default',
+    occurred_at: r.data?.processing?.received_at || r.data?.processing?.scored_at || new Date().toISOString(),
+  }))
 }
 
 // ============================================
-// UPDATE ACCOUNT FUNNEL (adminDb.from('accounts').update())
+// ACCOUNT UPDATE
 // ============================================
 
 async function updateAccountFunnel(
-  accountId: string,
-  stage: string,
-  scoring: RawScoreResult
-): Promise<boolean> {
-  // Get current account data
-  const { data: account, error: fetchError } = await adminDb
-    .from('accounts')
-    .select('data')
-    .eq('id', accountId)
-    .single()
-
-  if (fetchError || !account) {
-    console.error(`[FunnelSignal] Account not found: ${accountId}`)
-    return false
-  }
-
-  const now = new Date().toISOString()
-
-  // Only update if this is the best signal for this stage
-  const currentStageRating = account.data?.ratings?.[stage]?.rating || 0
-  const shouldUpdate = scoring.rating > currentStageRating
-
-  if (!shouldUpdate) {
-    // Just update last_signal_at
-    await adminDb
-      .from('accounts')
-      .update({
-        data: { ...account.data, last_signal_at: now }
-      })
-      .eq('id', accountId)
-
-    return true
-  }
-
-  // Update rating and temperature — write flat to data so UI can read directly
+  accountId: string, stage: string,
+  scoring: { calculated: number; max_possible: number; rating: number },
+  pipelineSlug: string | undefined, referrerDomain: string, referrerCategory: string, now: string
+): Promise<void> {
+  const { data: account } = await adminDb.from('accounts').select('data').eq('id', accountId).single()
+  if (!account) return
+
+  const currentData = account.data || {}
   const temperature = ratingToTemperature(scoring.rating)
-  const updatedRatings = {
-    ...(account.data?.ratings || {}),
-    [stage]: {
-      rating: scoring.rating,
-      raw_score: scoring.calculated,
-      calculated_at: now
-    }
+  const ratingEntry = { rating: scoring.rating, raw_score: scoring.calculated, calculated_at: now }
+
+  const updatedRatings: Record<string, any> = { ...(currentData.ratings || {}) }
+  const currentStageRating = updatedRatings[stage]?.rating || 0
+  if (scoring.rating > currentStageRating) updatedRatings[stage] = ratingEntry
+  if (pipelineSlug) {
+    const currentPipelineRating = updatedRatings[pipelineSlug]?.rating || 0
+    if (scoring.rating >= currentPipelineRating) updatedRatings[pipelineSlug] = ratingEntry
   }
 
-  const { error } = await adminDb
-    .from('accounts')
-    .update({
-      data: {
-        ...account.data,
-        lifecycle_stage: stage,
-        lead_score: scoring.calculated,
-        temperature,
-        last_signal_at: now,
-        ratings: updatedRatings,
-        attribution: account.data?.attribution || null
-      }
-    })
-    .eq('id', accountId)
-
-  if (error) {
-    console.error(`[FunnelSignal] Failed to update account: ${error.message}`)
-    return false
+  const attribution = currentData.attribution || {
+    first_touch_referrer_domain: referrerDomain,
+    first_touch_referrer_category: referrerCategory,
+    first_touch_occurred_at: now,
   }
 
-  return true
+  await adminDb.from('accounts').update({
+    data: {
+      ...currentData,
+      lifecycle_stage: stage,
+      lead_score: scoring.calculated,
+      temperature,
+      last_signal_at: now,
+      ratings: updatedRatings,
+      attribution,
+    },
+  }).eq('id', accountId)
 }
 
 // ============================================
-// UPSERT ANONYMOUS SESSION (adminDb.from('items').insert() / .update())
+// ANONYMOUS SESSION UPSERT
 // ============================================
 
 async function upsertAnonymousSession(
-  payload: SignalPayload,
-  enrichment: EnrichmentResult,
-  scoring: RawScoreResult,
-  signalId: string,
-  ids: Awaited<ReturnType<typeof resolveIds>>
-): Promise<{ id: string; created: boolean }> {
-  const now = new Date().toISOString()
-
-  // Try to find existing session
-  const { data: existingSession } = await adminDb
+  payload: SignalPayload, sessionTypeId: string, signalId: string,
+  scoring: { calculated: number; max_possible: number; rating: number },
+  engagement: any, referrerDomain: string, referrerCategory: string, now: string
+): Promise<void> {
+  const { data: existing } = await adminDb
     .from('items')
     .select('id, data')
-    .eq('type_id', ids.TYPE_IDS.anonymous_session)
-    .eq('data->identity->>anonymous_id', payload.anonymous_id!)
-    .eq('is_active', true)
+    .eq('type_id', sessionTypeId)
+    .eq('data->identity->>anonymous_id' as any, payload.anonymous_id!)
     .order('created_at', { ascending: false })
     .limit(1)
     .maybeSingle()
 
-  if (existingSession) {
-    // Update existing session
-    const currentData = existingSession.data || {}
-    const currentRatings = currentData.scoring?.ratings || {}
-
-    const shouldUpdateRating = !currentRatings.anonymous || scoring.rating > currentRatings.anonymous.rating
-
-    const updatedData = {
-      ...currentData,
-      attribution: {
-        ...currentData.attribution,
-        current_referrer: {
-          referrer_domain: enrichment.referrer_domain,
-          referrer_url: payload.referrer || null,
-          occurred_at: now
-        }
-      },
-      scoring: {
-        ...currentData.scoring,
-        ratings: {
-          anonymous: shouldUpdateRating ? {
-            rating: scoring.rating,
-            raw_score: scoring.calculated,
-            calculated_at: now,
-            best_signal_id: signalId,
-            signal_count: (currentRatings.anonymous?.signal_count || 0) + 1
-          } : currentRatings.anonymous
-        },
-        temperature: shouldUpdateRating ? ratingToTemperature(scoring.rating) : currentData.scoring?.temperature
-      },
-      lifecycle: {
-        ...currentData.lifecycle,
-        last_activity_at: now
-      }
-    }
-
-    await adminDb
-      .from('items')
-      .update({ data: updatedData, updated_at: now })
-      .eq('id', existingSession.id)
-
-    return { id: existingSession.id, created: false }
-  }
-
-  // Create new session
-  const sessionData = {
-    identity: {
-      anonymous_id: payload.anonymous_id
-    },
-    attribution: {
-      first_touch: {
-        referrer_domain: enrichment.referrer_domain,
-        referrer_url: payload.referrer || null,
-        referrer_category: enrichment.referrer_category,
-        landing_page: payload.url || null,
-        landing_page_category: null,
-        occurred_at: now,
-        utm_source: payload.utm_source || null,
-        utm_medium: payload.utm_medium || null,
-        utm_campaign: payload.utm_campaign || null
-      },
-      current_referrer: {
-        referrer_domain: enrichment.referrer_domain,
-        referrer_url: payload.referrer || null,
-        occurred_at: now
-      }
-    },
-    scoring: {
-      ratings: {
-        anonymous: {
-          rating: scoring.rating,
-          raw_score: scoring.calculated,
-          calculated_at: now,
-          best_signal_id: signalId,
-          signal_count: 1
-        }
+  if (existing) {
+    const d = existing.data || {}
+    const shouldUpdate = scoring.rating > (d.scoring_rating || 0)
+    await adminDb.from('items').update({
+      data: {
+        ...d,
+        current_referrer_referrer_domain: referrerDomain,
+        current_referrer_referrer_url: payload.referrer || null,
+        current_referrer_occurred_at: now,
+        scoring_signal_count: (d.scoring_signal_count || 0) + 1,
+        lifecycle_last_activity_at: now,
+        ...(shouldUpdate ? {
+          scoring_rating: scoring.rating,
+          scoring_raw_score: scoring.calculated,
+          scoring_calculated_at: now,
+          scoring_best_signal_id: signalId,
+          temperature: ratingToTemperature(scoring.rating),
+        } : {}),
       },
-      current_stage: 'anonymous',
-      temperature: ratingToTemperature(scoring.rating)
-    },
-    lifecycle: {
-      created_at: now,
-      last_activity_at: now,
-      stitched_at: null,
-      stitched_to_account_id: null,
-      stitched_to_person_id: null
-    },
-    retention: {
-      retention_days: 90,
-      purge_after: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString()
-    }
-  }
-
-  const { data, error } = await adminDb
-    .from('items')
-    .insert({
-      type_id: ids.TYPE_IDS.anonymous_session,
+    }).eq('id', existing.id)
+  } else {
+    await adminDb.from('items').insert({
+      type_id: sessionTypeId,
       title: `Anonymous: ${payload.anonymous_id!.slice(0, 8)}`,
-      account_id: payload.account_id || ids.UNIDENTIFIED_VISITORS_ACCOUNT_ID,
-      data: sessionData
+      data: {
+        identity: { anonymous_id: payload.anonymous_id },
+        temperature: ratingToTemperature(scoring.rating),
+        current_stage: 'anonymous',
+        scoring_rating: scoring.rating,
+        scoring_raw_score: scoring.calculated,
+        scoring_signal_count: 1,
+        scoring_calculated_at: now,
+        scoring_best_signal_id: signalId,
+        first_touch_referrer_domain: referrerDomain,
+        first_touch_referrer_category: referrerCategory,
+        first_touch_referrer_url: payload.referrer || null,
+        first_touch_landing_page: payload.url || null,
+        first_touch_occurred_at: now,
+        first_touch_utm_source: payload.utm_source || null,
+        first_touch_utm_medium: payload.utm_medium || null,
+        first_touch_utm_campaign: payload.utm_campaign || null,
+        current_referrer_referrer_domain: referrerDomain,
+        current_referrer_referrer_url: payload.referrer || null,
+        current_referrer_occurred_at: now,
+        lifecycle_created_at: now,
+        lifecycle_last_activity_at: now,
+        retention_retention_days: 90,
+        retention_purge_after: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString(),
+      },
     })
-    .select('id')
-    .single()
-
-  if (error) {
-    throw new Error(`Failed to create anonymous session: ${error.message}`)
   }
-
-  return { id: data.id, created: true }
 }
 
 // ============================================
-// CREATE ACCOUNT-SIGNAL LINK (adminDb.from('links').insert())
+// LINK CREATION
 // ============================================
 
-async function createAccountSignalLink(accountId: string, signalId: string, ids: Awaited<ReturnType<typeof resolveIds>>): Promise<void> {
-  const { error } = await adminDb
-    .from('links')
-    .insert({
-      link_type_id: ids.LINK_TYPE_IDS.account_signals,
-      source_type: 'account',
-      source_id: accountId,
-      target_type: 'item',
-      target_id: signalId,
-      data: { created_at: new Date().toISOString() }
-    })
-
-  if (error) {
-    console.error(`[FunnelSignal] Failed to create link: ${error.message}`)
-  }
+async function createLink(
+  linkTypeId: string, sourceType: string, sourceId: string, targetType: string, targetId: string
+): Promise<void> {
+  await adminDb.from('links').insert({
+    link_type_id: linkTypeId,
+    source_type: sourceType,
+    source_id: sourceId,
+    target_type: targetType,
+    target_id: targetId,
+  }).catch((err: any) => console.error('[FunnelSignal] Link insert failed:', err.message))
 }
 
 // ============================================
-// EVALUATE QUEUE ENTRY
+// QUEUE ENTRY EVALUATION
 // ============================================
 
 async function evaluateQueueEntry(
-  payload: SignalPayload,
-  scoring: RawScoreResult,
-  signalId: string,
-  ids: Awaited<ReturnType<typeof resolveIds>>
-): Promise<{ id: string } | null> {
-  // Infer opportunity type
-  const inference = inferOpportunityType([{ action: payload }], payload.stage, scoring.rating)
-
-  const now = new Date().toISOString()
+  payload: SignalPayload, queueTypeId: string, opportunityLinkTypeId: string | null,
+  signalId: string, scoring: { calculated: number; max_possible: number; rating: number }, now: string
+): Promise<void> {
+  const inference = inferOpportunityType(
+    [{ action: { action_type: payload.action_type } }],
+    payload.stage, scoring.rating
+  )
 
-  const queueData = {
-    identity: {
-      account_id: payload.account_id || null,
-      person_id: payload.person_id || null
-    },
-    trigger: {
-      source_signal_id: signalId,
-      trigger_stage: payload.stage,
-      trigger_rating: scoring.rating,
-      trigger_raw_score: scoring.calculated,
-      trigger_reason: `High engagement: ${inference.type}`
+  const { data: queueItem } = await adminDb.from('items').insert({
+    type_id: queueTypeId,
+    title: `${inference.type} - ${inference.confidence} priority`,
+    account_id: payload.account_id || null,
+    data: {
+      identity_account_id: payload.account_id || null,
+      trigger_source_signal_id: signalId,
+      trigger_trigger_stage: payload.stage,
+      trigger_trigger_rating: scoring.rating,
+      trigger_trigger_raw_score: scoring.calculated,
+      trigger_trigger_reason: `High engagement: ${inference.type}`,
+      recommendation_opportunity_type: inference.type,
+      recommendation_confidence: inference.confidence,
+      recommendation_suggested_priority: Math.min(scoring.rating, 5),
+      review_status: 'pending',
+      notes_auto_reason: `Auto-generated: ${inference.type} opportunity detected with confidence ${inference.confidence}`,
     },
-    recommendation: {
-      opportunity_type: inference.type,
-      confidence: inference.confidence,
-      suggested_priority: Math.min(scoring.rating, 5)
-    },
-    review: {
-      status: 'pending',
-      reviewed_by: null,
-      reviewed_at: null,
-      conversion_opportunity_id: null
-    },
-    notes: {
-      reviewer_notes: null,
-      auto_reason: `Auto-generated: ${inference.type} opportunity detected with confidence ${inference.confidence}`
+  }).select('id').single().then((r: { data: { id: string } | null }) => r.data).catch(() => null)
+
+  if (payload.account_id && queueItem?.id) {
+    const { data: acct } = await adminDb.from('accounts').select('data').eq('id', payload.account_id).single()
+    if (acct) {
+      await adminDb.from('accounts').update({
+        data: { ...(acct.data || {}), queue: { pending_opportunity_id: queueItem.id } },
+      }).eq('id', payload.account_id)
+    }
+    if (opportunityLinkTypeId) {
+      await createLink(opportunityLinkTypeId, 'account', payload.account_id, 'item', queueItem.id)
     }
   }
-
-  const { data, error } = await adminDb
-    .from('items')
-    .insert({
-      type_id: ids.TYPE_IDS.opportunity_queue,
-      title: `${inference.type} - ${inference.confidence} priority`,
-      account_id: payload.account_id || ids.UNIDENTIFIED_VISITORS_ACCOUNT_ID,
-      data: queueData
-    })
-    .select('id')
-    .single()
-
-  if (error) {
-    console.error(`[FunnelSignal] Failed to create queue entry: ${error.message}`)
-    return null
-  }
-
-  // If we have an account, update the queue reference and create link
-  if (payload.account_id) {
-    const { data: acct } = await adminDb
-      .from('accounts')
-      .select('data')
-      .eq('id', payload.account_id)
-      .single()
-
-    await adminDb
-      .from('accounts')
-      .update({
-        data: {
-          ...(acct?.data || {}),
-          queue: { pending_opportunity_id: data.id }
-        }
-      })
-      .eq('id', payload.account_id)
-
-    await adminDb
-      .from('links')
-      .insert({
-        link_type_id: ids.LINK_TYPE_IDS.account_opportunities,
-        source_type: 'account',
-        source_id: payload.account_id,
-        target_type: 'item',
-        target_id: data.id
-      })
-  }
-
-  return { id: data.id }
 }
 
 // ============================================
-// UTILITY FUNCTIONS
+// UTILITIES
 // ============================================
 
 function extractDomain(url: string | undefined): string {
   if (!url) return 'direct'
-  try {
-    const urlObj = new URL(url)
-    return urlObj.hostname.replace(/^www\./, '')
-  } catch {
-    return url
-  }
+  try { return new URL(url).hostname.replace(/^www\./, '') } catch { return url }
 }
 
-function ratingToTemperature(rating: number): 'cold' | 'warm' | 'hot' {
+function ratingToTemperature(rating: number): 'cold' | 'warm' | 'hot' | 'on_fire' {
   if (rating <= 2) return 'cold'
   if (rating <= 3) return 'warm'
-  return 'hot'
+  if (rating <= 4) return 'hot'
+  return 'on_fire'
 }