spine-framework 0.3.107 → 0.3.109

package/.framework/functions/_shared/agent-runner.ts

@@ -184,16 +184,26 @@ export async function runAgent(
       )
     }
 
-    // 5. Save agent response
+    // 5. Save agent response — include retrieved_sources + retrieval_confidence
+    //    so the feedback capture pipeline and the Portal UI can access them.
     const agentMsg = await saveMessage(
       threadId,
       agentResponse.content,
       'agent',
       {
         confidence: agentResponse.confidence,
+        retrieval_confidence: agentResponse.retrievalConfidence,
+        retrieved_sources: (agentResponse.retrievedSources || []).map((s: any) => ({
+          document_id: s.document_id,
+          title: s.title,
+          similarity: s.similarity,
+          item_type: s.item_type,
+          vector_type: s.vector_type,
+        })),
         tool_calls: agentResponse.tool_calls,
         agent_id: agent.id,
-        prompt_config_id: promptConfig.id
+        prompt_config_id: promptConfig.id,
+        sender_type: 'agent',
       },
       ctx,
       replyTypeSlug
@@ -208,6 +218,8 @@ export async function runAgent(
       thread_id: threadId,
       agent_id: agent.id,
       confidence: agentResponse.confidence,
+      retrieval_confidence: agentResponse.retrievalConfidence,
+      sources_count: agentResponse.retrievedSources?.length || 0,
       has_tool_calls: !!agentResponse.tool_calls?.length,
       duration_ms: Date.now() - startTime
     })
@@ -347,36 +359,49 @@ async function executeAgentInference(
   userMessage: string,
   ctx: CoreContext,
   maxToolIterations: number = 5
-): Promise<InferenceResult> {
-  const { agent, promptConfig, thread } = config
+): Promise<InferenceResult & { retrievedSources: any[]; retrievalConfidence: number }> {
+  const { agent, promptConfig } = config
 
-  // Build initial context
-  let context = await buildContext(config, userMessage, [], ctx)
+  // Build initial context — captures retrieved sources for feedback capture
+  let { context, retrievedSources, meanSimilarity } = await buildContext(config, userMessage, [], ctx)
 
   for (let iteration = 0; iteration < maxToolIterations; iteration++) {
-    // Call inference
     const inferenceResult = await callInference(context, agent, promptConfig, ctx)
 
-    // If no tool calls, return immediately
     if (!inferenceResult.tool_calls || inferenceResult.tool_calls.length === 0) {
-      return inferenceResult
+      // Composite confidence: 60% LLM logprobs + 40% retrieval similarity
+      // If mean retrieval similarity < 0.40, cap composite at 0.60
+      const llmConf = inferenceResult.confidence ?? 0.85
+      let compositeConf: number
+      if (meanSimilarity < 0.40 && meanSimilarity > 0) {
+        compositeConf = Math.min(llmConf * 0.6 + meanSimilarity * 0.4, 0.60)
+      } else {
+        compositeConf = llmConf * 0.6 + Math.min(meanSimilarity, 1) * 0.4
+      }
+
+      return {
+        ...inferenceResult,
+        confidence: Math.min(Math.max(compositeConf, 0), 1),
+        retrievedSources,
+        retrievalConfidence: meanSimilarity,
+      }
     }
 
-    // Execute tools
     const toolResults = await dispatchTools(inferenceResult.tool_calls, ctx)
+    const rebuilt = await buildContext(config, userMessage, toolResults, ctx)
+    context = rebuilt.context
+    if (rebuilt.retrievedSources.length) {
+      retrievedSources = rebuilt.retrievedSources
+      meanSimilarity = rebuilt.meanSimilarity
+    }
 
-    // Add tool results to context and re-inference
-    context = await buildContext(config, userMessage, toolResults, ctx)
-
-    // Check if any tool failed - if so, return with error info
     const hasErrors = toolResults.some(r => r.error)
     if (hasErrors && iteration === maxToolIterations - 1) {
       inferenceResult.content += '\n\n[Note: Some tools failed to execute.]'
-      return inferenceResult
+      return { ...inferenceResult, retrievedSources, retrievalConfidence: meanSimilarity }
     }
   }
 
-  // Max iterations reached
   throw new Error('Max tool iterations reached')
 }
 
