spine-framework-cortex 0.2.21 → 0.2.23

package/functions/custom_kb-embeddings.ts

@@ -4,7 +4,7 @@ import { chunkArticle, htmlToPlainText } from './custom_kb-chunker'
 
 interface KBEmbeddingRequest {
   item_id: string
-  vector_types: ('semantic' | 'structure' | 'code')[]
+  vector_types: ('semantic' | 'structure' | 'summary' | 'code')[]
   force_regenerate?: boolean
 }
 
@@ -109,6 +109,15 @@ async function generateEmbeddingBatch(inputs: string[]): Promise<string[]> {
   return sorted.map((d: any) => `[${d.embedding.join(',')}]`)
 }
 
+// Resolve platform account ID at runtime (slug: 'spine-system')
+let _platformAccountId: string | null = null
+async function getPlatformAccountId(): Promise<string | null> {
+  if (_platformAccountId) return _platformAccountId
+  const { data } = await adminDb.from('accounts').select('id').eq('slug', 'spine-system').maybeSingle()
+  _platformAccountId = data?.id ?? null
+  return _platformAccountId
+}
+
 // Insert an embedding record (used during batch writes)
 async function insertEmbedding(
   itemId: string,
@@ -116,12 +125,14 @@ async function insertEmbedding(
   chunkIndex: number,
   content: string,
   embedding: string,
-  metadata: any
+  metadata: any,
+  accountId?: string
 ): Promise<void> {
+  const resolvedAccountId = accountId ?? await getPlatformAccountId()
   await adminDb
     .from('embeddings')
     .insert({
-      account_id: '12acec9b-8451-40e7-80d5-e80c4e2fc0de', // Master account
+      account_id: resolvedAccountId,
       model_id: 'text-embedding-3-small',
       document_id: itemId,
       chunk_index: chunkIndex,
@@ -135,6 +146,33 @@ async function insertEmbedding(
     })
 }
 
+// Generate a one-paragraph AI summary for top-level retrieval matching
+async function generateArticleSummary(item: any): Promise<string> {
+  const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY
+  const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
+  if (!apiKey) return `${item.title || ''}: ${(item.description || '').slice(0, 300)}`
+
+  const plainText = (item.description || '')
+    .replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 3000)
+
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: process.env.LLM_DEFAULT_MODEL || 'gpt-4o-mini',
+      temperature: 0.2,
+      max_tokens: 120,
+      messages: [
+        { role: 'system', content: 'Write a single concise paragraph (max 100 words) summarising this knowledge base article for search indexing. Output only the paragraph.' },
+        { role: 'user', content: `Title: ${item.title}\n\n${plainText}` }
+      ]
+    })
+  })
+  if (!res.ok) return `${item.title}: ${plainText.slice(0, 200)}`
+  const result: any = await res.json()
+  return result.choices?.[0]?.message?.content?.trim() || `${item.title}: ${plainText.slice(0, 200)}`
+}
+
 // Delete all existing embeddings for a document (called before re-embedding)
 async function deleteExistingEmbeddings(itemId: string): Promise<number> {
   const { data } = await adminDb
@@ -169,7 +207,8 @@ function isCodeChunk(item: any): boolean {
 async function handleGenerateEmbeddings(
   itemId: string,
   vectorTypes: string[],
-  forceRegenerate: boolean = false
+  forceRegenerate: boolean = false,
+  overrideAccountId?: string
 ): Promise<KBEmbeddingResponse> {
   const response: KBEmbeddingResponse = {
     success: true,
@@ -179,18 +218,20 @@ async function handleGenerateEmbeddings(
   }
 
   try {
-    // Get the KB item
+    // Get the KB item — allow any type when called from case resolution path
     const { data: item, error: itemError } = await adminDb
       .from('items')
       .select('*')
       .eq('id', itemId)
-      .eq('type_id', 'ce1e50b6-473e-4581-ba0c-e944f47cb240') // kb_article type
       .single()
 
     if (itemError || !item) {
-      throw new Error('KB item not found')
+      throw new Error('Item not found for embedding')
     }
 
+    // Resolve account: caller override > item's own account > platform account
+    const accountId = overrideAccountId || item.account_id || await getPlatformAccountId()
+
     // Check if embeddings already exist
     if (!forceRegenerate) {
       const { data: existing } = await adminDb
@@ -213,7 +254,7 @@ async function handleGenerateEmbeddings(
       response.embeddings_updated = deleted
     }
 
-    // ── Code chunks: legacy path (single semantic + single structure) ──
+    // ── Code chunks: legacy path (semantic + structure) ──
     if (isCodeChunk(item)) {
       const semanticContent = buildSemanticContent(item)
       const structureContent = buildStructureContent(item)
@@ -226,33 +267,32 @@ async function handleGenerateEmbeddings(
           chunk_id: item.data?.code_metadata?.chunk_id,
           chunk_type: item.data?.code_metadata?.chunk_type,
           file_path: item.data?.code_metadata?.file_path,
-        }),
+        }, accountId),
         insertEmbedding(itemId, 'structure', 0, structureContent, vectors[1], {
           kb_type: item.data?.kb_type,
           tags: item.data?.tags,
           file_path: item.data?.code_metadata?.file_path,
           depends_on: item.data?.code_metadata?.depends_on,
-        }),
+        }, accountId),
       ])
 
       response.embeddings_created = 2
       return response
     }
 
