spine-framework-cortex 0.2.21 → 0.2.22

package/functions/custom_case_analysis.ts

@@ -1,507 +1,292 @@
 import { createHandler } from './_shared/middleware'
 import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId, resolveLinkTypeId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+import { embedResolvedCase } from './custom_kb-embeddings'
 
 /**
- * Custom Case Analysis Handler
+ * @module custom_case_analysis
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * Post-resolution case analysis. Triggered when a support ticket is resolved.
  *
  * Action: POST ?action=analyze_ticket
- * 
- * Analyzes resolved support tickets to extract insights, identify root causes, 
- * and suggest improvements. Creates case_analysis items and manages tags.
  *
  * Process:
- * 1. Fetch ticket data, threads, and messages
- * 2. Run AI analysis with structured prompt
- * 3. Process tag suggestions (check existence, create if needed)
- * 4. Create case_analysis item with results
- * 5. Update ticket with analysis summary and tags
+ *   1. Load ticket + all thread messages (external + internal + solution AI)
+ *   2. Create a temporary internal analysis thread wired to Case Resolution Analysis Agent
+ *   3. Call runAgent() with the full case context — agent returns structured JSON
+ *   4. Parse JSON from agent message content
+ *   5. Upsert tags, create case_analysis item, update ticket with ca_ fields
+ *   6. Trigger embedResolvedCase() to embed for future RAG
+ *
+ * The analysis thread persists as an audit trail of the AI's reasoning.
  */
 
-// ─── CONSTANTS ────────────────────────────────────────────────────────────────
-
-const ANALYSIS_AGENT_ID = 'case_analysis_agent' // Will be looked up by name
-const PROMPT_CONFIG_ID = 'case_analysis_prompt' // Will be looked up by slug
-const SUPPORT_TICKET_TYPE_ID = '82320862-a99c-4a84-b7ed-c2832cf519cd' // From existing triage
-const CASE_ANALYSIS_TYPE_ID = 'case_analysis' // Will be looked up by slug
-const TAG_TYPE_ID = 'tag' // Will be looked up by slug
-
 // ─── TYPES ────────────────────────────────────────────────────────────────────
 
-interface AnalysisRequest {
-  ticket_id: string
-}
-
-interface AnalysisResult {
-  ticketId: string
-  caseAnalysisId: string
-  analysisData: any
-  createdTags: string[]
-  confidence: number
-}
+interface AnalysisRequest { ticket_id: string }
 
 // ─── HELPERS ──────────────────────────────────────────────────────────────────
 