@@ -407,7 +432,7 @@ async function buildContext(
   userMessage: string,
   toolResults: ToolResult[],
   ctx: CoreContext
-): Promise<string> {
+): Promise<{ context: string; retrievedSources: any[]; meanSimilarity: number }> {
   const { agent, promptConfig, thread } = config
 
   // 1. System prompt (from agent)
@@ -419,19 +444,30 @@ async function buildContext(
   }
 
   // 3. Retrieved knowledge (RAG)
-  if (promptConfig.knowledge_sources && promptConfig.knowledge_sources.length > 0) {
-    const retrievedDocs = await retrieveKnowledge(
+  // Always attempt retrieval — even with empty knowledge_sources (full scope search)
+  let retrievedSources: any[] = []
+  let meanSimilarity = 0
+  const retrievalPolicy = promptConfig.metadata?.retrieval_policy || {}
+
+  try {
+    const { docs, meanSimilarity: ms } = await retrieveKnowledge(
       userMessage,
-      promptConfig.knowledge_sources,
-      ctx.accountId!
+      promptConfig.knowledge_sources || [],
+      ctx.accountId!,
+      retrievalPolicy
     )
-    if (retrievedDocs.length > 0) {
+    retrievedSources = docs
+    meanSimilarity = ms
+
+    if (docs.length > 0) {
       context += '## Relevant Information\n'
-      retrievedDocs.forEach((doc, i) => {
-        context += `[${i + 1}] ${doc.content}\n`
+      docs.forEach((doc, i) => {
+        const sourceLabel = doc.title ? `[${i + 1}] ${doc.title}` : `[${i + 1}]`
+        context += `${sourceLabel}\n${doc.content}\n\n`
       })
-      context += '\n'
     }
+  } catch (err) {
+    console.warn('retrieveKnowledge failed — proceeding without context:', err)
   }
 
   // 4. Conversation history
@@ -470,7 +506,7 @@ async function buildContext(
   // 7. Current user message
   context += `## Current Message\nUser: ${userMessage}\n\nAssistant: `
 
-  return context
+  return { context, retrievedSources, meanSimilarity }
 }
 
 // ─── KNOWLEDGE & HISTORY ───────────────────────────────────────────────────────────
@@ -505,29 +541,35 @@ async function buildContext(
 async function retrieveKnowledge(
   query: string,
   knowledgeSources: string[],
-  accountId: string
-): Promise<any[]> {
+  accountId: string,
+  retrievalPolicy?: {
+    item_types?: string[]
+    vector_types?: string[]
+    max_security_level?: 'external' | 'internal' | 'restricted'
+    require_approved?: boolean
+  }
+): Promise<{ docs: any[]; meanSimilarity: number }> {
   const SIMILARITY_THRESHOLD = 0.15
   const MATCH_COUNT = 8
+  const policy = retrievalPolicy || {}
+  const vectorTypesToSearch = policy.vector_types?.length ? policy.vector_types : ['semantic']
+  const maxSecurityLevel = policy.max_security_level || 'internal'
+
+  // Security level ordering: external < internal < restricted
+  const SECURITY_ORDER: Record<string, number> = { external: 0, internal: 1, restricted: 2 }
+  const maxSecurityRank = SECURITY_ORDER[maxSecurityLevel] ?? 1
 
   // ── Tier 1: vector similarity via match_embeddings RPC ──────────────────
   try {
     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) throw new Error('no_api_key')
 
-    // Resolve platform account ID at runtime — no hardcoded UUIDs
+    // Resolve platform account — always include spine-system KB
     const { data: platformAccount } = await adminDb
-      .from('accounts')
-      .select('id')
-      .eq('slug', 'spine-system')
-      .maybeSingle()
-
+      .from('accounts').select('id').eq('slug', 'spine-system').maybeSingle()
     const accountIds: string[] = [accountId]
-    if (platformAccount?.id && platformAccount.id !== accountId) {
-      accountIds.push(platformAccount.id)
-    }
+    if (platformAccount?.id && platformAccount.id !== accountId) accountIds.push(platformAccount.id)
 
     // Generate query embedding
     const embedRes = await fetch(`${baseUrl}/embeddings`, {
@@ -540,29 +582,37 @@ async function retrieveKnowledge(
     const queryEmbedding: number[] = embedJson.data?.[0]?.embedding || []
     if (!queryEmbedding.length) throw new Error('empty_embedding')
 
-    // Call vector RPC
-    const { data: matches, error: rpcError } = await adminDb.rpc('match_embeddings', {
-      query_embedding: `[${queryEmbedding.join(',')}]`,
-      match_count: MATCH_COUNT * 3,
-      filter_account_ids: accountIds,
-      filter_vector_type: 'semantic',
-      similarity_threshold: SIMILARITY_THRESHOLD,
-    })
-    if (rpcError) throw new Error(`rpc_${rpcError.message}`)
+    // Multi-vector search: run all declared vector types and merge
+    const allMatches: any[] = []
+    for (const vt of vectorTypesToSearch) {
+      const { data: matches, error: rpcError } = await adminDb.rpc('match_embeddings', {
+        query_embedding: `[${queryEmbedding.join(',')}]`,
+        match_count: MATCH_COUNT * 3,
+        filter_account_ids: accountIds,
+        filter_vector_type: vt,
+        similarity_threshold: SIMILARITY_THRESHOLD,
+        filter_item_types: policy.item_types?.length ? policy.item_types : null,
+      })
+      if (rpcError) throw new Error(`rpc_${rpcError.message}`)
+      allMatches.push(...(matches || []))
+    }
 
-    // Filter: security_level restriction for cross-account results
-    const filtered = (matches || []).filter((r: any) => {
+    // Hard security filter
+    const filtered = allMatches.filter((r: any) => {
       if (r.similarity < SIMILARITY_THRESHOLD) return false
-      if (r.account_id === accountId) return true
-      return r.metadata?.security_level !== 'restricted'
+      const secLevel = r.metadata?.security_level || 'internal'
+      const rank = SECURITY_ORDER[secLevel] ?? 1
+      if (rank > maxSecurityRank) return false
+      if (r.account_id !== accountId && secLevel === 'restricted') return false
+      return true
     })
 
-    // Optionally narrow to knowledgeSources doc IDs
+    // Narrow to knowledgeSources if specified
     const scoped = knowledgeSources.length > 0
       ? filtered.filter((r: any) => knowledgeSources.includes(r.document_id))
       : filtered
 
-    // Deduplicate — best chunk per document
+    // Deduplicate — best chunk per document across all vector types
     const bestByDoc = new Map<string, any>()
     for (const r of scoped) {
       const existing = bestByDoc.get(r.document_id)
@@ -572,47 +622,66 @@ async function retrieveKnowledge(
       .sort((a, b) => b.similarity - a.similarity)
       .slice(0, MATCH_COUNT)
 
-    if (deduped.length === 0) return []
+    if (!deduped.length) return { docs: [], meanSimilarity: 0 }
+
+    // If top result < 0.50 and summary not already included, try summary fallback
+    if (deduped[0]?.similarity < 0.50 && !vectorTypesToSearch.includes('summary')) {
+      const { data: summaryMatches } = await adminDb.rpc('match_embeddings', {
+        query_embedding: `[${queryEmbedding.join(',')}]`,
+        match_count: MATCH_COUNT,
+        filter_account_ids: accountIds,
+        filter_vector_type: 'summary',
+        similarity_threshold: SIMILARITY_THRESHOLD,
+        filter_item_types: policy.item_types?.length ? policy.item_types : null,
+      })
+      for (const r of summaryMatches || []) {
+        if (!bestByDoc.has(r.document_id) && r.similarity >= SIMILARITY_THRESHOLD) {
+          bestByDoc.set(r.document_id, r)
+        }
+      }
+    }
+    const finalDocs = [...bestByDoc.values()]
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, MATCH_COUNT)
 
     // Enrich with item titles
     const { data: items } = await adminDb
-      .from('items')
-      .select('id, title, description')
-      .in('id', deduped.map((r: any) => r.document_id))
-
+      .from('items').select('id, title').in('id', finalDocs.map((r: any) => r.document_id))
     const itemMap = new Map((items || []).map((i: any) => [i.id, i]))
-    return deduped.map((r: any) => ({
+
+    const docs = finalDocs.map((r: any) => ({
       document_id: r.document_id,
       content: r.content,
       metadata: r.metadata,
       similarity: r.similarity,
       title: itemMap.get(r.document_id)?.title || '',
+      item_type: r.metadata?.item_type || '',
+      vector_type: r.metadata?.vector_type || '',
     }))
 
+    const meanSimilarity = docs.length
+      ? docs.reduce((sum: number, d: any) => sum + d.similarity, 0) / docs.length
+      : 0
+
+    return { docs, meanSimilarity }
+
   } catch (vectorErr: any) {
     // ── Tier 2: full-text fallback ──────────────────────────────────────
     if (vectorErr.message !== 'no_api_key') {
       console.warn('retrieveKnowledge vector search failed, falling back to text search:', vectorErr.message)
     }
-
     const baseQuery = adminDb
       .from('embeddings')
       .select('document_id, content, metadata, account_id')
       .eq('account_id', accountId)
       .eq('metadata->>vector_type', 'semantic')
+      .not('revoked_at', 'is', null)
       .textSearch('content', query, { type: 'websearch', config: 'english' })
       .limit(5)
-
-    const q = knowledgeSources.length > 0
-      ? baseQuery.in('document_id', knowledgeSources)
-      : baseQuery
-
+    const q = knowledgeSources.length > 0 ? baseQuery.in('document_id', knowledgeSources) : baseQuery
     const { data: docs, error } = await q
-    if (error) {
-      console.error('Knowledge retrieval fallback failed:', error)
-      return []
-    }
-    return docs || []
+    if (error) { console.error('Knowledge retrieval fallback failed:', error); return { docs: [], meanSimilarity: 0 } }
+    return { docs: docs || [], meanSimilarity: 0 }
   }
 }
 
@@ -1172,17 +1241,6 @@ async function handleEscalation(
  * @sideEffects DB write: messages table
  * @calledBy runAgent (user message + agent response)
  */
-// Module-level cache so we only look up message type_ids once per cold-start
-const _messageTypeIds: Record<string, string> = {}
-
-async function getMessageTypeId(slug: string): Promise<string> {
-  if (_messageTypeIds[slug]) return _messageTypeIds[slug]
-  const { data } = await adminDb.from('types').select('id').eq('slug', slug).maybeSingle()
-  if (!data?.id) throw new Error(`Type "${slug}" not found in types table`)
-  _messageTypeIds[slug] = data.id
-  return data.id
-}
-
 // Map a thread type slug to the corresponding message/reply type slug.
 function getReplyTypeSlug(threadTypeSlug: string): string {
   if (threadTypeSlug === 'support_thread') return 'support_reply'
@@ -1198,20 +1256,20 @@ async function saveMessage(
   ctx: CoreContext,
   messageTypeSlug: string = 'message'
 ): Promise<any> {
-  const [typeId, { count }] = await Promise.all([
-    getMessageTypeId(messageTypeSlug),
-    adminDb.from('messages').select('id', { count: 'exact', head: true }).eq('thread_id', threadId),
-  ])
+  const { count } = await adminDb
+    .from('messages')
+    .select('id', { count: 'exact', head: true })
+    .eq('thread_id', threadId)
   const sequence = (count ?? 0) + 1
   const direction = messageType === 'human' ? 'inbound' : 'outbound'
   // human + agent messages are customer-visible; tool/system messages are internal
   const visibility = (messageType === 'human' || messageType === 'agent') ? 'external' : 'internal'
 
-  // Use admin-data's create() so design_schema + validation_schema are stamped
-  // from the type record — ensuring the permission engine returns full rows.
+  // Use admin-data's create() so type_slug is resolved server-side and
+  // design_schema + validation_schema are stamped from the type record.
   const message = await createRecord(ctx, {
     entity: 'messages',
-    type_id: typeId,
+    type_slug: messageTypeSlug,
     thread_id: threadId,
     person_id: messageType === 'human' ? ctx.principal?.id : null,
     content,

package/.framework/functions/_shared/permissions.ts

@@ -252,22 +252,10 @@ class _PermissionEngineInternal {
       // 1. Load type design schema if not provided (pre-stamped on record is preferred)
       let schema = designSchema
       if (!schema || !schema.record_permissions) {
-        // Attempt type lookup by slug as fallback
-        const { data: typeRecord } = await adminDb
-          .from('types')
-          .select('design_schema')
-          .eq('slug', typeSlug)
-          .eq('is_active', true)
-          .single()
-
-        // No schema = no permissions. RLS controls row access;
-        // design_schema controls what the principal can do with the record.
-        // A missing or empty schema is an explicit deny — not a free pass.
-        if (!typeRecord?.design_schema?.record_permissions) {
-          return defaultResult
-        }
-
-        schema = typeRecord.design_schema
+        // Runtime records are stamped with design_schema at creation. We do not
+        // fall back to the type definition because the runtime record is the
+        // source of truth for its own schema and permissions.
+        return defaultResult
       }
 
       // 2. Get user's role via people.role_id FK

package/.framework/functions/_shared/pipeline-runner.ts

@@ -626,7 +626,37 @@ const stageHandlers: Record<string, Function> = {
       metadata: { mock: true },
       model: model || 'gpt-4o'
     }
-  }
+  },
+
+  // ── generate_embeddings ─────────────────────────────────────────────────────
+  // Generates embeddings for an item using the core embeddings.generate action.
+  // Supports {{trigger.entity_id}} template interpolation in config.item_id.
+  //
+  // Config: item_id (required — supports {{trigger.entity_id}}),
+  //         force_regenerate (bool, default false)
+  //
+  // Called by the auto_embed_on_publish and auto_revoke_on_unpublish pipelines.
+  'generate_embeddings': async (ctx: CoreContext, config: any) => {
+    const triggerData = config._triggerData || {}
+    let itemId = config.item_id
+    if (!itemId) throw new Error('item_id is required for generate_embeddings')
+
+    // Template interpolation: {{trigger.entity_id}} or {{entity_id}}
+    if (typeof itemId === 'string' && itemId.includes('{{')) {
+      itemId = itemId
+        .replace(/\{\{trigger\.entity_id\}\}/g, triggerData?.entity_id || '')
+        .replace(/\{\{entity_id\}\}/g, triggerData?.entity_id || '')
+    }
+
+    if (!itemId) throw new Error('generate_embeddings: could not resolve item_id from trigger data')
+
+    const { generate } = await import('../embeddings')
+    const genCtx = { ...ctx, query: { ...(ctx.query || {}), action: 'generate' } }
+    return await generate(genCtx, {
+      item_id: itemId,
+      force_regenerate: config.force_regenerate ?? false,
+    })
+  },
 }
 
 // ─── MODULE DISPATCHERS ────────────────────────────────────────────────────────────

package/.framework/functions/admin-data.ts

@@ -44,6 +44,7 @@
 import { createHandler } from './_shared/middleware'
 import { sanitizeRecordData } from './_shared/permissions'
 import { adminDb } from './_shared/db'
+import { resolveTypeId } from './_shared/resolve-ids'
 import { fireCreateTriggers, fireUpdateTriggers, fireDeleteTriggers } from './_shared/trigger-engine'
 
 // ─── CONSTANTS ────────────────────────────────────────────────────────────────
@@ -59,6 +60,17 @@ const PERMISSIONS_ALL = {
  */
 const VALID_ENTITIES = ['accounts', 'people', 'items', 'threads', 'messages', 'links', 'attachments', 'watchers', 'item_progress']
 
+// Map admin-data entity names to the kind field used in the types table
+const ENTITY_TO_KIND: Record<string, string> = {
+  items: 'item',
+  threads: 'thread',
+  messages: 'message',
+  links: 'link',
+  attachments: 'attachment',
+  watchers: 'watcher',
+  item_progress: 'item_progress'
+}
+
 // ─── HANDLERS ─────────────────────────────────────────────────────────────────
 
 // ─── CHUNK_START: ADMIN_DATA_LIST ──────────────────────────────────────────────
@@ -89,17 +101,14 @@ export const list = createHandler(async (ctx, _body) => {
   let query = ctx.db.from(entity).select('*')
 
   // Apply type_slug filter if provided (for schema-driven entities)
-  if (type_slug && entity === 'items') {
-    // Look up the type ID from the slug
-    const { data: typeRecord } = await adminDb
-      .from('types')
-      .select('id')
-      .eq('slug', type_slug)
-      .eq('is_active', true)
-      .single()
-    
-    if (typeRecord) {
-      query = query.eq('type_id', typeRecord.id)
+  if (type_slug) {
+    const kind = ENTITY_TO_KIND[entity]
+    if (kind) {
+      // Resolve the type ID from the slug via the shared resolver
+      const typeId = await resolveTypeId(kind, type_slug)
+      if (typeId) {
+        query = query.eq('type_id', typeId)
+      }
     }
   }
 
@@ -250,30 +259,41 @@ export const get = createHandler(async (ctx, _body) => {
  */
 export const create = createHandler(async (ctx, body) => {
   const entity = body?.entity || ctx.query?.entity
-  const { entity: _e, design_schema: _ds, validation_schema: _vs, account_id: _ai, ...recordData } = body || {}
+  const { entity: _e, type_slug: _ts, design_schema: _ds, validation_schema: _vs, account_id: _ai, ...recordData } = body || {}
 
   if (!entity || !VALID_ENTITIES.includes(entity)) {
     const e: any = new Error('Valid entity parameter is required'); e.statusCode = 400; throw e
   }
 
+  // Resolve type_id from type_slug if provided, otherwise require type_id directly
+  let typeId = recordData.type_id
+  if (!typeId && body?.type_slug) {
+    const kind = ENTITY_TO_KIND[entity]
+    if (!kind) {
+      const e: any = new Error(`type_slug is not supported for entity: ${entity}`); e.statusCode = 400; throw e
+    }
+    typeId = await resolveTypeId(kind, body.type_slug)
+  }
+
   // type_id is required on all runtime record creation
-  if (!recordData.type_id) {
-    const e: any = new Error('type_id is required — every runtime record must reference a type'); e.statusCode = 400; throw e
+  if (!typeId) {
+    const e: any = new Error('type_id or type_slug is required — every runtime record must reference a type'); e.statusCode = 400; throw e
   }
+  recordData.type_id = typeId
 
   // Look up the type to stamp design_schema and validation_schema
   const { data: typeRecord, error: typeErr } = await adminDb
     .from('types')
     .select('id, design_schema, validation_schema, is_active')
-    .eq('id', recordData.type_id)
+    .eq('id', typeId)
     .single()
 
   if (typeErr || !typeRecord) {
-    throw new Error(`type_id not found: ${recordData.type_id}`)
+    throw new Error(`type_id not found: ${typeId}`)
   }
 
   if (!typeRecord.is_active) {
-    throw new Error(`type_id references an inactive type: ${recordData.type_id}`)
+    throw new Error(`type_id references an inactive type: ${typeId}`)
   }
 
   // Ensure the type has at least permissions=ALL (defensive — migration 062 guarantees this)
@@ -282,8 +302,9 @@ export const create = createHandler(async (ctx, body) => {
     designSchema = { ...PERMISSIONS_ALL, ...designSchema }
   }
 
-  // Resolve account_id and propagate scope via parent inheritance (Option A)
-  // Priority: parent reference in body > type's own scope declaration
+  // Resolve account_id and propagate scope via parent inheritance.
+  // Runtime records are the source of truth: the parent record's stamped scope
+  // and account_id are inherited, not re-looked up from the type table.
   let recordAccountId = ctx.accountId
   const parentRef = recordData.thread_id || recordData.target_id || recordData.parent_id
   if (parentRef) {
@@ -301,16 +322,18 @@ export const create = createHandler(async (ctx, body) => {
     if (parentScope) {
       designSchema = { ...designSchema, scope: parentScope }
     }
-  } else {
-    const scope: string = designSchema.scope ?? 'account'
-    if (scope === 'platform') {
-      const { data: sysAccount } = await adminDb
-        .from('accounts')
-        .select('id')
-        .eq('slug', 'spine-system')
-        .single()
-      if (sysAccount?.id) recordAccountId = sysAccount.id
-    }
+  }
+
+  // Platform-scoped records belong to the system account so they are visible
+  // across all accounts. Child records already inherited the parent's scope above.
+  const resolvedScope: string = designSchema.scope ?? 'account'
+  if (resolvedScope === 'platform') {
+    const { data: sysAccount } = await adminDb
+      .from('accounts')
+      .select('id')
+      .eq('slug', 'spine-system')
+      .single()
+    if (sysAccount?.id) recordAccountId = sysAccount.id
   }
 
   // Add audit fields + stamped schema