-    // ── Article path: chunk → batch embed → parallel write ──
+    // ── Article path: semantic chunks + structure + summary ──
     const articleContent = item.description || ''
-    const chunks = chunkArticle(articleContent, {
-      articleTitle: item.title || 'Untitled',
-    })
+    const chunks = chunkArticle(articleContent, { articleTitle: item.title || 'Untitled' })
 
-    // Build all texts to embed: N semantic chunks + 1 structure
     const structureContent = buildArticleStructureContent(item)
-    const allTexts = [...chunks.map(c => c.content), structureContent]
 
-    // Single batched API call to OpenAI
+    // Generate AI summary for top-level retrieval matching
+    const summaryContent = await generateArticleSummary(item)
+
+    // Single batched embed: N semantic chunks + 1 structure + 1 summary
+    const allTexts = [...chunks.map(c => c.content), structureContent, summaryContent]
     const allVectors = await generateEmbeddingBatch(allTexts)
 
-    // Parallel DB writes
     const writePromises: Promise<void>[] = []
 
     // Semantic embeddings — one per chunk
@@ -263,22 +303,32 @@ async function handleGenerateEmbeddings(
           chunk_index: i,
           chunk_total: chunks.length,
           section_path: chunks[i].sectionPath,
-        })
+          security_level: item.data?.security_level,
+        }, accountId)
       )
     }
 
-    // Structure embedding — article-level, single vector
+    // Structure embedding — facets for filtering
     writePromises.push(
       insertEmbedding(itemId, 'structure', 0, structureContent, allVectors[chunks.length], {
         kb_type: item.data?.kb_type,
         tags: item.data?.tags,
         category: item.data?.category,
         audience: item.data?.audience,
-      })
+        security_level: item.data?.security_level,
+      }, accountId)
+    )
+
+    // Summary embedding — one-paragraph AI summary for top-level matching
+    writePromises.push(
+      insertEmbedding(itemId, 'summary', 0, summaryContent, allVectors[chunks.length + 1], {
+        kb_type: item.data?.kb_type,
+        security_level: item.data?.security_level,
+      }, accountId)
     )
 
     await Promise.all(writePromises)
