spine-framework-portal 0.2.19 → 0.2.21

package/functions/custom_portal-community-escalation.ts

@@ -165,7 +165,7 @@ export const checkUnanswered = createHandler(async (ctx, _body) => {
   // Resolve type IDs dynamically
   const [supportTicketTypeId, threadTypeId] = await Promise.all([
     resolveTypeId('item', 'support_ticket'),
-    resolveTypeId('thread', 'thread')
+    resolveTypeId('thread', 'support_thread')
   ])
 
   try {

package/functions/custom_support-triage.ts

@@ -1,489 +1,137 @@
 import { createHandler, CoreContext } from './_shared/middleware'
 import { adminDb } from './_shared/db'
 import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
 import { create, update } from './admin-data'
 
 /**
- * Custom Support Triage Handler
+ * @module custom_support-triage
+ * @layer custom/portal
+ * @stability custom
  *
- * Two actions:
- *   POST ?action=new_ticket  — first message: creates ticket + thread + messages, runs AI
- *   POST ?action=reply       — follow-up message on existing ticket: posts message, runs AI
+ * Support ticket entry point. Two actions:
+ *   POST ?action=new_ticket  — creates ticket + external thread, calls runAgent()
+ *   POST ?action=reply       — posts the human message, calls runAgent() on the existing thread
  *
- * All runtime record creation goes through admin-data.create so design_schema,
- * validation_schema, scope, audit fields, and triggers are handled consistently.
+ * All AI inference (RAG, tool calls, confidence scoring, escalation pipeline) is
+ * delegated to core's runAgent() — agent behaviour is controlled entirely via
+ * ai_agents + prompt_configs records (no AI logic in this file).
  *
- * AI response schema (enforced via response_format: json_object):
- * {
- *   public_response: string,
- *   confidence: number (0-1),
- *   confidence_reasoning: string,
- *   escalate: boolean,
- *   escalation_reason: 'low_confidence' | 'none',
- *   sources_used: Array<{ type, id, title, relevance }>,
- *   suggested_title: string   (turn 1 only)
- * }
+ * Response shape:
+ *   { ticketId, threadId, agentMessageId, content, confidence, escalated }
+ *
+ * Escalation is handled inside agent-runner.ts via the escalation_pipeline
+ * configured in the prompt_config row — no escalation code here.
  */
 
-// ─── CONSTANTS ────────────────────────────────────────────────────────────────
-
-const CONFIDENCE_THRESHOLD = 0.75
+// ─── HELPERS ──────────────────────────────────────────────────────────────────
 
-// Helper: call admin-data.update as a nested import (entity+id go in ctx.query)
 function adminDataUpdate(ctx: CoreContext, entity: string, id: string, fields: Record<string, any>) {
   return update({ ...ctx, query: { ...((ctx as any).query || {}), entity, id } } as any, fields)
 }
 
-// ─── TYPES ────────────────────────────────────────────────────────────────────
-
-interface TriageEnvelope {
-  public_response: string
-  confidence: number
-  confidence_reasoning: string
-  escalate: boolean
-  escalation_reason: 'low_confidence' | 'none'
-  sources_used: Array<{ type: string; id: string; title: string; relevance: number }>
-  suggested_title?: string
-}
-
-interface TriageResult {
-  ticketId: string
-  threadId: string
-  publicMessageId: string
-  internalMessageId: string
-  public_response: string
-  confidence: number
-  escalated: boolean
-  escalation_reason: string
-  suggested_title?: string
-}
-
-interface TypeIds {
-  supportTicket: string
-  thread: string
-  message: string
-  triageAgentId: string
-  promptConfigId: string
-}
-
-// ─── HELPERS ──────────────────────────────────────────────────────────────────
-
-async function getConversationHistory(threadId: string): Promise<any[]> {
-  const { data: msgs, error } = await adminDb
-    .from('messages')
-    .select('content, direction, data, created_at')
-    .eq('thread_id', threadId)
-    .eq('visibility', 'public')
-    .order('created_at', { ascending: true })
-    .limit(20)
-  if (error) return []
-  return msgs || []
-}
-
-async function getPriorTickets(accountId: string, personId: string, supportTicketTypeId: string): Promise<any[]> {
-  const { data: tickets, error } = await adminDb
-    .from('items')
-    .select('id, title, description, created_at')
-    .eq('type_id', supportTicketTypeId)
-    .eq('account_id', accountId)
-    .eq('created_by', personId)
-    .order('created_at', { ascending: false })
-    .limit(5)
-  if (error) return []
-  return tickets || []
-}
-
-const KB_PLATFORM_ACCOUNT_ID = '12acec9b-8451-40e7-80d5-e80c4e2fc0de' // spine-system
-
-async function searchKB(query: string, accountId: string): Promise<any[]> {
-  const accountIds = [accountId]
-  if (accountId !== KB_PLATFORM_ACCOUNT_ID) accountIds.push(KB_PLATFORM_ACCOUNT_ID)
-
-  const { data: results, error } = await adminDb
-    .from('embeddings')
-    .select('document_id, content, metadata, account_id')
-    .in('account_id', accountIds)
-    .eq('metadata->>item_type', 'kb_article')
-    .eq('metadata->>vector_type', 'semantic')
-    .textSearch('content', query, { type: 'websearch', config: 'english' })
-    .limit(8)
-
-  if (error) return []
-
-  return (results || [])
-    .filter((r: any) => r.account_id === accountId || r.metadata?.security_level !== 'restricted')
-    .slice(0, 5)
-}
-
-async function callOpenAI(
-  systemPrompt: string,
-  messages: Array<{ role: 'user' | 'assistant' | 'system'; content: string }>,
-  model: string,
-  temperature: number
-): Promise<{ envelope: TriageEnvelope; 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) {
-    return {
-      envelope: {
-        public_response: '[Mock] No OPENAI_API_KEY set. This is a mock AI response for local development.',
-        confidence: 0.85,
-        confidence_reasoning: 'Mock response — no API key configured.',
-        escalate: false,
-        escalation_reason: 'none',
-        sources_used: [],
-        suggested_title: 'Mock Support Ticket'
-      },
-      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: TriageEnvelope
-
-  try {
-    envelope = JSON.parse(raw)
-    if (typeof envelope.public_response !== 'string') throw new Error('missing public_response')
-    if (typeof envelope.confidence !== 'number') throw new Error('missing confidence')
-  } catch (parseErr: any) {
-    envelope = {
-      public_response: "We're looking into this and will have a human response shortly.",
-      confidence: 0,
-      confidence_reasoning: `Parse failure: ${parseErr.message}. Raw: ${raw.slice(0, 200)}`,
-      escalate: true,
-      escalation_reason: 'low_confidence',
-      sources_used: []
-    }
-  }
-
-  return { envelope, latency_ms: Date.now() - startTime, token_usage: result.usage || {} }
-}
-
-function buildSystemPrompt(
-  agentSystemPrompt: string,
-  contextTemplate: string,
-  kbSources: any[],
-  priorTickets: any[],
-  history: any[]
-): string {
-  let prompt = agentSystemPrompt + '\n\n'
-  prompt += contextTemplate + '\n\n'
-
-  if (kbSources.length > 0) {
-    prompt += '## Knowledge Base Articles\n'
-    kbSources.forEach((doc, i) => { prompt += `[KB${i + 1}] ${doc.content?.slice(0, 500)}\n` })
-    prompt += '\n'
-  }
-
-  if (priorTickets.length > 0) {
-    prompt += "## Customer's Prior Tickets\n"
-    priorTickets.forEach((t) => { prompt += `- ${t.title}: ${t.description?.slice(0, 200) || 'No description'}\n` })
-    prompt += '\n'
-  }
-
-  if (history.length > 0) {
-    prompt += '## Conversation So Far\n'
-    history.forEach((m) => {
-      prompt += `${m.direction === 'inbound' ? 'Customer' : 'Assistant'}: ${m.content}\n`
-    })
-    prompt += '\n'
-  }
-
-  prompt += `\nYou MUST respond with a single valid JSON object matching EXACTLY this schema. No markdown, no code fences, no extra text:\n`
-  prompt += `{
-  "public_response": "<your response to the customer>",
-  "confidence": <0.0-1.0>,
-  "confidence_reasoning": "<one sentence explaining your confidence score>",
-  "escalate": <true|false>,
-  "escalation_reason": "<low_confidence|none>",
-  "sources_used": [{"type": "kb_article|prior_ticket", "id": "<id>", "title": "<title>", "relevance": <0.0-1.0>}],
-  "suggested_title": "<3-8 word case title — ONLY include on the first turn>"
-}`
-
-  return prompt
-}
-
 // ─── ACTION: NEW TICKET ───────────────────────────────────────────────────────
 
-async function handleNewTicket(ctx: any, body: any, typeIds: TypeIds): Promise<TriageResult> {
+async function handleNewTicket(
+  ctx: any,
+  body: any,
+  ids: { supportTicket: string; thread: string; triageAgentId: string; promptConfigId: string }
+) {
   const { message } = body
   const account_id = ctx.accountId as string
   const person_id = ctx.principal?.id as string
   if (!message) throw new Error('message is required')
   if (!account_id || !person_id) throw new Error('User context (account + person) required')
 
-  const { triageAgentId, promptConfigId } = typeIds
-
-  // Load agent + prompt config (config tables — direct reads are fine)
-  const [{ data: agent }, { data: promptConfig }] = await Promise.all([
-    adminDb.from('ai_agents').select('*').eq('id', triageAgentId).single(),
-    adminDb.from('prompt_configs').select('*').eq('id', promptConfigId).single()
-  ])
-  if (!agent || !promptConfig) throw new Error('Triage agent configuration not found')
-
-  const model = agent.model_config?.model || process.env.LLM_DEFAULT_MODEL || 'gpt-4o'
-  const temperature = agent.model_config?.temperature ?? 0.7
-
-  // Run AI before ticket exists (no history yet)
-  const [kbSources, priorTickets] = await Promise.all([
-    searchKB(message, account_id),
-    getPriorTickets(account_id, person_id, typeIds.supportTicket)
-  ])
-  const systemPrompt = buildSystemPrompt(
-    agent.system_prompt,
-    promptConfig.context_template.replace('{{user_message}}', message),
-    kbSources,
-    priorTickets,
-    []
-  )
-  const { envelope, latency_ms, token_usage } = await callOpenAI(
-    systemPrompt,
-    [{ role: 'user', content: message }],
-    model,
-    temperature
-  )
+  const { supportTicket, thread, triageAgentId, promptConfigId } = ids
 
-  const escalate = envelope.escalate || envelope.confidence < (promptConfig.confidence_threshold || CONFIDENCE_THRESHOLD)
-  const suggestedTitle = envelope.suggested_title || message.slice(0, 80)
-
-  // Create ticket via admin-data (stamps schema, fires triggers)
+  // 1. Create a placeholder ticket — title will be updated after agent responds
   const ticket = await create(ctx, {
     entity: 'items',
-    type_id: typeIds.supportTicket,
-    title: suggestedTitle,
+    type_id: supportTicket,
+    title: message.slice(0, 100),
     description: message,
-    status: escalate ? 'human_assigned' : 'ai_responding',
+    status: 'ai_responding',
     data: {
-      status: escalate ? 'human_assigned' : 'ai_responding',
       aim_triage_agent_id: triageAgentId,
-      aim_confidence_threshold: promptConfig.confidence_threshold || CONFIDENCE_THRESHOLD,
-      aim_confidence_at_response: envelope.confidence,
-      aim_escalation_reason: escalate ? envelope.escalation_reason : 'none'
     }
   })
   if (!ticket?.id) throw new Error('Failed to create ticket')
-  const ticketId = ticket.id
 
-  // Create thread via admin-data
-  const thread = await create(ctx, {
+  // 2. Create the external thread wired to the triage agent + prompt config.
+  //    agent-runner resolves agent & config from thread.data.agent_id / prompt_config_id.
+  const threadRecord = await create(ctx, {
     entity: 'threads',
-    type_id: typeIds.thread,
+    type_id: thread,
     target_type: 'items',
-    target_id: ticketId,
+    target_id: ticket.id,
     visibility: 'external',
     status: 'active',
-    data: { agent_id: triageAgentId, prompt_config_id: promptConfigId }
+    data: {
+      agent_id: triageAgentId,
+      prompt_config_id: promptConfigId,
+    }
   })
-  if (!thread?.id) throw new Error('Failed to create thread')
-  const threadId = thread.id
-
-  const publicContent = escalate
-    ? "We're looking into this and will have a human response shortly."
-    : envelope.public_response
+  if (!threadRecord?.id) throw new Error('Failed to create thread')
 
-  // Post all three messages via admin-data
-  const customerMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id: threadId,
-    person_id,
-    content: message,
-    direction: 'inbound',
-    visibility: 'public',
-    sequence: 1,
-    data: { message_type: 'human' }
-  })
-  if (!customerMsg?.id) throw new Error('Failed to save customer message')
+  // 3. Run the agent — saves user message, runs RAG+inference, handles escalation,
+  //    saves agent message, emits audit. Returns the persisted agent message row.
+  const agentMsg = await runAgent(threadRecord.id, message, ctx)
 
-  const publicMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id: threadId,
-    content: publicContent,
-    direction: 'outbound',
-    visibility: 'public',
-    sequence: 2,
-    data: { message_type: 'agent', agent_id: triageAgentId, confidence: envelope.confidence, escalated: escalate }
-  })
-  if (!publicMsg?.id) throw new Error('Failed to save public AI message')
+  const confidence = agentMsg?.data?.confidence ?? 0
+  const escalated = agentMsg?.data?.escalated ?? false
 
-  const internalMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id: threadId,
-    content: `[AI Internal] Turn 1 — Confidence: ${envelope.confidence.toFixed(2)} — ${envelope.confidence_reasoning}`,
-    direction: 'outbound',
-    visibility: 'internal',
-    sequence: 3,
+  // 4. Backfill suggested title if agent produced one, and stamp confidence/status
+  const suggestedTitle = agentMsg?.data?.suggested_title || message.slice(0, 80)
+  await adminDataUpdate(ctx, 'items', ticket.id, {
+    title: suggestedTitle,
+    status: escalated ? 'human_assigned' : 'ai_responding',
     data: {
-      message_type: 'agent_internal',
-      ai_internal: {
-        turn: 1,
-        prompt_sent: [{ role: 'system', content: systemPrompt }, { role: 'user', content: message }],
-        kb_sources_retrieved: kbSources.map((s) => ({ id: s.document_id, content: s.content?.slice(0, 100), relevance: null })),
-        prior_tickets_retrieved: priorTickets.map((t) => ({ id: t.id, title: t.title })),
-        ai_raw_response: envelope,
-        confidence: envelope.confidence,
-        confidence_reasoning: envelope.confidence_reasoning,
-        escalation_decision: escalate ? envelope.escalation_reason : 'none',
-        model, temperature, latency_ms, token_usage, suggested_title: suggestedTitle
-      }
+      aim_triage_agent_id: triageAgentId,
+      aim_confidence_at_response: confidence,
+      aim_escalation_reason: escalated ? 'low_confidence' : 'none',
     }
   })
-  if (!internalMsg?.id) throw new Error('Failed to save internal AI message')
 
   return {
-    ticketId,
-    threadId,
-    publicMessageId: publicMsg.id,
-    internalMessageId: internalMsg.id,
-    public_response: publicContent,
-    confidence: envelope.confidence,
-    escalated: escalate,
-    escalation_reason: escalate ? envelope.escalation_reason : 'none',
-    suggested_title: suggestedTitle
+    ticketId: ticket.id,
+    threadId: threadRecord.id,
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+    confidence,
+    escalated,
   }
 }
 
-// ─── ACTION: REPLY (multi-turn) ───────────────────────────────────────────────
+// ─── ACTION: REPLY ────────────────────────────────────────────────────────────
 
-async function handleReply(ctx: any, body: any, typeIds: TypeIds): Promise<TriageResult> {
-  const { message, thread_id, ticket_id } = body
-  const account_id = ctx.accountId as string
+async function handleReply(
+  ctx: any,
+  body: any,
+  _ids: { supportTicket: string; thread: string; triageAgentId: string; promptConfigId: string }
+) {
+  const { message, ticket_id, thread_id } = body
   const person_id = ctx.principal?.id as string
-  if (!message || !thread_id || !ticket_id) throw new Error('message, thread_id, and ticket_id are required')
-  if (!account_id || !person_id) throw new Error('User context (account + person) required')
-
-  const { triageAgentId, promptConfigId } = typeIds
-
-  // Load agent + prompt config (config tables — direct reads are fine)
-  const [{ data: agent }, { data: promptConfig }] = await Promise.all([
-    adminDb.from('ai_agents').select('*').eq('id', triageAgentId).single(),
-    adminDb.from('prompt_configs').select('*').eq('id', promptConfigId).single()
-  ])
-  if (!agent || !promptConfig) throw new Error('Triage agent configuration not found')
-
-  const model = agent.model_config?.model || process.env.LLM_DEFAULT_MODEL || 'gpt-4o'
-  const temperature = agent.model_config?.temperature ?? 0.7
-
-  const history = await getConversationHistory(thread_id)
-  const turnNumber = history.filter((m) => m.direction === 'inbound').length + 1
-
-  const { count: msgCount } = await adminDb
-    .from('messages')
-    .select('id', { count: 'exact', head: true })
-    .eq('thread_id', thread_id)
-  const nextSeq = (msgCount || 0) + 1
-
-  // Post customer message first (shows immediately)
-  const customerMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id,
-    person_id,
-    content: message,
-    direction: 'inbound',
-    visibility: 'public',
-    sequence: nextSeq,
-    data: { message_type: 'human' }
-  })
-  if (!customerMsg?.id) throw new Error('Failed to save customer message')
-
-  // Run AI with full history
-  const [kbSources, priorTickets] = await Promise.all([
-    searchKB(message, account_id),
-    getPriorTickets(account_id, person_id, typeIds.supportTicket)
-  ])
-  const systemPrompt = buildSystemPrompt(
-    agent.system_prompt,
-    promptConfig.context_template.replace('{{user_message}}', message),
-    kbSources,
-    priorTickets,
-    history
-  )
-  const promptMessages: Array<{ role: 'user' | 'assistant'; content: string }> = [
-    ...history.map((m) => ({ role: (m.direction === 'inbound' ? 'user' : 'assistant') as 'user' | 'assistant', content: m.content })),
-    { role: 'user', content: message }
-  ]
-  const { envelope, latency_ms, token_usage } = await callOpenAI(systemPrompt, promptMessages, model, temperature)
-
-  const escalate = envelope.escalate || envelope.confidence < (promptConfig.confidence_threshold || CONFIDENCE_THRESHOLD)
-  const publicContent = escalate
-    ? "We're looking into this and will have a human response shortly."
-    : envelope.public_response
+  if (!message) throw new Error('message is required')
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!thread_id) throw new Error('thread_id is required')
 
-  const publicMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id,
-    content: publicContent,
-    direction: 'outbound',
-    visibility: 'public',
-    sequence: nextSeq + 1,
-    data: { message_type: 'agent', agent_id: triageAgentId, confidence: envelope.confidence, escalated: escalate }
-  })
-  if (!publicMsg?.id) throw new Error('Failed to save public AI message')
+  // agent-runner saves the user message then runs inference on the existing thread.
+  // Thread.data.agent_id / prompt_config_id are already set from ticket creation.
+  const agentMsg = await runAgent(thread_id, message, ctx)
 
