@lota-sdk/core 0.1.16 → 0.1.17

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -14,6 +14,7 @@ import type { RegularChatMemoryDigestJob } from '../queues/regular-chat-memory-d
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { memoryService } from '../services/memory.service'
+import { socialChatHistoryService } from '../services/social-chat-history.service'
 import { createRegularChatMemoryDigestAgent } from '../system-agents/regular-chat-memory-digest.agent'
 import { compactWhitespace } from '../utils/string'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
@@ -48,6 +49,7 @@ const helperModelRuntime = createHelperModelRuntime()
 interface RegularChatDigestRunResult {
   skipped: boolean
   processedWorkstreamMessages: number
+  processedSocialMessages: number
   followUpScheduled: boolean
 }
 
@@ -152,7 +154,7 @@ export async function runRegularChatMemoryDigest(
   const workspaceProvider = getRuntimeAdapters().services?.workspaceProvider
   if (!workspaceProvider) {
     serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
-    return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+    return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
   }
 
   return withConfiguredWorkspaceMemoryLock(orgId, async () => {
@@ -162,14 +164,14 @@ export async function runRegularChatMemoryDigest(
       !workspaceProvider.applyProfileProjection
     ) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider background/profile methods are incomplete`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
     const workspace = await workspaceProvider.getWorkspace(orgRef)
     const lifecycleState = await workspaceProvider.getLifecycleState?.(workspace)
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: onboarding is not completed`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
     const projectionState = await workspaceProvider.readProfileProjectionState?.(workspace)
 
@@ -185,13 +187,23 @@ export async function runRegularChatMemoryDigest(
       cursor: existingWorkstreamCursor,
       onboardingCutoff: workstreamOnboardingCutoff,
     })
+    const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('regular-chat-digest', orgId)
+    const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
+      hasExistingCursor: existingSocialCursor !== null,
+      bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
+    })
+    const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: existingSocialCursor,
+      onboardingCutoff: socialOnboardingCutoff,
+    })
 