-async function getTicketData(ticketId: string): Promise<any> {
-  const { data: ticket, error } = await adminDb
-    .from('items')
-    .select('*')
-    .eq('id', ticketId)
-    .eq('type_id', SUPPORT_TICKET_TYPE_ID)
-    .single()
-  
-  if (error || !ticket) throw new Error(`Ticket not found: ${error?.message}`)
-  return ticket
-}
-
-async function getConversationHistory(ticketId: string): Promise<any[]> {
-  // Get threads for this ticket
-  const { data: threads, error: threadError } = await adminDb
+async function loadConversationContext(ticketId: string): Promise<{
+  externalMessages: any[]
+  internalMessages: any[]
+  solutionMessages: any[]
+}> {
+  const { data: threads } = await adminDb
     .from('threads')
-    .select('id')
+    .select('id, visibility, data')
     .eq('target_type', 'items')
     .eq('target_id', ticketId)
-  
-  if (threadError || !threads || threads.length === 0) return []
-  
-  const threadId = threads[0].id
-  
-  // Get messages for this thread
-  const { data: messages, error: msgError } = await adminDb
-    .from('messages')
-    .select('content, direction, data, created_at, person_id')
-    .eq('thread_id', threadId)
-    .eq('visibility', 'public')
-    .order('created_at', { ascending: true })
-    .limit(50)
-  
-  if (msgError) return []
-  return messages || []
-}
-
-async function getAgentAndPrompt(): Promise<{ agent: any; promptConfig: any }> {
-  const [{ data: agent }, { data: promptConfig }] = await Promise.all([
-    adminDb.from('ai_agents').select('*').eq('name', 'Case Resolution Analysis Agent').single(),
-    adminDb.from('prompt_configs').select('*').eq('slug', 'case_analysis_prompt').single()
-  ])
-  
-  if (!agent || !promptConfig) {
-    throw new Error('Case analysis agent or prompt configuration not found')
-  }
-  
-  return { agent, promptConfig }
-}
-
-async function callOpenAI(
-  systemPrompt: string,
-  messages: Array<{ role: 'user' | 'assistant' | 'system'; content: string }>,
-  model: string,
-  temperature: number
-): Promise<{ envelope: any; latency_ms: number; token_usage: any }> {
-  const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY
-  const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
-  const startTime = Date.now()
-
-  if (!apiKey) {
-    const mockEnvelope = {
-      reported_issue: 'Mock reported issue - no API key configured',
-      true_problem: 'Mock true problem - no API key configured',
-      diagnostic_steps: ['Mock step 1', 'Mock step 2'],
-      solution_steps: ['Mock solution step 1', 'Mock solution step 2'],
-      final_solution: 'Mock final solution - no API key configured',
-      customer_temperature: 'neutral',
-      time_to_resolution: 60,
-      escalation_required: false,
-      back_and_forth_count: 2,
-      sentiment_progression: ['neutral', 'neutral', 'neutral'],
-      automation_potential: 'medium',
-      kb_candidate: false,
-      suggested_tags: [],
-      confidence_score: 0.5,
-      analysis_summary: 'Mock analysis - no API key configured'
-    }
-    return { envelope: mockEnvelope, latency_ms: 0, token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } }
-  }
-
-  const res = await fetch(`${baseUrl}/chat/completions`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
-    body: JSON.stringify({
-      model,
-      temperature,
-      response_format: { type: 'json_object' },
-      messages: [{ role: 'system', content: systemPrompt }, ...messages],
-    }),
-  })
-
-  if (!res.ok) {
-    const err = await res.text()
-    throw new Error(`OpenAI error ${res.status}: ${err.slice(0, 200)}`)
-  }
-
-  const result: any = await res.json()
-  const raw = result.choices?.[0]?.message?.content || '{}'
-  let envelope: any
 