-    response.embeddings_created = chunks.length + 1
+    response.embeddings_created = chunks.length + 2 // +2 for structure + summary
 
   } catch (error) {
     response.success = false
@@ -288,6 +338,63 @@ async function handleGenerateEmbeddings(
   return response
 }
 
+/**
+ * Embeds a resolved ticket's case data as a knowledge source for future triage RAG.
+ * Called automatically when a ticket is resolved (via case analysis completion).
+ *
+ * Stores two vectors:
+ *   - 'semantic': ca_true_problem + ca_final_solution (the actual answer)
+ *   - 'summary': ca_reported_issue (how the customer described it — improves matching)
+ *
+ * These are stored with item_type: 'resolved_case' so they can be included in
+ * triage agent knowledge_sources without polluting the main KB article pool.
+ */
+export async function embedResolvedCase(ticketId: string, accountId: string): Promise<void> {
+  // Load ticket data fields
+  const { data: ticket } = await adminDb
+    .from('items')
+    .select('id, title, data')
+    .eq('id', ticketId)
+    .single()
+
+  if (!ticket) return
+
+  const trueProb = ticket.data?.ca_true_problem || ''
+  const finalSol = ticket.data?.ca_final_solution || ''
+  const reportedIssue = ticket.data?.ca_reported_issue || ticket.title || ''
+
+  if (!trueProb && !finalSol) return // nothing to embed
+
+  // Delete any pre-existing resolved_case embeddings for this ticket
+  await adminDb
+    .from('embeddings')
+    .delete()
+    .eq('document_id', ticketId)
+    .eq('metadata->>item_type', 'resolved_case')
+
+  const semanticContent = `Problem: ${trueProb}\n\nSolution: ${finalSol}`
+  const summaryContent = `Customer reported: ${reportedIssue}`
+
+  try {
+    const vectors = await generateEmbeddingBatch([semanticContent, summaryContent])
+    await Promise.all([
+      insertEmbedding(ticketId, 'semantic', 0, semanticContent, vectors[0], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+        kb_candidate: ticket.data?.ca_kb_candidate ?? false,
+        automation_potential: ticket.data?.ca_automation_potential ?? 'unknown',
+      }, accountId),
+      insertEmbedding(ticketId, 'summary', 0, summaryContent, vectors[1], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+      }, accountId),
+    ])
+  } catch (err) {
+    // Best-effort: don't fail ticket resolution if embedding fails
+    console.error(`embedResolvedCase failed for ticket ${ticketId}:`, err)
+  }
+}
+
 // Generate embedding vector for a query string via OpenAI
 async function generateQueryEmbedding(text: string): Promise<number[]> {
   const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY

package/functions/custom_support-redaction.ts

@@ -0,0 +1,115 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+
+/**
+ * @module custom_support-redaction
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * KB Redaction Analysis — drives the RedactionReview page.
+ * Runs content through the KB Redaction Agent and returns structured
+ * redaction suggestions + a generalised rewrite ready for human review.
+ *
+ * Action: POST ?action=analyze
+ *   body: { ticket_id: string, content: string }
+ *
+ * Response: { analysis: RedactionAnalysis }
+ *   RedactionAnalysis matches the shape expected by RedactionReview.tsx:
+ *   {
+ *     original_content: string
+ *     redacted_content: string
+ *     suggestions: RedactionSuggestion[]
+ *     confidence_score: number
+ *     processing_metadata: { model_used, temperature, tokens_consumed }
+ *   }
+ *
+ * The agent message is saved in an internal analysis thread on the ticket
+ * (thread_purpose: 'redaction_analysis') as an audit trail.
+ */
+
+async function handleAnalyze(ctx: any, body: any) {
+  const { ticket_id, content } = body
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!content) throw new Error('content is required')
+
+  const [threadTypeId, agentId, promptConfigId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('KB Redaction Agent'),
+    resolvePromptConfigId('kb_generator'),
+  ])
+
+  // Reuse existing redaction thread if one exists (idempotent re-analysis)
+  const { data: existing } = await adminDb
+    .from('threads')
+    .select('id')
+    .eq('target_type', 'items')
+    .eq('target_id', ticket_id)
+    .eq('visibility', 'internal')
+    .eq('data->>thread_purpose', 'redaction_analysis')
+    .maybeSingle()
+
+  let threadId = existing?.id
+
+  if (!threadId) {
+    const thread = await create(ctx, {
+      entity: 'threads',
+      type_id: threadTypeId,
+      target_type: 'items',
+      target_id: ticket_id,
+      visibility: 'internal',
+      status: 'active',
+      data: {
+        thread_purpose: 'redaction_analysis',
+        agent_id: agentId,
+        prompt_config_id: promptConfigId,
+      }
+    })
+    if (!thread?.id) throw new Error('Failed to create redaction thread')
+    threadId = thread.id
+  }
+
+  // Run the KB Redaction Agent — returns structured JSON in message content
+  const agentMsg = await runAgent(threadId, content, ctx)
+
+  // Parse JSON from agent response
+  let analysis: any = null
+  try {
+    const raw = agentMsg?.content || '{}'
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
+    analysis = JSON.parse(cleaned)
+  } catch {
+    // If the agent didn't return valid JSON, return a minimal analysis
+    // so the UI can still proceed with the original content unredacted
+    analysis = {
+      original_content: content,
+      redacted_content: content,
+      suggestions: [],
+      confidence_score: 0.0,
+      processing_metadata: {
+        model_used: 'unknown',
+        temperature: 0.1,
+        tokens_consumed: 0,
+        error: 'Agent response was not valid JSON',
+      }
+    }
+  }
+
+  // Ensure required fields are present for RedactionReview.tsx
+  if (!analysis.original_content) analysis.original_content = content
+  if (!analysis.suggestions) analysis.suggestions = []
+  if (typeof analysis.confidence_score !== 'number') analysis.confidence_score = 0.5
+  if (!analysis.processing_metadata) analysis.processing_metadata = { model_used: 'unknown', temperature: 0.1, tokens_consumed: 0 }
+
+  return { analysis, analysisThreadId: threadId }
+}
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'analyze': return handleAnalyze(ctx, body)
+    default: throw new Error(`Unknown action: ${action}. Use 'analyze'.`)
+  }
+})