-    if (workstreamMessages.length === 0) {
+    if (workstreamMessages.length === 0 && socialMessages.length === 0) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: no eligible messages`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const combinedMessages = [...workstreamMessages].sort(compareDigestMessageOrder)
+    const combinedMessages = [...workstreamMessages, ...socialMessages].sort(compareDigestMessageOrder)
     const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
     const existingMemories = await loadExistingOrganizationMemories(orgId)
 
@@ -219,7 +231,8 @@ export async function runRegularChatMemoryDigest(
       throw new Error('Regular chat memory digest returned an empty summaryBlock')
     }
 
-    const processedWorkstreamCursor = getLastCursor(combinedMessages)
+    const processedWorkstreamCursor = getLastCursor(workstreamMessages)
+    const processedSocialCursor = getLastCursor(socialMessages)
     const digestRunAt = new Date().toISOString()
 
     if (synthesis.facts.length > 0) {
@@ -235,6 +248,12 @@ export async function runRegularChatMemoryDigest(
                 digestWorkstreamCursorId: processedWorkstreamCursor.id,
               }
             : {}),
+          ...(processedSocialCursor
+            ? {
+                digestSocialCursorCreatedAt: processedSocialCursor.createdAt.toISOString(),
+                digestSocialCursorId: processedSocialCursor.id,
+              }
+            : {}),
         },
         agentNames: involvedAgentNames,
         acquireLock: false,
@@ -248,6 +267,9 @@ export async function runRegularChatMemoryDigest(
     if (processedWorkstreamCursor) {
       await workspaceProvider.setBackgroundCursor('regular-chat-digest', orgRef, processedWorkstreamCursor)
     }
+    if (processedSocialCursor) {
+      await socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
+    }
 
     const workstreamBoundaryCursor = processedWorkstreamCursor ?? existingWorkstreamCursor
     const hasMoreWorkstreamMessages = await hasNewEligibleWorkstreamMessages({
@@ -255,15 +277,26 @@ export async function runRegularChatMemoryDigest(
       cursor: workstreamBoundaryCursor,
       onboardingCutoff: workstreamBoundaryCursor ? null : workstreamOnboardingCutoff,
     })
+    const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
+    const hasMoreSocialMessages = await socialChatHistoryService.hasWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: socialBoundaryCursor,
+      onboardingCutoff: socialBoundaryCursor ? null : socialOnboardingCutoff,
+    })
 
-    const followUpScheduled = hasMoreWorkstreamMessages
+    const followUpScheduled = hasMoreWorkstreamMessages || hasMoreSocialMessages
     if (followUpScheduled) {
       await clearRegularChatMemoryDigestDeduplicationKey(orgId)
       await enqueueRegularChatMemoryDigest({ orgId })
     }
 
-    serverLogger.info`Regular chat memory digest completed for ${orgId}: workstreamMessages=${workstreamMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
+    serverLogger.info`Regular chat memory digest completed for ${orgId}: workstreamMessages=${workstreamMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
 
-    return { skipped: false, processedWorkstreamMessages: workstreamMessages.length, followUpScheduled }
+    return {
+      skipped: false,
+      processedWorkstreamMessages: workstreamMessages.length,
+      processedSocialMessages: socialMessages.length,
+      followUpScheduled,
+    }
   })
 }

package/src/workers/skill-extraction.runner.ts

@@ -6,6 +6,7 @@ import type { SkillExtractionJob } from '../queues/skill-extraction.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { learnedSkillService } from '../services/learned-skill.service'
+import { socialChatHistoryService } from '../services/social-chat-history.service'
 import { createSkillExtractorAgent, SkillExtractionOutputSchema } from '../system-agents/skill-extractor.agent'
 import type { SkillCandidate } from '../system-agents/skill-extractor.agent'
 import { createSkillManagerAgent, SkillManagerOutputSchema } from '../system-agents/skill-manager.agent'
@@ -100,9 +101,24 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       hasExistingCursor: existingCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
+    const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('skill-extraction', orgId)
+    const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
+      hasExistingCursor: existingSocialCursor !== null,
+      bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
+    })
 
     const workstreamIds = await listWorkstreamIdsForOrg(orgRef)
-    const messages = await listEligibleWorkstreamMessages({ workstreamIds, cursor: existingCursor, onboardingCutoff })
+    const workstreamMessages = await listEligibleWorkstreamMessages({
+      workstreamIds,
+      cursor: existingCursor,
+      onboardingCutoff,
+    })
+    const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: existingSocialCursor,
+      onboardingCutoff: socialOnboardingCutoff,
+    })
+    const messages = [...workstreamMessages, ...socialMessages]
 
     if (messages.length < MIN_MESSAGE_THRESHOLD) {
       serverLogger.info`Skipping skill extraction for ${orgId}: only ${messages.length} messages (threshold: ${MIN_MESSAGE_THRESHOLD})`
@@ -225,12 +241,16 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       }
     }
 
-    const lastMessage = sortedMessages.at(-1)
-    if (lastMessage) {
-      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastMessage.cursor)
+    const lastWorkstreamMessage = workstreamMessages.at(-1)
+    const lastSocialMessage = socialMessages.at(-1)
+    if (lastWorkstreamMessage) {
+      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastWorkstreamMessage.cursor)
+    }
+    if (lastSocialMessage) {
+      await socialChatHistoryService.setBackgroundCursor('skill-extraction', orgId, lastSocialMessage.cursor)
     }
 
-    serverLogger.info`Skill extraction completed for ${orgId}: messages=${messages.length}, extracted=${extractedSkills}`
+    serverLogger.info`Skill extraction completed for ${orgId}: messages=${messages.length}, socialMessages=${socialMessages.length}, extracted=${extractedSkills}`
 
     return { skipped: false, processedMessages: messages.length, extractedSkills }
   })

package/src/workers/utils/repo-structure-extractor.ts

@@ -1,4 +1,4 @@
-import { readdir, readFile } from 'node:fs/promises'
+import { readdir } from 'node:fs/promises'
 import path from 'node:path'
 
 import { RepositoryStructureArtifactSchema, RepositoryStructureSummarySchema } from '@lota-sdk/shared'
@@ -119,7 +119,7 @@ async function collectRelativeFilePaths(rootDir: string, currentDir = ''): Promi
 
 async function readPackageJson(rootDir: string, relativePath: string): Promise<PackageJson | null> {
   try {
-    const raw = await readFile(path.join(rootDir, relativePath), 'utf8')
+    const raw = await Bun.file(path.join(rootDir, relativePath)).text()
     return JSON.parse(raw) as PackageJson
   } catch {
     return null

package/src/workers/utils/workstream-message-query.ts

@@ -9,14 +9,12 @@ import { TABLES } from '../../db/tables'
 import { WorkstreamMessageRowSchema } from '../../db/workstream-message-row'
 import type { WorkstreamMessageRow } from '../../db/workstream-message-row'
 import { normalizeTextBody } from '../../document/parsing'
+import type { LotaRuntimeBackgroundCursor } from '../../runtime/runtime-extensions'
 
-export interface DigestCursor {
-  createdAt: Date
-  id: string
-}
+export type DigestCursor = LotaRuntimeBackgroundCursor
 
 export interface DigestMessage {
-  source: 'workstream'
+  source: 'workstream' | 'social'
   sourceId: string
   role: 'system' | 'user' | 'assistant'
   parts: Array<Record<string, unknown>>

package/src/runtime/workstream-routing-policy.ts

@@ -1,267 +0,0 @@
-import { extractAgentMentions, getLeadAgentId } from '../config/agent-defaults'
-
-export type MessageRoute =
-  | { type: 'direct'; agents: [string] }
-  | { type: 'mentions'; agents: string[] }
-  | { type: 'group-default'; agents: [string] }
-
-export type ReasoningProfileName = 'fast' | 'standard' | 'deep'
-
-export interface ReasoningProfile {
-  name: ReasoningProfileName
-  maxSteps: number
-  toolCallBudget: number
-  maxInputTokensHint: number
-}
-
-export type HighImpactResponseClass =
-  | 'architecture-recommendation'
-  | 'gtm-strategy'
-  | 'pricing-positioning'
-  | 'product-capability-claim'
-  | 'community-targeting'
-  | 'mutating-operation'
-
-export type PolicyClass = 'external-mutation' | 'security-privacy' | 'legal-compliance' | 'financial-decision'
-
-export function uniqueMentionOrder(message: string): string[] {
-  const ordered: string[] = []
-  const seen = new Set<string>()
-  for (const mention of extractAgentMentions(message)) {
-    const agent = mention.agent
-    if (seen.has(agent)) continue
-    seen.add(agent)
-    ordered.push(agent)
-  }
-  return ordered
-}
-
-const HIGH_IMPACT_CLASS_PATTERNS: Array<{ className: HighImpactResponseClass; patterns: RegExp[] }> = [
-  {
-    className: 'architecture-recommendation',
-    patterns: [
-      /\barchitecture\b/i,
-      /\btech(?:nical)?\s+stack\b/i,
-      /\binfra(?:structure)?\b/i,
-      /\brefactor\b/i,
-      /\bsystem\s+design\b/i,
-    ],
-  },
-  {
-    className: 'gtm-strategy',
-    patterns: [
-      /\bgo[-\s]?to[-\s]?market\b/i,
-      /\bgtm\b/i,
-      /\bdistribution\s+strategy\b/i,
-      /\blaunch\s+strategy\b/i,
-      /\bcontent\s+strategy\b/i,
-      /\bdemand\s+gen(?:eration)?\b/i,
-    ],
-  },
-  {
-    className: 'pricing-positioning',
-    patterns: [/\bpricing\b/i, /\bpositioning\b/i, /\bpackaging\b/i, /\bfreemium\b/i, /\bbilling\b/i],
-  },
-  {
-    className: 'product-capability-claim',
-    patterns: [
-      /\bdoes\s+it\s+(already\s+)?(support|have|do)\b/i,
-      /\bwhat\s+can\s+(it|we)\s+do\b/i,
-      /\bis\s+this\s+implemented\b/i,
-      /\bcurrent(?:ly)?\s+supports?\b/i,
-      /\bcapabilities?\b/i,
-    ],
-  },
-  {
-    className: 'community-targeting',
-    patterns: [
-      /\bwhere\s+to\s+post\b/i,
-      /\bcommunity\b/i,
-      /\btarget\s+audience\b/i,
-      /\bchannels?\b/i,
-      /\bdistribution\s+channels?\b/i,
-    ],
-  },
-  {
-    className: 'mutating-operation',
-    patterns: [
-      /\bdelete\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bremove\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bupdate\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bcreate\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bchange\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\barchive\b/i,
-      /\bskip\s+onboarding\b/i,
-      /\bproceed\s+in\s+onboarding\b/i,
-    ],
-  },
-]
-
-const POLICY_CLASS_PATTERNS: Array<{ className: PolicyClass; patterns: RegExp[] }> = [
-  {
-    className: 'external-mutation',
-    patterns: [
-      /\bdelete\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bremove\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bupdate\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bcreate\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\bchange\s+(issue|comment|task|record|workspace|project)\b/i,
-      /\barchive\b/i,
-      /\bskip\s+onboarding\b/i,
-      /\bproceed\s+in\s+onboarding\b/i,
-    ],
-  },
-  {
-    className: 'security-privacy',
-    patterns: [
-      /\bsecurity\b/i,
-      /\bprivacy\b/i,
-      /\bpii\b/i,
-      /\bauth(?:entication|orization)?\b/i,
-      /\bencrypt(?:ion|ed)?\b/i,
-      /\bpermission(?:s)?\b/i,
-      /\baccess\s+control\b/i,
-      /\bsecret(?:s)?\b/i,
-    ],
-  },
-  {
-    className: 'legal-compliance',
-    patterns: [
-      /\blegal\b/i,
-      /\bcompliance\b/i,
-      /\bregulation(?:s)?\b/i,
-      /\bgdpr\b/i,
-      /\bhipaa\b/i,
-      /\bsoc\s*2\b/i,
-      /\blicense\b/i,
-      /\bterms?\b/i,
-    ],
-  },
-  {
-    className: 'financial-decision',
-    patterns: [
-      /\bpricing\b/i,
-      /\bbilling\b/i,
-      /\brevenue\b/i,
-      /\bbudget\b/i,
-      /\bburn\s+rate\b/i,
-      /\brunway\b/i,
-      /\bfundrais(?:e|ing)\b/i,
-      /\bcash\s+flow\b/i,
-    ],
-  },
-]
-
-const REASONING_PROFILES: Record<ReasoningProfileName, ReasoningProfile> = {
-  fast: { name: 'fast', maxSteps: 5, toolCallBudget: 3, maxInputTokensHint: 12_000 },
-  standard: { name: 'standard', maxSteps: 10, toolCallBudget: 6, maxInputTokensHint: 24_000 },
-  deep: { name: 'deep', maxSteps: 15, toolCallBudget: 10, maxInputTokensHint: 36_000 },
-}
-
-const STRATEGIC_COMPLEXITY_PATTERNS: RegExp[] = [
-  /\bstrategy\b/i,
-  /\btrade[-\s]?off\b/i,
-  /\bcompare\b/i,
-  /\broadmap\b/i,
-  /\barchitecture\b/i,
-  /\bconstraints?\b/i,
-  /\bprioriti(?:y|es)\b/i,
-]
-
-const CROSS_SOURCE_COMPLEXITY_PATTERNS: RegExp[] = [
-  /\bcitation\b/i,
-  /\bevidence\b/i,
-  /\bsource\b/i,
-  /\bground(?:ed|ing)\b/i,
-  /\brepo\b/i,
-  /\bmemory\b/i,
-]
-
-const STANDARD_FLOOR_INTENT_PATTERNS: RegExp[] = [
-  /\bplan(?:ning)?\b/i,
-  /\bthink(?:ing)?\b/i,
-  /\bcareful(?:ly)?\b/i,
-  /\bimportant\b/i,
-  /\bcritical(?:ly)?\b/i,
-  /\bthorough(?:ly)?\b/i,
-]
-
-export function classifyHighImpactResponse(params: { message: string }): { classes: HighImpactResponseClass[] } {
-  const message = params.message.trim()
-  if (!message) return { classes: [] }
-
-  const classes: HighImpactResponseClass[] = []
-  for (const entry of HIGH_IMPACT_CLASS_PATTERNS) {
-    if (entry.patterns.some((pattern) => pattern.test(message))) {
-      classes.push(entry.className)
-    }
-  }
-
-  return { classes }
-}
-
-export function classifyPolicyClasses(params: { message: string }): { classes: PolicyClass[] } {
-  const message = params.message.trim()
-  if (!message) return { classes: [] }
-
-  const classes: PolicyClass[] = []
-  for (const entry of POLICY_CLASS_PATTERNS) {
-    if (entry.patterns.some((pattern) => pattern.test(message))) {
-      classes.push(entry.className)
-    }
-  }
-
-  return { classes }
-}
-
-export function resolveReasoningProfile(params: {
-  message: string
-  forceDeep?: boolean
-  explicitProfile?: ReasoningProfileName
-}): ReasoningProfile {
-  if (params.explicitProfile) {
-    return REASONING_PROFILES[params.explicitProfile]
-  }
-
-  const text = params.message.trim()
-  if (!text) {
-    return REASONING_PROFILES.standard
-  }
-
-  let score = 0
-  if (text.length >= 700) score += 3
-  else if (text.length >= 350) score += 2
-  else if (text.length >= 180) score += 1
-
-  const numberedListCount = (text.match(/\n\s*\d+\./g) ?? []).length
-  if (numberedListCount >= 3) score += 2
-  else if (numberedListCount >= 1) score += 1
-
-  if (STRATEGIC_COMPLEXITY_PATTERNS.some((pattern) => pattern.test(text))) score += 2
-  if (CROSS_SOURCE_COMPLEXITY_PATTERNS.some((pattern) => pattern.test(text))) score += 2
-  if (params.forceDeep) score += 2
-  if (STANDARD_FLOOR_INTENT_PATTERNS.some((pattern) => pattern.test(text))) {
-    score += 3
-  }
-
-  if (score >= 7) return REASONING_PROFILES.deep
-  if (score >= 3) return REASONING_PROFILES.standard
-  return REASONING_PROFILES.fast
-}
-
-export function resolveMessageRoute(params: {
-  workstreamMode: 'direct' | 'group'
-  workstreamAgentId?: string
-  message: string
-}): MessageRoute {
-  if (params.workstreamMode === 'direct') {
-    return { type: 'direct', agents: [params.workstreamAgentId ?? getLeadAgentId()] }
-  }
-
-  const mentions = uniqueMentionOrder(params.message)
-  if (mentions.length > 0) {
-    return { type: 'mentions', agents: mentions }
-  }
-
-  return { type: 'group-default', agents: [getLeadAgentId()] }
-}