spine-framework-cortex 0.1.14 → 0.1.16

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [0.1.16] — 2026-06-09
+- Fixed `integrations.json` seed — removed non-existent `description` column, changed `display_name` to `name`, added required `slug`, `provider`, `status` fields
+
+## [0.1.15] — 2026-06-09
+- Fixed `integrations.json` handler config format for `funnel-signal-mar` and `funnel-signal-use` integrations
+- Removed orphaned `on_funnel_signal_created` trigger from `triggers.json` — trigger engine requires `pipeline_id` and cannot directly invoke custom functions
+- Removed orphaned `funnel-scoring-trigger` handler registration from `webhook-handlers.ts`
+- Deleted orphaned `custom_funnel-scoring-trigger.ts` file
+- Restored `custom_funnel-signal.ts` as complete inline handler with full scoring, account updates, link creation, and queue evaluation
+
 ## [0.1.14] — 2026-06-09
 - Added **Command Center** page (`/ops/command-center`) — KPI strip, Hot Opportunities table, Audit/Install funnel tab strip, funnel health panels
 - Added **Audit Funnel** page (`/ops/audit-funnel`) — account list filtered to `funnel-ai-audit` pipeline, sorted by signal score, with recommended offer logic

package/functions/custom_funnel-signal.ts

@@ -1,56 +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'
-import { fireCreateTriggers, SYSTEM_PRINCIPAL } from './_shared/index'
-
-// 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,
@@ -58,62 +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, payload.pipeline_slug)
-
-    // 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)
-  }
-
-  // 6. EVALUATE QUEUE (if rating >= 4)
-  let queueEntry = null
-  if (scoring.rating >= 4) {
-    queueEntry = await evaluateQueueEntry(payload, 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)
   }
 
-  // 7. FIRE TRIGGERS — lets core pipeline/trigger engine handle downstream automation
-  const triggerCtx = {
-    principal: SYSTEM_PRINCIPAL,
-    accountId: payload.account_id || ids.UNIDENTIFIED_VISITORS_ACCOUNT_ID,
-    db: adminDb,
-    requestId: scriptContext?.requestId || crypto.randomUUID(),
+  // 7. EVALUATE QUEUE — if rating >= 4
+  if (scoring.rating >= 4 && queueTypeId) {
+    await evaluateQueueEntry(payload, queueTypeId, opportunityLinkTypeId, signalId, scoring, scoredAt)
   }
-  await fireCreateTriggers('item', signalItem.id, signalItem, triggerCtx)
 
   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
   }
 }
 
@@ -121,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
@@ -179,517 +187,243 @@ interface SignalPayload {
   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,
-      pipeline_slug: payload.pipeline_slug || null
-    },
-    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,
-  pipelineSlug?: string
-): 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 ratingEntry = { rating: scoring.rating, raw_score: scoring.calculated, calculated_at: now }
-  const updatedRatings: Record<string, any> = {
-    ...(account.data?.ratings || {}),
-    [stage]: ratingEntry,
-  }
-  // Also store per-pipeline_slug so UI can show per-funnel score breakdown
+
+  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
-    }
+    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}`
-    },
-    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
+  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}`,
     },
-    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'
 }

package/functions/webhook-handlers.ts

@@ -26,3 +26,4 @@ registerWebhookHandler({
   description: 'Funnel signal processing webhook handler',
   events: ['integration.webhook'],
 }).catch(console.error)
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-cortex",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Cortex — AI-powered support, CRM, and knowledge base app for Spine Framework",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",

package/pages/intelligence/IntelligencePage.tsx

@@ -11,11 +11,11 @@ interface FunnelSignal {
   id: string
   title: string
   data: {
-    signal_type: string
-    score_delta: number
-    account_id?: string
-    person_id?: string
-    occurred_at: string
+    action?: { action_type?: string; action_value?: number }
+    identity?: { account_id?: string; person_id?: string; anonymous_id?: string }
+    classification?: { stage?: string; source?: string }
+    scoring_components?: { raw_score?: { rating?: number; calculated?: number } }
+    processing?: { received_at?: string; scored_at?: string }
   }
   created_at: string
 }