package/functions/custom_support-solution.ts

@@ -0,0 +1,104 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+
+/**
+ * @module custom_support-solution
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * Solution AI — internal AI collaborator for support agents working a case.
+ * Powered by core's runAgent() with the 'solution_ai' prompt config.
+ * Never visible to the customer (all messages are visibility='internal').
+ *
+ * Two actions:
+ *   POST ?action=start   — ensures an internal AI thread exists for the ticket,
+ *                          sends the first message, returns thread + agent message.
+ *   POST ?action=message — sends a follow-up message on the existing AI thread.
+ *
+ * Response: { threadId, agentMessageId, content }
+ *
+ * The AI thread is distinct from the regular internal thread: it is tagged with
+ * data.thread_purpose = 'solution_ai' so the UI can find it deterministically.
+ */
+
+// ─── ACTION: START ─────────────────────────────────────────────────────────────
+
+async function handleStart(ctx: any, body: any) {
+  const { ticket_id, message } = body
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!message) throw new Error('message is required')
+
+  const [threadTypeId, solutionAgentId, promptConfigId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('Solution AI Agent'),
+    resolvePromptConfigId('solution_ai'),
+  ])
+
+  // Find existing solution AI thread for this ticket
+  const { data: existing } = await adminDb
+    .from('threads')
+    .select('id')
+    .eq('target_type', 'items')
+    .eq('target_id', ticket_id)
+    .eq('visibility', 'internal')
+    .eq('data->>thread_purpose', 'solution_ai')
+    .maybeSingle()
+
+  let threadId = existing?.id
+
+  if (!threadId) {
+    const thread = await create(ctx, {
+      entity: 'threads',
+      type_id: threadTypeId,
+      target_type: 'items',
+      target_id: ticket_id,
+      visibility: 'internal',
+      status: 'active',
+      data: {
+        thread_purpose: 'solution_ai',
+        agent_id: solutionAgentId,
+        prompt_config_id: promptConfigId,
+      }
+    })
+    if (!thread?.id) throw new Error('Failed to create solution AI thread')
+    threadId = thread.id
+  }
+
+  const agentMsg = await runAgent(threadId, message, ctx)
+
+  return {
+    threadId,
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+  }
+}
+
+// ─── ACTION: MESSAGE ───────────────────────────────────────────────────────────
+
+async function handleMessage(ctx: any, body: any) {
+  const { thread_id, message } = body
+  if (!thread_id) throw new Error('thread_id is required')
+  if (!message) throw new Error('message is required')
+
+  const agentMsg = await runAgent(thread_id, message, ctx)
+
+  return {
+    threadId: thread_id,
+    agentMessageId: agentMsg?.id,
+    content: agentMsg?.content || '',
+  }
+}
+
+// ─── HANDLER ──────────────────────────────────────────────────────────────────
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'start':   return handleStart(ctx, body)
+    case 'message': return handleMessage(ctx, body)
+    default: throw new Error(`Unknown action: ${action}. Use 'start' or 'message'.`)
+  }
+})

package/manifest.json

@@ -2,7 +2,7 @@
   "name": "Cortex",
   "slug": "cortex",
   "description": "Unified workspace for CRM, Support, Community, and Knowledge Base",
-  "version": "0.2.12",
+  "version": "0.2.22",
   "app_type": "full",
   "route_prefix": "/cortex",
   "required_roles": ["support", "support_admin"],
@@ -19,6 +19,7 @@
     "/crm/activity",
     "/support",
     "/support/:id",