-  const internalMsg = await create(ctx, {
-    entity: 'messages',
-    type_id: typeIds.message,
-    thread_id,
-    content: `[AI Internal] Turn ${turnNumber} — Confidence: ${envelope.confidence.toFixed(2)} — ${envelope.confidence_reasoning}`,
-    direction: 'outbound',
-    visibility: 'internal',
-    sequence: nextSeq + 2,
-    data: {
-      message_type: 'agent_internal',
-      ai_internal: {
-        turn: turnNumber,
-        prompt_sent: [{ role: 'system', content: systemPrompt }, ...promptMessages],
-        kb_sources_retrieved: kbSources.map((s) => ({ id: s.document_id, content: s.content?.slice(0, 100), relevance: null })),
-        prior_tickets_retrieved: priorTickets.map((t) => ({ id: t.id, title: t.title })),
-        ai_raw_response: envelope,
-        confidence: envelope.confidence,
-        confidence_reasoning: envelope.confidence_reasoning,
-        escalation_decision: escalate ? envelope.escalation_reason : 'none',
-        model, temperature, latency_ms, token_usage
-      }
-    }
-  })
-  if (!internalMsg?.id) throw new Error('Failed to save internal AI message')
+  const confidence = agentMsg?.data?.confidence ?? 0
+  const escalated = agentMsg?.data?.escalated ?? false
 