-  try {
-    envelope = JSON.parse(raw)
-  } catch (parseErr: any) {
-    envelope = {
-      reported_issue: 'Parse failure',
-      true_problem: 'Parse failure',
-      diagnostic_steps: ['Parse failure'],
-      solution_steps: ['Parse failure'],
-      final_solution: `Parse failure: ${parseErr.message}`,
-      customer_temperature: 'neutral',
-      time_to_resolution: 0,
-      escalation_required: true,
-      back_and_forth_count: 0,
-      sentiment_progression: ['neutral'],
-      automation_potential: 'low',
-      kb_candidate: false,
-      suggested_tags: [],
-      confidence_score: 0,
-      analysis_summary: `Parse failure: ${parseErr.message}. Raw: ${raw.slice(0, 200)}`
+  const result = { externalMessages: [], internalMessages: [], solutionMessages: [] } as any
+
+  for (const thread of threads || []) {
+    const { data: msgs } = await adminDb
+      .from('messages')
+      .select('content, direction, visibility, created_at')
+      .eq('thread_id', thread.id)
+      .eq('visibility', thread.data?.thread_purpose === 'solution_ai' ? 'internal' : 'public')
+      .order('created_at', { ascending: true })
+      .limit(100)
+
+    const messages = msgs || []
+    if (thread.data?.thread_purpose === 'solution_ai') {
+      result.solutionMessages = messages
+    } else if (thread.visibility === 'internal') {
+      result.internalMessages = messages
+    } else {
+      result.externalMessages = messages
     }
   }
+  return result
+}
 
-  return {
-    envelope,
-    latency_ms: Date.now() - startTime,
-    token_usage: result.usage || {},
-  }
+function formatMessages(msgs: any[], label: string): string {
+  if (!msgs.length) return ''
+  return `\n\n## ${label}\n` + msgs.map(m => {
+    const role = m.direction === 'inbound' ? 'Customer' : 'Agent'
+    return `${role}: ${m.content}`
+  }).join('\n')
 }
 
-async function getOrCreateTag(tagData: any, accountId: string): Promise<string> {
+async function upsertTag(tagData: any, accountId: string, tagTypeId: string): Promise<string | null> {
   const { slug, name, purpose, category, applicable_to } = tagData
-  
-  // Check if tag already exists
-  const { data: existingTag } = await adminDb
+  if (!slug || !name) return null
+
+  const { data: existing } = await adminDb
     .from('items')
     .select('id')
-    .eq('type_id', TAG_TYPE_ID)
+    .eq('type_id', tagTypeId)
     .eq('data->>slug', slug)
-    .single()
-  
-  if (existingTag) {
-    // Increment usage count
-    await adminDb
-      .from('items')
-      .update({
-        data: adminDb.sql`jsonb_set(data, '{usage_count}', COALESCE((data->>'usage_count')::int, 0) + 1)`,
-        updated_at: new Date().toISOString()
-      })
-      .eq('id', existingTag.id)
-    
-    return existingTag.id
-  }
-  
-  // Get tag type ID
-  const { data: tagType } = await adminDb
-    .from('types')
-    .select('id')
-    .eq('slug', 'tag')
-    .single()
-  
-  if (!tagType) throw new Error('Tag type not found')
-  
-  // Create new tag
-  const { data: newTag, error } = await adminDb
+    .maybeSingle()
+
+  if (existing) return existing.id
+
+  const { data: newTag } = await adminDb
     .from('items')
     .insert({
-      type_id: tagType.id,
+      type_id: tagTypeId,
       account_id: accountId,
       title: name,
-      description: purpose,
-      data: {
-        slug,
-        name,
-        purpose,
-        applicable_to: applicable_to || ['ticket'],
-        category,
-        usage_count: 1
-      },
-      status: 'active'
+      description: purpose || '',
+      status: 'active',
+      data: { slug, name, purpose, applicable_to: applicable_to || ['ticket'], category, usage_count: 1 }
     })
     .select('id')
     .single()
-  
-  if (error || !newTag) throw new Error(`Failed to create tag: ${error?.message}`)
-  return newTag.id
-}
 
-async function createCaseAnalysis(
-  ticketId: string,
-  analysisData: any,
-  confidence: number,
-  agentId: string,
-  accountId: string
-): Promise<string> {
-  // Get case_analysis type ID
-  const { data: caseAnalysisType } = await adminDb
-    .from('types')
-    .select('id')
-    .eq('slug', 'case_analysis')
-    .single()
-  
-  if (!caseAnalysisType) throw new Error('Case analysis type not found')
-  
-  const { data: caseAnalysis, error } = await adminDb
-    .from('items')
-    .insert({
-      type_id: caseAnalysisType.id,
-      account_id: accountId,
-      title: `Analysis for Ticket ${ticketId.slice(0, 8)}`,
-      data: {
-        ticket_id: ticketId,
-        analysis_data: analysisData,
-        confidence_score: confidence,
-        analysis_timestamp: new Date().toISOString(),
-        ai_agent_id: agentId
-      },
-      status: 'completed'
-    })
-    .select('id')
-    .single()
-  
-  if (error || !caseAnalysis) throw new Error(`Failed to create case analysis: ${error?.message}`)
-  
-  // Create entity link from case analysis to ticket
-  await createEntityLink(
-    caseAnalysis.id,
-    'items',
-    ticketId,
-    'items',
-    'analyzed_by',
-    accountId
-  )
-  
-  return caseAnalysis.id
+  return newTag?.id ?? null
 }
 
-async function createEntityLink(
-  sourceId: string,
-  sourceType: string,
-  targetId: string,
-  targetType: string,
-  linkTypeSlug: string,
-  accountId: string
-): Promise<void> {
-  // Get link type ID
-  const { data: linkType } = await adminDb
-    .from('link_types')
-    .select('id')
-    .eq('slug', linkTypeSlug)
-    .single()
-  
-  if (!linkType) throw new Error(`Link type '${linkTypeSlug}' not found`)
-  
-  // Get link type ID for the links table
-  const { data: linkItemType } = await adminDb
-    .from('types')
-    .select('id')
-    .eq('slug', 'link')
-    .single()
-  
-  if (!linkItemType) throw new Error('Link type not found')
-  
-  // Check if link already exists
-  const { data: existingLink } = await adminDb
-    .from('links')
-    .select('id')
-    .eq('source_id', sourceId)
-    .eq('source_type', sourceType)
-    .eq('target_id', targetId)
-    .eq('target_type', targetType)
-    .eq('link_type_id', linkType.id)
-    .single()
-  
-  if (existingLink) return // Link already exists
-  
-  // Create the link
-  const { error } = await adminDb
-    .from('links')
-    .insert({
-      type_id: linkItemType.id, // Required field
-      link_type_id: linkType.id,
-      account_id: accountId,
-      source_type: sourceType,
-      source_id: sourceId,
-      target_type: targetType,
-      target_id: targetId,
-      link_type: linkTypeSlug,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString()
-    })
-  
-  if (error) throw new Error(`Failed to create entity link: ${error?.message}`)
-}
-
-async function createTagLinks(
-  ticketId: string,
-  tagIds: string[],
-  accountId: string
-): Promise<void> {
-  for (const tagId of tagIds) {
-    await createEntityLink(
-      ticketId,
-      'items',
-      tagId,
-      'items',
-      'tagged_with',
-      accountId
-    )
-  }
-}
-
-async function updateTicketWithAnalysis(
-  ticketId: string,
-  analysisData: any,
-  tagIds: string[]
-): Promise<void> {
-  // Get current ticket data
-  const { data: ticket, error: fetchError } = await adminDb
-    .from('items')
-    .select('data')
-    .eq('id', ticketId)
-    .single()
-
-  if (fetchError || !ticket) {
-    throw new Error(`Ticket not found: ${ticketId}`)
-  }
-
-  // Map analysis data to ca_ prefixed field names to match design schema
-  const mappedAnalysisData = {
-    ca_reported_issue: analysisData.reported_issue,
-    ca_true_problem: analysisData.true_problem,
-    ca_final_solution: analysisData.final_solution,
-    ca_diagnostic_steps: analysisData.diagnostic_steps,
-    ca_solution_steps: analysisData.solution_steps,
-    ca_analysis_tags: tagIds,
-    ca_time_to_resolution: analysisData.time_to_resolution,
-    ca_back_and_forth_count: analysisData.back_and_forth_count,
-    ca_escalation_required: analysisData.escalation_required,
-    ca_automation_potential: analysisData.automation_potential,
-    ca_customer_temperature: analysisData.customer_temperature,
-    ca_kb_candidate: analysisData.kb_candidate,
-    ca_sentiment_progression: analysisData.sentiment_progression,
-    analysis_timestamp: new Date().toISOString()
-  }
-
-  // Update ticket with analysis data using simple object merge
-  const { error } = await adminDb
-    .from('items')
-    .update({
-      data: {
-        ...ticket.data,
-        ...mappedAnalysisData
-      },
-      updated_at: new Date().toISOString()
-    })
-    .eq('id', ticketId)
-
-  if (error) {
-    throw new Error(`Failed to update ticket with analysis: ${error.message}`)
-  }
-}
-
-// ─── ACTION: ANALYZE TICKET ─────────────────────────────────────────────────────
+// ─── ACTION: ANALYZE TICKET ───────────────────────────────────────────────────
 
-async function handleAnalyzeTicket(ctx: any, body: AnalysisRequest): Promise<AnalysisResult> {
+async function handleAnalyzeTicket(ctx: any, body: AnalysisRequest) {
   const { ticket_id } = body
   const account_id = ctx.accountId as string
-  
   if (!ticket_id) throw new Error('ticket_id is required')
   if (!account_id) throw new Error('Account context required')
 
-  // Load ticket and conversation data
-  const [ticket, conversationHistory, { agent, promptConfig }] = await Promise.all([
-    getTicketData(ticket_id),
-    getConversationHistory(ticket_id),
-    getAgentAndPrompt()
+  // Load ticket
+  const { data: ticket, error: ticketErr } = await adminDb
+    .from('items')
+    .select('*')
+    .eq('id', ticket_id)
+    .single()
+  if (ticketErr || !ticket) throw new Error(`Ticket not found: ${ticket_id}`)
+  if (ticket.status !== 'resolved') throw new Error('Ticket must be resolved before analysis')
+
+  // Resolve IDs
+  const [threadTypeId, analysisAgentId, promptConfigId, caseAnalysisTypeId, tagTypeId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('Case Resolution Analysis Agent'),
+    resolvePromptConfigId('case_analysis_prompt'),
+    resolveTypeId('item', 'case_analysis'),
+    resolveTypeId('item', 'tag'),
   ])
 
-  // Verify ticket is resolved
-  if (ticket.status !== 'resolved') {
-    throw new Error('Ticket must be resolved before analysis')
-  }
-
-  const modelConfig = agent.model_config || {}
-  const model = modelConfig.model || process.env.LLM_DEFAULT_MODEL || 'gpt-4o'
-  const temperature = modelConfig.temperature ?? 0.3
-
-  // Build analysis prompt
-  const contextTemplate = promptConfig.context_template
-    .replace('{{ticket_title}}', ticket.title || '')
-    .replace('{{ticket_description}}', ticket.description || '')
-    .replace('{{created_at}}', ticket.created_at || '')
-    .replace('{{resolved_at}}', ticket.updated_at || '')
-    .replace('{{status}}', ticket.data?.status || ticket.status || '')
-    .replace('{{priority}}', ticket.data?.priority || 'medium')
-
-  const conversationText = conversationHistory.map(msg => {
-    const role = msg.direction === 'inbound' ? 'Customer' : 'Agent'
-    return `${role}: ${msg.content}`
-  }).join('\n')
+  // Load full conversation context (external + internal + solution AI)
+  const { externalMessages, internalMessages, solutionMessages } = await loadConversationContext(ticket_id)
+
+  // Build the analysis prompt as the user message to the agent.
+  // The agent's context_template handles placeholders; we pass everything here.
+  const conversationText =
+    formatMessages(externalMessages, 'Customer Conversation') +
+    formatMessages(internalMessages, 'Internal Support Notes') +
+    formatMessages(solutionMessages, 'Solution AI Collaboration')
+
+  const analysisPrompt = [
+    `Ticket: ${ticket.title}`,
+    `Description: ${ticket.description || ''}`,
+    `Created: ${ticket.created_at}`,
+    `Resolved: ${ticket.updated_at}`,
+    `Status: ${ticket.status}`,
+    `Priority: ${ticket.data?.priority || 'medium'}`,
+    conversationText,
+    '\nProduce the full structured postmortem JSON.'
+  ].join('\n')
+
+  // Create a dedicated analysis thread — persists as audit trail
+  const analysisThread = await create(ctx, {
+    entity: 'threads',
+    type_id: threadTypeId,
+    target_type: 'items',
+    target_id: ticket_id,
+    visibility: 'internal',
+    status: 'active',
+    data: {
+      thread_purpose: 'case_analysis',
+      agent_id: analysisAgentId,
+      prompt_config_id: promptConfigId,
+    }
+  })
+  if (!analysisThread?.id) throw new Error('Failed to create analysis thread')
 
-  const fullPrompt = contextTemplate.replace('{{conversation_history}}', conversationText)
+  // Run the agent — saves messages, handles RAG (none needed here), returns message row
+  const agentMsg = await runAgent(analysisThread.id, analysisPrompt, ctx)
 
-  // Run AI analysis
-  const promptMessages = [{ role: 'user' as const, content: fullPrompt }]
-  const { envelope, latency_ms, token_usage } = await callOpenAI(
-    agent.system_prompt,
-    promptMessages,
-    model,
-    temperature
-  )
+  // Parse structured JSON from agent response
+  let envelope: any = {}
+  try {
+    const raw = agentMsg?.content || '{}'
+    // Strip code fences if the model wrapped it
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
+    envelope = JSON.parse(cleaned)
+  } catch {
+    console.error('Case analysis: failed to parse agent JSON response')
+    envelope = {
+      reported_issue: ticket.description || '',
+      true_problem: 'Analysis parse failure — see raw agent message',
+      diagnostic_steps: [],
+      solution_steps: [],
+      final_solution: '',
+      confidence_score: 0.1,
+      kb_candidate: false,
+      suggested_tags: [],
+      analysis_summary: 'Structured analysis unavailable — agent response was not valid JSON.'
+    }
+  }
 
-  // Process suggested tags
-  const suggestedTags = envelope.suggested_tags || []
-  const createdTagIds: string[] = []
-  
-  for (const tagData of suggestedTags) {
+  // Upsert tags
+  const tagIds: string[] = []
+  for (const tagData of envelope.suggested_tags || []) {
     try {
-      const tagId = await getOrCreateTag(tagData, account_id)
-      createdTagIds.push(tagId)
+      const tagId = await upsertTag(tagData, account_id, tagTypeId)
+      if (tagId) tagIds.push(tagId)
     } catch (err) {
-      console.error(`Failed to create tag ${tagData.slug}:`, err)
+      console.error('Tag upsert failed:', tagData.slug, err)
     }
   }
 
-  // Create case analysis record
-  const caseAnalysisId = await createCaseAnalysis(
-    ticket_id,
-    envelope,
-    envelope.confidence_score || 0.5,
-    agent.id,
-    account_id
-  )
+  // Create case_analysis item
+  const { data: caseAnalysis } = await adminDb
+    .from('items')
+    .insert({
+      type_id: caseAnalysisTypeId,
+      account_id,
+      title: `Analysis: ${ticket.title}`,
+      status: 'completed',
+      data: {
+        ticket_id,
+        analysis_data: envelope,
+        confidence_score: envelope.confidence_score || 0.5,
+        analysis_timestamp: new Date().toISOString(),
+        ai_agent_id: analysisAgentId,
+        analysis_thread_id: analysisThread.id,
+      }
+    })
+    .select('id')
+    .single()
 
-  // Update ticket with analysis data
-  await updateTicketWithAnalysis(ticket_id, envelope, createdTagIds)
-  
-  // Create entity links for tags
-  if (createdTagIds.length > 0) {
-    await createTagLinks(ticket_id, createdTagIds, account_id)
+  // Link case_analysis → ticket
+  if (caseAnalysis?.id) {
+    const analyzedByLinkTypeId = await resolveLinkTypeId('analyzed_by').catch(() => null)
+    if (analyzedByLinkTypeId) {
+      const linkTypeItemId = await resolveTypeId('item', 'link').catch(() => null)
+      if (linkTypeItemId) {
+        await adminDb.from('links').upsert({
+          type_id: linkTypeItemId,
+          link_type_id: analyzedByLinkTypeId,
+          account_id,
+          source_type: 'items',
+          source_id: caseAnalysis.id,
+          target_type: 'items',
+          target_id: ticket_id,
+          link_type: 'analyzed_by',
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        }, { onConflict: 'source_id,target_id,link_type_id' })
+      }
+    }
   }
 
+  // Update ticket with ca_ fields
+  const { data: currentTicket } = await adminDb.from('items').select('data').eq('id', ticket_id).single()
+  await adminDb.from('items').update({
+    data: {
+      ...(currentTicket?.data || {}),
+      ca_reported_issue: envelope.reported_issue,
+      ca_true_problem: envelope.true_problem,
+      ca_final_solution: envelope.final_solution,
+      ca_diagnostic_steps: envelope.diagnostic_steps,
+      ca_solution_steps: envelope.solution_steps,
+      ca_analysis_tags: tagIds,
+      ca_time_to_resolution: envelope.time_to_resolution,
+      ca_back_and_forth_count: envelope.back_and_forth_count,
+      ca_escalation_required: envelope.escalation_required,
+      ca_automation_potential: envelope.automation_potential,
+      ca_customer_temperature: envelope.customer_temperature,
+      ca_kb_candidate: envelope.kb_candidate,
+      ca_sentiment_progression: envelope.sentiment_progression,
+      analysis_timestamp: new Date().toISOString(),
+    },
+    updated_at: new Date().toISOString(),
+  }).eq('id', ticket_id)
+
+  // Embed the resolved case for future triage RAG (best-effort, non-blocking)
+  embedResolvedCase(ticket_id, account_id).catch(err =>
+    console.error('embedResolvedCase failed (non-fatal):', err)
+  )
+
   return {
     ticketId: ticket_id,
-    caseAnalysisId,
-    analysisData: envelope,
-    createdTags: createdTagIds,
-    confidence: envelope.confidence_score || 0.5
+    caseAnalysisId: caseAnalysis?.id,
+    analysisThreadId: analysisThread.id,
+    confidence: envelope.confidence_score || 0.5,
+    kbCandidate: envelope.kb_candidate,
+    createdTags: tagIds.length,
   }
 }
 
 // ─── HANDLER ──────────────────────────────────────────────────────────────────
 
 export const handler = createHandler(async (ctx, body) => {
-  const action = ctx.query?.action
-
+  const action = (ctx as any).query?.action
   switch (action) {
-    case 'analyze_ticket':
-      return await handleAnalyzeTicket(ctx, body)
-    default:
-      throw new Error(`Unknown action: ${action}. Use 'analyze_ticket'.`)
+    case 'analyze_ticket': return handleAnalyzeTicket(ctx, body as AnalysisRequest)
+    default: throw new Error(`Unknown action: ${action}. Use 'analyze_ticket'.`)
   }
 })