+    "/support/:id/kb-review",
     "/community",
     "/kb",
     "/kb/editor",
@@ -90,10 +91,13 @@
   "entry_point": "./index.tsx",
   "sidebar_component": "./components/CortexSidebar.tsx",
   "seed": [
-    { "file": "seed/roles.json",            "table": "roles",      "conflict": "app_id,slug" },
-    { "file": "seed/types.json",            "table": "types",      "conflict": "app_id,kind,slug" },
-    { "file": "seed/link-types.json",       "table": "link_types", "conflict": "app_id,slug" },
-    { "file": "seed/type_permissions.json", "table": "types",      "conflict": "kind,slug", "inject_app_id": false, "permissions_patch": true }
+    { "file": "seed/roles.json",            "table": "roles",         "conflict": "app_id,slug" },
+    { "file": "seed/types.json",            "table": "types",         "conflict": "app_id,kind,slug" },
+    { "file": "seed/link-types.json",       "table": "link_types",    "conflict": "app_id,slug" },
+    { "file": "seed/ai-agents.json",        "table": "ai_agents",     "conflict": "app_id,name",    "inject_app_id": true },
+    { "file": "seed/prompt-configs.json",   "table": "prompt_configs","conflict": "app_id,slug",    "inject_app_id": true },
+    { "file": "seed/pipelines.json",        "table": "pipelines",     "conflict": "app_id,name",    "inject_app_id": true },
+    { "file": "seed/type_permissions.json", "table": "types",         "conflict": "kind,slug",      "inject_app_id": false, "permissions_patch": true }
   ],
   "registration": {
     "enabled": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-cortex",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "private": false,
   "description": "Cortex — AI-powered support, CRM, and knowledge base app for Spine Framework",
   "keywords": [

package/pages/crm/AccountDetailPage.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
+import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@core/components/ui/tabs'
 import { Badge } from '@core/components/ui/badge'
@@ -81,6 +82,7 @@ function PeopleTab({ accountId }: { accountId: string }) {
 
 function ItemsTab({ accountId, typeSlug, emptyText }: { accountId: string; typeSlug: string; emptyText: string }) {
   const navigate = useNavigate()
+  const appPath = useAppPath()
   const [items, setItems] = useState<Item[]>([])
   const [loading, setLoading] = useState(true)
   useEffect(() => {
@@ -94,7 +96,7 @@ function ItemsTab({ accountId, typeSlug, emptyText }: { accountId: string; typeS
       {items.map(item => (
         <div key={item.id}
           className="flex items-center gap-3 px-4 py-3 hover:bg-accent/50 cursor-pointer transition-colors"
-          onClick={() => typeSlug === 'support_ticket' ? navigate(`/cortex/support/${item.id}`) : typeSlug === 'deal' ? navigate(`/cortex/crm/deals/${item.id}`) : undefined}
+          onClick={() => typeSlug === 'support_ticket' ? navigate(appPath(`/support/${item.id}`)) : typeSlug === 'deal' ? navigate(appPath(`/crm/deals/${item.id}`)) : undefined}
         >
           <div className="flex-1 min-w-0">
             <p className="text-sm font-medium truncate">{item.title}</p>
@@ -330,6 +332,7 @@ function FunnelTab({ account }: { account: Account }) {
 export default function AccountDetailPage() {
   const { id } = useParams<{ id: string }>()
   const navigate = useNavigate()
+  const appPath = useAppPath()
   const [account, setAccount] = useState<Account | null>(null)
   const [loading, setLoading] = useState(true)
 
@@ -345,7 +348,7 @@ export default function AccountDetailPage() {
   return (
     <div className="flex flex-col h-full">
       <div className="px-6 py-4 border-b border-border shrink-0">
-        <Button variant="ghost" size="sm" className="mb-2 -ml-2 gap-1 text-muted-foreground" onClick={() => navigate('/cortex/crm/accounts')}>
+        <Button variant="ghost" size="sm" className="mb-2 -ml-2 gap-1 text-muted-foreground" onClick={() => navigate(appPath('/crm/accounts'))}>
           <ArrowLeft className="h-3.5 w-3.5" /> Accounts
         </Button>
         <div className="flex items-center gap-3">

package/pages/crm/AccountsPage.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
+import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
 import { Input } from '@core/components/ui/input'
 import { Badge } from '@core/components/ui/badge'
@@ -26,6 +27,7 @@ type Filter = 'all'
 
 export default function AccountsPage() {
   const navigate = useNavigate()
+  const appPath = useAppPath()
   const [accounts, setAccounts] = useState<Account[]>([])
   const [loading, setLoading] = useState(true)
   const [search, setSearch] = useState('')
@@ -91,7 +93,7 @@ export default function AccountsPage() {
               {filtered.map(account => (
                 <tr
                   key={account.id}
-                  onClick={() => navigate(`/cortex/crm/accounts/${account.id}`)}
+                  onClick={() => navigate(appPath(`/crm/accounts/${account.id}`))}
                   className="hover:bg-accent/50 cursor-pointer transition-colors"
                 >
                   <td className="px-5 py-3 font-medium">

package/pages/crm/DealDetailPage.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useNavigate, useParams } from 'react-router-dom'
+import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
 
 const STAGES = ['prospecting', 'qualification', 'proposal', 'negotiation', 'closed_won', 'closed_lost']
@@ -19,6 +20,7 @@ const EMPTY: DealForm = { title: '', stage: 'prospecting', value: '', close_date
 export default function DealDetailPage() {
   const { id } = useParams<{ id: string }>()
   const navigate = useNavigate()
+  const appPath = useAppPath()
   const isNew = !id || id === 'new'
 
   const [form, setForm] = useState<DealForm>(EMPTY)
@@ -82,7 +84,7 @@ export default function DealDetailPage() {
   const handleDelete = async () => {
     if (!confirm('Delete this deal?')) return
     await apiFetch(`/api/admin-data?action=delete&entity=items&id=${id}`, { method: 'POST' })
-    navigate('/cortex/crm/deals')
+    navigate(appPath('/crm/deals'))
   }
 
   const set = (field: keyof DealForm) => (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) =>
@@ -93,7 +95,7 @@ export default function DealDetailPage() {
   return (
     <div className="p-6 max-w-2xl">
       <div className="flex items-center gap-3 mb-6">
-        <button onClick={() => navigate('/cortex/crm/deals')} className="text-slate-400 hover:text-slate-700 text-sm">
+        <button onClick={() => navigate(appPath('/crm/deals'))} className="text-slate-400 hover:text-slate-700 text-sm">
           ← Deals
         </button>
         <h1 className="text-xl font-bold text-slate-900">{isNew ? 'New Deal' : 'Edit Deal'}</h1>
@@ -174,7 +176,7 @@ export default function DealDetailPage() {
           </button>
         ) : <div />}
         <div className="flex gap-3">
-          <button onClick={() => navigate('/cortex/crm/deals')} className="px-4 py-2 text-sm text-slate-600 border border-slate-200 rounded-lg hover:bg-slate-50">
+          <button onClick={() => navigate(appPath('/crm/deals'))} className="px-4 py-2 text-sm text-slate-600 border border-slate-200 rounded-lg hover:bg-slate-50">
             Cancel
           </button>
           <button

package/pages/crm/DealsPage.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
+import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
 
 interface Deal {
@@ -40,6 +41,7 @@ function DealCard({ deal, onClick }: { deal: Deal; onClick: () => void }) {
 
 export default function DealsPage() {
   const navigate = useNavigate()
+  const appPath = useAppPath()
   const [deals, setDeals] = useState<Deal[]>([])
   const [loading, setLoading] = useState(true)
   const [view, setView] = useState<'kanban' | 'list'>('kanban')
@@ -77,7 +79,7 @@ export default function DealsPage() {
             </button>
           </div>
           <button
-            onClick={() => navigate('/cortex/crm/deals/new')}
+            onClick={() => navigate(appPath('/crm/deals/new'))}
             className="bg-blue-600 text-white text-sm font-medium px-4 py-2 rounded-lg hover:bg-blue-700 transition-colors"
           >
             + New Deal
@@ -133,7 +135,7 @@ export default function DealsPage() {
                 <tr>
                   <td colSpan={5} className="px-5 py-12 text-center text-slate-400">
                     No deals yet.{' '}
-                    <button onClick={() => navigate('/cortex/crm/deals/new')} className="text-blue-600 hover:underline">
+                    <button onClick={() => navigate(appPath('/crm/deals/new'))} className="text-blue-600 hover:underline">
                       Create one →
                     </button>
                   </td>