-  // Update ticket status if escalated
-  if (escalate) {
+  if (escalated) {
     const { data: currentTicket } = await adminDb
-      .from('items')
-      .select('data')
-      .eq('id', ticket_id)
-      .single()
-
+      .from('items').select('data').eq('id', ticket_id).single()
     await adminDataUpdate(ctx, 'items', ticket_id, {
       status: 'human_assigned',
       data: {
         ...(currentTicket?.data || {}),
-        status: 'human_assigned',
-        aim_confidence_at_response: envelope.confidence,
-        aim_escalation_reason: envelope.escalation_reason
+        aim_confidence_at_response: confidence,
+        aim_escalation_reason: 'low_confidence',
       }
     })
   }
@@ -491,12 +139,10 @@ async function handleReply(ctx: any, body: any, typeIds: TypeIds): Promise<Triag
   return {
     ticketId: ticket_id,
     threadId: thread_id,
-    publicMessageId: publicMsg.id,
-    internalMessageId: internalMsg.id,
-    public_response: publicContent,
-    confidence: envelope.confidence,
-    escalated: escalate,
-    escalation_reason: escalate ? envelope.escalation_reason : 'none'
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+    confidence,
+    escalated,
   }
 }
 
@@ -505,19 +151,17 @@ async function handleReply(ctx: any, body: any, typeIds: TypeIds): Promise<Triag
 export const handler = createHandler(async (ctx, body) => {
   const action = (ctx as any).query?.action
 
-  // Resolve all IDs once, shared across both actions
-  const [supportTicket, thread, message, triageAgentId, promptConfigId] = await Promise.all([
+  const [supportTicket, thread, triageAgentId, promptConfigId] = await Promise.all([
     resolveTypeId('item', 'support_ticket'),
-    resolveTypeId('thread', 'thread'),
-    resolveTypeId('message', 'message'),
+    resolveTypeId('thread', 'support_thread'),
     resolveAgentId('Support Triage Agent'),
     resolvePromptConfigId('support_triage'),
   ])
-  const typeIds: TypeIds = { supportTicket, thread, message, triageAgentId, promptConfigId }
+  const ids = { supportTicket, thread, triageAgentId, promptConfigId }
 
   switch (action) {
-    case 'new_ticket': return handleNewTicket(ctx, body, typeIds)
-    case 'reply':      return handleReply(ctx, body, typeIds)
+    case 'new_ticket': return handleNewTicket(ctx, body, ids)
+    case 'reply':      return handleReply(ctx, body, ids)
     default: throw new Error(`Unknown action: ${action}. Use 'new_ticket' or 'reply'.`)
   }
 })

package/hooks/usePortalThreads.ts

@@ -35,19 +35,39 @@ async function fetchJSON(path: string, options?: RequestInit) {
   return json.data
 }
 
-export function usePortalThread(targetType: string, targetId: string | null) {
+type ThreadDomain = 'support' | 'community' | 'generic'
+
+function getThreadTypeSlug(domain: ThreadDomain) {
+  if (domain === 'support') return 'support_thread'
+  if (domain === 'community') return 'community_thread'
+  return 'thread'
+}
+
+function getMessageTypeSlug(domain: ThreadDomain) {
+  if (domain === 'support') return 'support_reply'
+  if (domain === 'community') return 'community_reply'
+  return 'message'
+}
+
+export function usePortalThread(targetType: string, targetId: string | null, domain: ThreadDomain = 'generic') {
   const [thread, setThread] = useState<PortalThread | null>(null)
   const [messages, setMessages] = useState<PortalMessage[]>([])
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | null>(null)
 
+  const threadTypeSlug = getThreadTypeSlug(domain)
+  const messageTypeSlug = getMessageTypeSlug(domain)
+
   const load = useCallback(async () => {
     if (!targetId) return
     setLoading(true)
     setError(null)
     try {
+      const threadTypeId = await getTypeIdAsync(threadTypeSlug)
+      if (!threadTypeId) throw new Error(`${threadTypeSlug} type not found`)
+
       const threads = await fetchJSON(
-        `/.netlify/functions/admin-data?entity=threads&target_type=${targetType}&target_id=${targetId}`
+        `/.netlify/functions/admin-data?entity=threads&target_type=${targetType}&target_id=${targetId}&type_id=${threadTypeId}`
       )
       const found: PortalThread | null = Array.isArray(threads) ? (threads[0] ?? null) : null
       setThread(found)
@@ -64,7 +84,7 @@ export function usePortalThread(targetType: string, targetId: string | null) {
     } finally {
       setLoading(false)
     }
-  }, [targetType, targetId])
+  }, [targetType, targetId, threadTypeSlug])
 
   useEffect(() => { load() }, [load])
 
@@ -72,8 +92,8 @@ export function usePortalThread(targetType: string, targetId: string | null) {
     let activeThread = thread
     
     if (!activeThread?.id) {
-      const threadTypeId = await getTypeIdAsync('thread')
-      if (!threadTypeId) throw new Error('thread type not found')
+      const threadTypeId = await getTypeIdAsync(threadTypeSlug)
+      if (!threadTypeId) throw new Error(`${threadTypeSlug} type not found`)
       
       activeThread = await fetchJSON('/.netlify/functions/admin-data', {
         method: 'POST',
@@ -88,8 +108,8 @@ export function usePortalThread(targetType: string, targetId: string | null) {
       setThread(activeThread)
     }
     
-    const messageTypeId = await getTypeIdAsync('message')
-    if (!messageTypeId) throw new Error('message type not found')
+    const messageTypeId = await getTypeIdAsync(messageTypeSlug)
+    if (!messageTypeId) throw new Error(`${messageTypeSlug} type not found`)
     
     // Calculate next sequence based on current messages to avoid stale state
     const nextSequence = messages.reduce((max, m) => Math.max(max, m.sequence || 0), 0) + 1
@@ -107,7 +127,7 @@ export function usePortalThread(targetType: string, targetId: string | null) {
     })
     setMessages((prev) => [...prev, msg])
     return msg
-  }, [thread, targetType, targetId, messages])
+  }, [thread, targetType, targetId, messages, threadTypeSlug, messageTypeSlug])
 
   return { thread, messages, loading, error, reply, refetch: load }
 }

package/manifest.json

@@ -2,7 +2,7 @@
   "name": "Portal",
   "slug": "portal",
   "description": "Self-service portal for customers to access tickets, knowledge base, courses, and community",
-  "version": "0.2.10",
+  "version": "0.2.21",
   "app_type": "full",
   "route_prefix": "/portal",
   "required_roles": ["member", "member_admin"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-portal",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "private": false,
   "description": "Customer Portal — self-service portal app for Spine Framework",
   "type": "module",

package/pages/CommunityPage.tsx

@@ -22,7 +22,7 @@ const CHANNEL_LABELS: Record<string, string> = {
 }
 
 function ThreadPane({ post }: { post: CommunityPost }) {
-  const { messages, loading, reply } = usePortalThread('items', post.id)
+  const { messages, loading, reply } = usePortalThread('items', post.id, 'community')
   const [replyText, setReplyText] = useState('')
   const [sending, setSending] = useState(false)
   const { sendSignal } = usePortalSignal()

package/pages/TicketsPage.tsx

@@ -85,7 +85,7 @@ function AIResponseCard({ message, ticketId, messageId, onFeedback }: {
 }
 
 function TicketThread({ ticketId, ticketStatus, onStatusChange }: TicketThreadProps) {
-  const { messages, loading, thread, refetch } = usePortalThread('items', ticketId)
+  const { messages, loading, thread, refetch } = usePortalThread('items', ticketId, 'support')
   const [replyText, setReplyText] = useState('')
   const [aiState, setAiState] = useState<'idle' | 'analyzing' | 'responded' | 'escalated'>('idle')
   const { sendReply, loading: replying } = useTriageReply()

package/seed/types.json

@@ -1300,10 +1300,162 @@
     }
   },
   {
-    "kind": "item",
+    "kind": "thread",
+    "slug": "support_thread",
+    "name": "Support Thread",
+    "description": "Customer-visible conversation thread attached to a support ticket",
+    "icon": "message-square",
+    "color": "#EF4444",
+    "ownership": "tenant",
+    "is_active": true,
+    "validation_schema": {},
+    "design_schema": {
+      "scope": "account",
+      "views": {
+        "default_list": {
+          "type": "list",
+          "label": "Support Threads",
+          "fields": {
+            "title": { "sortable": true, "display_type": "text" },
+            "target_type": { "sortable": true, "display_type": "text" },
+            "visibility": { "sortable": true, "display_type": "badge" },
+            "status": { "sortable": true, "display_type": "badge" }
+          },
+          "display": "table"
+        },
+        "default_detail": {
+          "type": "detail",
+          "label": "Support Thread",
+          "sections": [
+            { "title": "Overview", "fields": ["title", "target_type", "target_id", "visibility", "status"] }
+          ]
+        }
+      },
+      "fields": {
+        "title": { "data_type": "text", "label": "Title", "required": false, "system": true },
+        "target_type": { "data_type": "text", "label": "Target Type", "required": true, "system": true },
+        "target_id": { "data_type": "uuid", "label": "Target ID", "required": true, "system": true },
+        "visibility": { "data_type": "text", "label": "Visibility", "required": true, "system": true },
+        "status": { "data_type": "text", "label": "Status", "required": true, "system": true },
+        "is_active": { "data_type": "boolean", "label": "Active", "required": true, "system": true },
+        "created_at": { "data_type": "datetime", "label": "Created", "required": false, "system": true, "readonly": true },
+        "updated_at": { "data_type": "datetime", "label": "Updated", "required": false, "system": true, "readonly": true }
+      },
+      "record_permissions": {
+        "system_admin": ["create", "read", "update", "delete"],
+        "support_admin": ["create", "read", "update"],
+        "support": ["create", "read", "update"],
+        "member_admin": ["create", "read", "update"],
+        "member": ["create", "read", "update"]
+      }
+    }
+  },
+  {
+    "kind": "message",
+    "slug": "support_reply",
+    "name": "Support Reply",
+    "description": "Customer or agent message within a support thread",
+    "icon": "message-circle",
+    "color": "#EF4444",
+    "ownership": "tenant",
+    "is_active": true,
+    "validation_schema": {},
+    "design_schema": {
+      "scope": "account",
+      "views": {
+        "default_list": {
+          "type": "list",
+          "label": "Support Replies",
+          "fields": {
+            "content": { "sortable": false, "display_type": "text" },
+            "direction": { "sortable": true, "display_type": "badge" },
+            "visibility": { "sortable": true, "display_type": "badge" },
+            "created_at": { "sortable": true, "display_type": "datetime" }
+          },
+          "display": "table"
+        },
+        "default_detail": {
+          "type": "detail",
+          "label": "Support Reply",
+          "sections": [
+            { "title": "Content", "fields": ["content", "direction", "visibility"] }
+          ]
+        }
+      },
+      "fields": {
+        "content": { "data_type": "textarea", "label": "Content", "required": true, "system": true },
+        "direction": { "data_type": "text", "label": "Direction", "required": true, "system": true },
+        "sequence": { "data_type": "number", "label": "Sequence", "required": true, "system": true },
+        "visibility": { "data_type": "text", "label": "Visibility", "required": true, "system": true },
+        "is_active": { "data_type": "boolean", "label": "Active", "required": true, "system": true },
+        "created_at": { "data_type": "datetime", "label": "Created", "required": false, "system": true, "readonly": true },
+        "updated_at": { "data_type": "datetime", "label": "Updated", "required": false, "system": true, "readonly": true }
+      },
+      "record_permissions": {
+        "system_admin": ["create", "read", "update", "delete"],
+        "support_admin": ["create", "read", "update"],
+        "support": ["create", "read", "update"],
+        "member_admin": ["create", "read", "update"],
+        "member": ["create", "read", "update"]
+      }
+    }
+  },
+  {
+    "kind": "thread",
+    "slug": "community_thread",
+    "name": "Community Thread",
+    "description": "Public discussion thread attached to a community post",
+    "icon": "users",
+    "color": "#6366F1",
+    "ownership": "tenant",
+    "is_active": true,
+    "validation_schema": {},
+    "design_schema": {
+      "scope": "platform",
+      "views": {
+        "default_list": {
+          "type": "list",
+          "label": "Community Threads",
+          "fields": {
+            "title": { "sortable": true, "display_type": "text" },
+            "target_type": { "sortable": true, "display_type": "text" },
+            "visibility": { "sortable": true, "display_type": "badge" },
+            "status": { "sortable": true, "display_type": "badge" }
+          },
+          "display": "table"
+        },
+        "default_detail": {
+          "type": "detail",
+          "label": "Community Thread",
+          "sections": [
+            { "title": "Overview", "fields": ["title", "target_type", "target_id", "visibility", "status"] }
+          ]
+        }
+      },
+      "fields": {
+        "title": { "data_type": "text", "label": "Title", "required": false, "system": true },
+        "target_type": { "data_type": "text", "label": "Target Type", "required": true, "system": true },
+        "target_id": { "data_type": "uuid", "label": "Target ID", "required": true, "system": true },
+        "visibility": { "data_type": "text", "label": "Visibility", "required": true, "system": true },
+        "status": { "data_type": "text", "label": "Status", "required": true, "system": true },
+        "is_active": { "data_type": "boolean", "label": "Active", "required": true, "system": true },
+        "created_at": { "data_type": "datetime", "label": "Created", "required": false, "system": true, "readonly": true },
+        "updated_at": { "data_type": "datetime", "label": "Updated", "required": false, "system": true, "readonly": true }
+      },
+      "record_permissions": {
+        "system_admin": ["create", "read", "update", "delete"],
+        "support_admin": ["create", "read", "update"],
+        "support": ["create", "read", "update"],
+        "member_admin": ["create", "read", "update"],
+        "member": ["create", "read", "update"]
+      }
+    }
+  },
+  {
+    "kind": "message",
     "slug": "community_reply",
     "name": "Community Reply",
-    "description": "Reply to a community post or discussion",
+    "description": "Public reply within a community thread",
     "icon": "message-circle",
     "color": "#22C55E",
     "ownership": "tenant",
@@ -1316,18 +1468,10 @@
           "type": "list",
           "label": "Community Replies",
           "fields": {
-            "title": {
-              "sortable": true,
-              "display_type": "text"
-            },
-            "parent_post_id": {
-              "sortable": true,
-              "display_type": "text"
-            },
-            "created_at": {
-              "sortable": true,
-              "display_type": "datetime"
-            }
+            "content": { "sortable": false, "display_type": "text" },
+            "direction": { "sortable": true, "display_type": "badge" },
+            "visibility": { "sortable": true, "display_type": "badge" },
+            "created_at": { "sortable": true, "display_type": "datetime" }
           },
           "display": "table"
         },
@@ -1335,73 +1479,26 @@
           "type": "detail",
           "label": "Community Reply",
           "sections": [
-            {
-              "title": "Content",
-              "fields": [
-                "title",
-                "content"
-              ]
-            },
-            {
-              "title": "Context",
-              "fields": [
-                "parent_post_id"
-              ]
-            }
+            { "title": "Content", "fields": ["content", "direction", "visibility"] }
           ]
         }
       },
       "fields": {
-        "title": {
-          "label": "Title",
-          "required": true,
-          "data_type": "text"
-        },
-        "content": {
-          "label": "Content",
-          "required": true,
-          "data_type": "textarea"
-        },
-        "parent_post_id": {
-          "label": "Parent Post ID",
-          "required": true,
-          "data_type": "text"
-        },
-        "is_solution": {
-          "label": "Is Solution",
-          "data_type": "boolean",
-          "default": false
-        }
+        "content": { "data_type": "textarea", "label": "Content", "required": true, "system": true },
+        "direction": { "data_type": "text", "label": "Direction", "required": true, "system": true },
+        "sequence": { "data_type": "number", "label": "Sequence", "required": true, "system": true },
+        "visibility": { "data_type": "text", "label": "Visibility", "required": true, "system": true },
+        "is_active": { "data_type": "boolean", "label": "Active", "required": true, "system": true },
+        "created_at": { "data_type": "datetime", "label": "Created", "required": false, "system": true, "readonly": true },
+        "updated_at": { "data_type": "datetime", "label": "Updated", "required": false, "system": true, "readonly": true }
       },
       "record_permissions": {
-        "system_admin": [
-          "create",
-          "read",
-          "update",
-          "delete"
-        ],
-        "support_admin": [
-          "create",
-          "read",
-          "update"
-        ],
-        "support": [
-          "create",
-          "read",
-          "update"
-        ],
-        "member_admin": [
-          "create",
-          "read",
-          "update"
-        ],
-        "member": [
-          "create",
-          "read",
-          "update"
-        ]
-      },
-      "functionality": null
+        "system_admin": ["create", "read", "update", "delete"],
+        "support_admin": ["create", "read", "update"],
+        "support": ["create", "read", "update"],
+        "member_admin": ["create", "read", "update"],
+        "member": ["create", "read", "update"]
+      }
     }
   }
 ]