@@ -95,7 +95,7 @@ export default function IntelligencePage() {
 
   useEffect(() => {
     if (accountsData) {
-      setAccounts(accountsData.filter((acc: any) => acc.data?.lead_score !== undefined))
+      setAccounts(accountsData.filter((acc: any) => acc.data?.lead_score !== undefined || acc.data?.lifecycle_stage))
     }
   }, [accountsData])
 
@@ -206,28 +206,35 @@ export default function IntelligencePage() {
             <CardContent>
               <div className="space-y-3">
                 {signals
-                  .filter(signal => signal.data.account_id === selectedAccountId)
+                  .filter(signal => signal.data?.identity?.account_id === selectedAccountId)
                   .slice(0, 5)
-                  .map((signal) => (
-                    <div key={signal.id} className="flex items-center justify-between p-3 border rounded">
-                      <div className="flex items-center space-x-3">
-                        <Badge className={getSignalTypeColor(signal.data.signal_type)}>
-                          {signal.data.signal_type}
-                        </Badge>
-                        <div>
-                          <div className="font-medium">{signal.title}</div>
-                          <div className="text-sm text-gray-500">
-                            {new Date(signal.data.occurred_at).toLocaleDateString()}
+                  .map((signal) => {
+                    const actionType = signal.data?.action?.action_type
+                    const rating = signal.data?.scoring_components?.raw_score?.rating
+                    const receivedAt = signal.data?.processing?.received_at || signal.created_at
+                    return (
+                      <div key={signal.id} className="flex items-center justify-between p-3 border rounded">
+                        <div className="flex items-center space-x-3">
+                          <Badge className={getSignalTypeColor(actionType || '')}>
+                            {actionType || signal.title}
+                          </Badge>
+                          <div>
+                            <div className="font-medium">{signal.title}</div>
+                            <div className="text-sm text-gray-500">
+                              {new Date(receivedAt).toLocaleDateString()}
+                            </div>
                           </div>
                         </div>
+                        {rating !== undefined && (
+                          <div className={`font-bold ${
+                            rating >= 4 ? 'text-green-600' : rating >= 3 ? 'text-yellow-600' : 'text-gray-500'
+                          }`}>
+                            {rating}/5
+                          </div>
+                        )}
                       </div>
-                      <div className={`font-bold ${
-                        signal.data.score_delta > 0 ? 'text-green-600' : 'text-red-600'
-                      }`}>
-                        {signal.data.score_delta > 0 ? '+' : ''}{signal.data.score_delta}
-                      </div>
-                    </div>
-                  ))}
+                    )
+                  })}
               </div>
             </CardContent>
           </Card>

package/seed/integrations.json

@@ -0,0 +1,24 @@
+[
+  {
+    "name": "Funnel Signal: Marketing",
+    "slug": "funnel-signal-mar",
+    "provider": "webhook",
+    "status": "active",
+    "is_active": true,
+    "config": {
+      "handler": { "path": "funnel-signal" },
+      "description": "Marketing signal ingest via integration-routes"
+    }
+  },
+  {
+    "name": "Funnel Signal: Usage",
+    "slug": "funnel-signal-use",
+    "provider": "webhook",
+    "status": "active",
+    "is_active": true,
+    "config": {
+      "handler": { "path": "funnel-signal" },
+      "description": "Usage signal ingest via integration-routes"
+    }
+  }
+]

package/seed/types.json

@@ -1,4 +1,63 @@
 [
+  {
+    "kind": "account",
+    "slug": "account",
+    "name": "Account",
+    "description": "Customer or prospect account with funnel intelligence tracking",
+    "icon": "building",
+    "color": "#3b82f6",
+    "ownership": "tenant",
+    "is_active": true,
+    "design_schema": {
+      "scope": "account",
+      "fields": {
+        "name": { "label": "Name", "system": true, "required": true, "data_type": "text", "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "slug": { "label": "Slug", "system": true, "required": false, "data_type": "text", "permissions": { "system_admin": ["read", "write"], "support": ["read"], "member": ["read"] } },
+        "is_active": { "label": "Active", "system": true, "required": true, "data_type": "boolean", "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "created_at": { "label": "Created", "system": true, "readonly": true, "required": false, "data_type": "datetime", "permissions": { "system_admin": ["read"], "support": ["read"], "member": ["read"] } },
+        "updated_at": { "label": "Updated", "system": true, "readonly": true, "required": false, "data_type": "datetime", "permissions": { "system_admin": ["read"], "support": ["read"], "member": ["read"] } },
+        "lifecycle_stage": { "label": "Lifecycle Stage", "system": false, "required": false, "data_type": "select", "options": [{"label":"Anonymous","value":"anonymous"},{"label":"Identified","value":"identified"},{"label":"Installed","value":"installed"},{"label":"Qualified","value":"qualified"},{"label":"Customer","value":"customer"},{"label":"Churned","value":"churned"}], "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "lead_score": { "label": "Lead Score", "system": false, "required": false, "data_type": "number", "validation": { "min": 0, "max": 25 }, "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "temperature": { "label": "Temperature", "system": false, "required": false, "data_type": "select", "options": [{"label":"Cold","value":"cold"},{"label":"Warm","value":"warm"},{"label":"Hot","value":"hot"},{"label":"On Fire","value":"on_fire"}], "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "last_signal_at": { "label": "Last Signal At", "system": false, "required": false, "data_type": "datetime", "permissions": { "system_admin": ["read", "write"], "support": ["read"], "member": ["read"] } },
+        "ratings": { "label": "Ratings", "system": false, "required": false, "data_type": "json", "permissions": { "system_admin": ["read", "write"], "support": ["read"], "member": ["read"] } },
+        "attribution": { "label": "Attribution", "system": false, "required": false, "data_type": "json", "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "claim_status": { "label": "Claim Status", "system": false, "required": false, "data_type": "select", "options": [{"label":"Unclaimed","value":"unclaimed"},{"label":"Claimed","value":"claimed"},{"label":"Verified","value":"verified"}], "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "claimed_apps": { "label": "Claimed Apps", "system": false, "required": false, "data_type": "json", "permissions": { "system_admin": ["read", "write"], "support": ["read"], "member": ["read"] } },
+        "segment": { "label": "Segment", "system": false, "required": false, "data_type": "text", "permissions": { "system_admin": ["read", "write"], "support": ["read", "write"], "member": ["read"] } },
+        "queue": { "label": "Queue", "system": false, "required": false, "data_type": "json", "permissions": { "system_admin": ["read", "write"], "support": ["read"], "member": ["read"] } }
+      },
+      "views": {
+        "default_list": {
+          "type": "list",
+          "display": "table",
+          "label": "Accounts",
+          "fields": {
+            "name": { "sortable": true, "display_type": "text" },
+            "lifecycle_stage": { "sortable": true, "display_type": "badge" },
+            "lead_score": { "sortable": true, "display_type": "number" },
+            "temperature": { "sortable": true, "display_type": "badge" },
+            "claim_status": { "sortable": true, "display_type": "badge" },
+            "last_signal_at": { "sortable": true, "display_type": "timestamp" }
+          },
+          "default_sort": { "field": "last_signal_at", "direction": "desc" }
+        },
+        "default_detail": {
+          "type": "detail",
+          "label": "Account",
+          "sections": [
+            { "title": "Identity", "fields": { "name": { "display_type": "input" }, "slug": { "display_type": "text" }, "is_active": { "display_type": "badge" } } },
+            { "title": "Funnel Intelligence", "fields": { "lifecycle_stage": { "display_type": "badge" }, "lead_score": { "display_type": "number" }, "temperature": { "display_type": "badge" }, "last_signal_at": { "display_type": "timestamp" }, "segment": { "display_type": "text" } } },
+            { "title": "Attribution", "fields": { "attribution": { "display_type": "json" } } },
+            { "title": "App Registrations", "fields": { "claim_status": { "display_type": "badge" }, "claimed_apps": { "display_type": "json" } } }
+          ]
+        }
+      },
+      "record_permissions": { "system_admin": ["create", "read", "update", "delete"], "support": ["create", "read", "update"], "member": ["read"] },
+      "functionality": null
+    },
+    "validation_schema": {}
+  },
   {
     "kind": "item",
     "slug": "case_analysis",