@lota-sdk/core 0.4.8 → 0.4.10

package/src/workers/organization-learning.worker.ts

@@ -1,31 +1,65 @@
 import type { SandboxedJob } from 'bullmq'
+import { Effect } from 'effect'
+import type { Context } from 'effect'
 
 import { serverLogger } from '../config/logger'
+import { effectTryPromise } from '../effect/helpers'
+import { DatabaseServiceTag, RuntimeAdaptersServiceTag, RuntimeConfigServiceTag } from '../effect/services'
 import type { OrganizationLearningJob } from '../queues/organization-learning.queue'
+import { LearnedSkillServiceTag } from '../services/learned-skill.service'
+import { MemoryServiceTag } from '../services/memory/memory.service'
+import { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
 import { initializeSandboxedWorkerRuntime } from './bootstrap'
 import { runRegularChatMemoryDigest } from './regular-chat-memory-digest.runner'
+import type { RegularChatDigestServices } from './regular-chat-memory-digest.runner'
 import { runSkillExtraction } from './skill-extraction.runner'
+import type { SkillExtractionServices } from './skill-extraction.runner'
 import { toSandboxedWorkerError } from './utils/sandbox-error'
 import { createTracedWorkerProcessor } from './worker-utils'
 
-await initializeSandboxedWorkerRuntime()
+const runtime = await initializeSandboxedWorkerRuntime()
+const resolve = <I, T>(tag: Context.Key<I, T>): Promise<T> => runtime.runPromise(Effect.service(tag))
+const regularChatDigestServices: RegularChatDigestServices = {
+  databaseService: await resolve(DatabaseServiceTag),
+  memoryService: await resolve(MemoryServiceTag),
+  socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
+  runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
+}
+const workerRuntimeConfig = await resolve(RuntimeConfigServiceTag)
+const skillExtractionServices: SkillExtractionServices = {
+  databaseService: await resolve(DatabaseServiceTag),
+  learnedSkillService: await resolve(LearnedSkillServiceTag),
+  socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
+  runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
+  embeddingModel: workerRuntimeConfig.aiGateway.embeddingModel,
+  openRouterApiKey: workerRuntimeConfig.aiGateway.openRouterApiKey,
+}
 
 // One sandboxed worker handles both organization-learning branches so the
 // queue can dispatch digest and skill jobs without separate worker images.
-const handler = async (job: SandboxedJob<OrganizationLearningJob>) => {
-  try {
-    if (job.data.kind === 'regular-chat-memory-digest') {
-      await runRegularChatMemoryDigest(job.data)
-      return
-    }
-    await runSkillExtraction(job.data)
-  } catch (error) {
-    const message =
-      job.data.kind === 'regular-chat-memory-digest' ? 'Regular chat memory digest failed' : 'Skill extraction failed'
-    const serialized = toSandboxedWorkerError(error, message)
-    serverLogger.error`${serialized.message}`
-    throw serialized
-  }
-}
+const handler = (job: SandboxedJob<OrganizationLearningJob>) =>
+  Effect.runPromise(
+    Effect.gen(function* () {
+      if (job.data.kind === 'regular-chat-memory-digest') {
+        const digestJob = job.data
+        return yield* effectTryPromise(() => runRegularChatMemoryDigest(digestJob, regularChatDigestServices))
+      }
+
+      const skillJob = job.data
+      return yield* effectTryPromise(() => runSkillExtraction(skillJob, skillExtractionServices))
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const message =
+            job.data.kind === 'regular-chat-memory-digest'
+              ? 'Regular chat memory digest failed'
+              : 'Skill extraction failed'
+          const serialized = toSandboxedWorkerError(error, message)
+          serverLogger.error`${serialized.message}`
+          return yield* Effect.fail(serialized)
+        }),
+      ),
+    ),
+  )
 
 export default createTracedWorkerProcessor('organization-learning', handler)

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

@@ -1,40 +1,40 @@
 import { isAgentName } from '../config/agent-defaults'
-import { compactWhitespace } from '../utils/string'
+import { compactWhitespace, readRecord, readString } from '../utils/string'
+import type { DigestMessage } from './utils/thread-message-query'
 
-interface DigestMessageForTranscript {
-  source: 'thread' | 'social'
-  sourceId: string
-  role: 'system' | 'user' | 'assistant'
-  parts: Array<Record<string, unknown>>
-  metadata?: Record<string, unknown>
-}
+type DigestMessageForTranscript = Pick<DigestMessage, 'source' | 'sourceId' | 'role' | 'parts' | 'metadata'>
+type DigestMessagePart = DigestMessageForTranscript['parts'][number]
 
-function normalizeFilePartMetadata(part: Record<string, unknown>): string | null {
+function normalizeFilePartMetadata(part: DigestMessagePart): string | null {
   if (part.type !== 'file') return null
+  const partRecord = readRecord(part)
+  if (!partRecord) return null
 
-  const filename = typeof part.filename === 'string' && part.filename.trim() ? part.filename.trim() : 'attachment'
-  const mediaType = typeof part.mediaType === 'string' && part.mediaType.trim() ? part.mediaType.trim() : 'unknown'
-  const storageKey = typeof part.storageKey === 'string' && part.storageKey.trim() ? part.storageKey.trim() : 'unknown'
+  const filename = readString(partRecord.filename) ?? 'attachment'
+  const mediaType = readString(partRecord.mediaType) ?? 'unknown'
+  const providerMetadata = readRecord(partRecord.providerMetadata)
+  const lotaMetadata = readRecord(providerMetadata?.lota)
+  const storageKey = readString(partRecord.storageKey) ?? readString(lotaMetadata?.attachmentStorageKey) ?? 'unknown'
   const sizeBytes =
-    typeof part.sizeBytes === 'number' && Number.isFinite(part.sizeBytes) && part.sizeBytes >= 0
-      ? Math.trunc(part.sizeBytes)
+    typeof partRecord.sizeBytes === 'number' && Number.isFinite(partRecord.sizeBytes) && partRecord.sizeBytes >= 0
+      ? Math.trunc(partRecord.sizeBytes)
       : null
 
   const sizeSegment = sizeBytes === null ? '' : `, sizeBytes=${sizeBytes}`
   return `${filename} (${mediaType}${sizeSegment}, storageKey=${storageKey})`
 }
 
-function extractAssistantLabel(message: DigestMessageForTranscript): string {
+function extractAssistantLabel(
+  message: DigestMessageForTranscript,
+  isKnownAgentName: (value: string) => boolean = isAgentName,
+): string {
   const metadataAgentId =
-    message.metadata && typeof message.metadata.agentId === 'string'
-      ? message.metadata.agentId.trim().toLowerCase()
-      : ''
-  if (metadataAgentId && isAgentName(metadataAgentId)) {
+    typeof message.metadata?.agentId === 'string' ? message.metadata.agentId.trim().toLowerCase() : ''
+  if (metadataAgentId && isKnownAgentName(metadataAgentId)) {
     return metadataAgentId
   }
 
-  const metadataAgentName =
-    message.metadata && typeof message.metadata.agentName === 'string' ? message.metadata.agentName.trim() : ''
+  const metadataAgentName = typeof message.metadata?.agentName === 'string' ? message.metadata.agentName.trim() : ''
   if (metadataAgentName) {
     return metadataAgentName
   }
@@ -42,12 +42,13 @@ function extractAssistantLabel(message: DigestMessageForTranscript): string {
   return 'assistant'
 }
 
-export function buildDigestTranscript(params: { messages: DigestMessageForTranscript[] }): {
-  transcript: string
-  involvedAgentNames: string[]
-} {
+export function buildDigestTranscript(params: {
+  messages: DigestMessageForTranscript[]
+  isKnownAgentName?: (value: string) => boolean
+}): { transcript: string; involvedAgentNames: string[] } {
   const lines: string[] = []
   const involvedAgentNames = new Set<string>()
+  const isKnownAgentName = params.isKnownAgentName ?? isAgentName
 
   for (const message of params.messages) {
     if (message.role !== 'user' && message.role !== 'assistant') continue
@@ -70,8 +71,8 @@ export function buildDigestTranscript(params: { messages: DigestMessageForTransc
       continue
     }
 
-    const assistantLabel = extractAssistantLabel(message)
-    if (isAgentName(assistantLabel)) {
+    const assistantLabel = extractAssistantLabel(message, isKnownAgentName)
+    if (isKnownAgentName(assistantLabel)) {
       involvedAgentNames.add(assistantLabel)
     }
 

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

@@ -1,21 +1,25 @@
+import { Effect, Schema } from 'effect'
+import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
 import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { effectTryPromise } from '../effect/helpers'
 import {
   clearRegularChatMemoryDigestDeduplicationKey,
   enqueueRegularChatMemoryDigest,
 } from '../queues/organization-learning.queue'
 import type { RegularChatMemoryDigestJob } from '../queues/organization-learning.queue'
 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 type { LotaRuntimeAdapters, LotaRuntimeBackgroundCursor } from '../runtime/runtime-extensions'
+import type { MemoryServiceTag } from '../services/memory/memory.service'
+import type { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
 import { createRegularChatMemoryDigestAgent } from '../system-agents/regular-chat-memory-digest.agent'
+import { nowIsoDateTimeString } from '../utils/date-time'
 import { compactWhitespace } from '../utils/string'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
 import {
@@ -24,15 +28,26 @@ import {
   listThreadIdsForOrg,
   normalizeBlock,
 } from './utils/thread-message-query'
-import type { DigestCursor, DigestMessage } from './utils/thread-message-query'
+import type { DigestMessage } from './utils/thread-message-query'
 
 // Onboarding extracts memory immediately inside the turn flow. This delayed
 // runner handles the regular-chat path after onboarding so longer transcripts
 // can be digested into durable memory and profile projections in the background.
 const StructuredProfilePatchSchema = z.record(z.string(), z.unknown()).default({})
 
+class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('MemoryDigestError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
 const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
+export interface RegularChatDigestServices {
+  databaseService: SurrealDBService
+  memoryService: Context.Service.Shape<typeof MemoryServiceTag>
+  socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
+  runtimeAdapters: LotaRuntimeAdapters
+}
 
 const ExtractedFactSchema = z.object({
   content: z.string().trim().min(1),
@@ -96,109 +111,124 @@ function buildPrompt(params: {
   ].join('\n')
 }
 
-function getLastCursor(messages: DigestMessage[]): DigestCursor | null {
+function getLastCursor(messages: DigestMessage[]): LotaRuntimeBackgroundCursor | null {
   return messages.length > 0 ? messages[messages.length - 1].cursor : null
 }
 
-async function hasNewEligibleThreadMessages(params: {
+function hasNewEligibleThreadMessages(params: {
+  db: SurrealDBService
   threadIds: RecordIdRef[]
-  cursor: DigestCursor | null
+  cursor: LotaRuntimeBackgroundCursor | null
   onboardingCutoff: Date | null
 }): Promise<boolean> {
-  if (params.threadIds.length === 0) return false
-
-  let query: BoundQuery | null = null
-  if (params.cursor) {
-    const cursorRowId = ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE)
-    query = new BoundQuery(
-      `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
-       WHERE threadId IN $threadIds
-         AND (
-           createdAt > $cursorCreatedAt
-           OR (createdAt = $cursorCreatedAt AND id > $cursorRowId)
-         )
-       ORDER BY createdAt ASC, id ASC
-       LIMIT 1`,
-      { threadIds: params.threadIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
-    )
-  } else if (params.onboardingCutoff) {
-    query = new BoundQuery(
-      `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
-       WHERE threadId IN $threadIds
-         AND createdAt > $onboardingCutoff
-       ORDER BY createdAt ASC, id ASC
-       LIMIT 1`,
-      { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
-    )
-  }
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      if (params.threadIds.length === 0) return false
+
+      const query: BoundQuery | null = params.cursor
+        ? new BoundQuery(
+            `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+           WHERE threadId IN $threadIds
+             AND (
+               createdAt > $cursorCreatedAt
+               OR (createdAt = $cursorCreatedAt AND id > $cursorRowId)
+             )
+           ORDER BY createdAt ASC, id ASC
+           LIMIT 1`,
+            {
+              threadIds: params.threadIds,
+              cursorCreatedAt: params.cursor.createdAt,
+              cursorRowId: ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE),
+            },
+          )
+        : params.onboardingCutoff
+          ? new BoundQuery(
+              `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+           WHERE threadId IN $threadIds
+             AND createdAt > $onboardingCutoff
+           ORDER BY createdAt ASC, id ASC
+           LIMIT 1`,
+              { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
+            )
+          : null
 
-  if (!query) return false
-  const rows = await databaseService.query<unknown>(query)
-  return rows.length > 0
+      if (!query) return false
+      const rows = yield* effectTryPromise(() => params.db.query<unknown>(query))
+      return rows.length > 0
+    }),
+  )
 }
 
-async function loadExistingOrganizationMemories(orgId: string): Promise<Array<{ content: string }>> {
-  return databaseService.queryMany(
-    new BoundQuery(
-      `SELECT content, createdAt, id FROM ${TABLES.MEMORY}
-       WHERE metadata.orgId = $orgId
-         AND archivedAt IS NONE
-         AND (validUntil IS NONE OR validUntil > time::now())
-       ORDER BY createdAt DESC, id DESC
-      LIMIT 250`,
-      { orgId },
+function loadExistingOrganizationMemories(db: SurrealDBService, orgId: string): Promise<Array<{ content: string }>> {
+  return Effect.runPromise(
+    effectTryPromise(() =>
+      db.queryMany(
+        new BoundQuery(
+          `SELECT content, createdAt, id FROM ${TABLES.MEMORY}
+           WHERE metadata.orgId = $orgId
+             AND archivedAt IS NONE
+             AND (validUntil IS NONE OR validUntil > time::now())
+           ORDER BY createdAt DESC, id DESC
+          LIMIT 250`,
+          { orgId },
+        ),
+        WorkspaceMemoryRowSchema,
+      ),
     ),
-    WorkspaceMemoryRowSchema,
   )
 }
 
-export async function runRegularChatMemoryDigest(
-  data: RegularChatMemoryDigestJob,
-): Promise<RegularChatDigestRunResult> {
-  const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
-  const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
-  const workspaceProvider = getRuntimeAdapters().workspaceProvider
-  if (!workspaceProvider) {
-    serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
-    return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
-  }
-
-  return withConfiguredWorkspaceMemoryLock(orgId, async () => {
-    if (
-      !workspaceProvider.getBackgroundCursor ||
-      !workspaceProvider.setBackgroundCursor ||
-      !workspaceProvider.applyProfileProjection
-    ) {
+function runRegularChatMemoryDigestEffect(
+  services: RegularChatDigestServices,
+  orgRef: RecordIdRef,
+  orgId: string,
+  workspaceProvider: NonNullable<LotaRuntimeAdapters['workspaceProvider']>,
+) {
+  return Effect.gen(function* () {
+    const getBackgroundCursor = workspaceProvider.getBackgroundCursor?.bind(workspaceProvider)
+    const setBackgroundCursor = workspaceProvider.setBackgroundCursor?.bind(workspaceProvider)
+    const applyProfileProjection = workspaceProvider.applyProfileProjection?.bind(workspaceProvider)
+    if (!getBackgroundCursor || !setBackgroundCursor || !applyProfileProjection) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider background/profile methods are incomplete`
       return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const workspace = await workspaceProvider.getWorkspace(orgRef)
-    const lifecycleState = await workspaceProvider.getLifecycleState?.(workspace)
+    const workspace = yield* effectTryPromise(() => workspaceProvider.getWorkspace(orgRef))
+    const lifecycleState = workspaceProvider.getLifecycleState
+      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.getLifecycleState?.(workspace)))
+      : undefined
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: onboarding is not completed`
       return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
-    const projectionState = await workspaceProvider.readProfileProjectionState?.(workspace)
+    const projectionState = workspaceProvider.readProfileProjectionState
+      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.readProfileProjectionState?.(workspace)))
+      : undefined
 
-    const existingThreadCursor = await workspaceProvider.getBackgroundCursor('regular-chat-digest', orgRef)
+    const existingThreadCursor = yield* effectTryPromise(() => getBackgroundCursor('regular-chat-digest', orgRef))
     const threadOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingThreadCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const threadIds = await listThreadIdsForOrg(orgRef)
-    const threadMessages = await listEligibleThreadMessages({
-      threadIds,
-      cursor: existingThreadCursor,
-      onboardingCutoff: threadOnboardingCutoff,
-    })
-    const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('regular-chat-digest', orgId)
+    const threadIds = yield* effectTryPromise(() => listThreadIdsForOrg(services.databaseService, orgRef))
+    const threadMessages = yield* effectTryPromise(() =>
+      listEligibleThreadMessages({
+        db: services.databaseService,
+        threadIds,
+        cursor: existingThreadCursor,
+        onboardingCutoff: threadOnboardingCutoff,
+      }),
+    )
+    const existingSocialCursor = yield* services.socialChatHistoryService.getBackgroundCursor(
+      'regular-chat-digest',
+      orgId,
+    )
     const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingSocialCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
-    const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
+    const socialMessages = yield* services.socialChatHistoryService.listWorkspaceMessages({
       workspaceId: orgId,
       cursor: existingSocialCursor,
       onboardingCutoff: socialOnboardingCutoff,
@@ -211,38 +241,45 @@ export async function runRegularChatMemoryDigest(
 
     const combinedMessages = [...threadMessages, ...socialMessages].sort(compareDigestMessageOrder)
     const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
-    const existingMemories = await loadExistingOrganizationMemories(orgId)
-
-    const synthesis = await helperModelRuntime.generateHelperStructured({
-      tag: 'regular-chat-memory-digest',
-      createAgent: createRegularChatMemoryDigestAgent,
-      timeoutMs: REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS,
-      messages: [
-        {
-          role: 'user',
-          content: buildPrompt({
-            workspaceName: projectionState?.workspaceName || 'Workspace',
-            currentSummaryBlock: projectionState?.summaryBlock ?? '',
-            currentStructuredProfile: JSON.stringify(projectionState?.structuredProfile ?? {}, null, 2),
-            existingMemories: buildMemoryContext(existingMemories),
-            transcript,
-          }),
-        },
-      ],
-      schema: RegularChatMemoryDigestOutputSchema,
-    })
+    const existingMemories = yield* effectTryPromise(() =>
+      loadExistingOrganizationMemories(services.databaseService, orgId),
+    )
+
+    const synthesis = yield* effectTryPromise(() =>
+      helperModelRuntime.generateHelperStructured({
+        tag: 'regular-chat-memory-digest',
+        createAgent: createRegularChatMemoryDigestAgent,
+        timeoutMs: REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS,
+        messages: [
+          {
+            role: 'user',
+            content: buildPrompt({
+              workspaceName: projectionState?.workspaceName || 'Workspace',
+              currentSummaryBlock: projectionState?.summaryBlock ?? '',
+              currentStructuredProfile: JSON.stringify(projectionState?.structuredProfile ?? {}, null, 2),
+              existingMemories: buildMemoryContext(existingMemories),
+              transcript,
+            }),
+          },
+        ],
+        schema: RegularChatMemoryDigestOutputSchema,
+      }),
+    )
 
     const summaryBlock = normalizeBlock(synthesis.summaryBlock)
     if (!summaryBlock) {
-      throw new Error('Regular chat memory digest returned an empty summaryBlock')
+      return yield* new MemoryDigestError({
+        message: 'Regular chat memory digest returned an empty summaryBlock',
+        cause: new Error('Regular chat memory digest returned an empty summaryBlock'),
+      })
     }
 
     const processedThreadCursor = getLastCursor(threadMessages)
     const processedSocialCursor = getLastCursor(socialMessages)
-    const digestRunAt = new Date().toISOString()
+    const digestRunAt = nowIsoDateTimeString()
 
     if (synthesis.facts.length > 0) {
-      await memoryService.addExtractedFactsToScopes({
+      yield* services.memoryService.addExtractedFactsToScopes({
         orgId,
         facts: synthesis.facts,
         source: 'regular_chat_digest',
@@ -266,25 +303,27 @@ export async function runRegularChatMemoryDigest(
       })
     }
 
-    await workspaceProvider.applyProfileProjection(orgRef, {
-      summaryBlock,
-      structuredPatch: synthesis.structuredProfilePatch,
-    })
+    yield* effectTryPromise(() =>
+      applyProfileProjection(orgRef, { summaryBlock, structuredPatch: synthesis.structuredProfilePatch }),
+    )
     if (processedThreadCursor) {
-      await workspaceProvider.setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor)
+      yield* effectTryPromise(() => setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor))
     }
     if (processedSocialCursor) {
-      await socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
+      yield* services.socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
     }
 
     const threadBoundaryCursor = processedThreadCursor ?? existingThreadCursor
-    const hasMoreThreadMessages = await hasNewEligibleThreadMessages({
-      threadIds,
-      cursor: threadBoundaryCursor,
-      onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
-    })
+    const hasMoreThreadMessages = yield* effectTryPromise(() =>
+      hasNewEligibleThreadMessages({
+        db: services.databaseService,
+        threadIds,
+        cursor: threadBoundaryCursor,
+        onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
+      }),
+    )
     const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
-    const hasMoreSocialMessages = await socialChatHistoryService.hasWorkspaceMessages({
+    const hasMoreSocialMessages = yield* services.socialChatHistoryService.hasWorkspaceMessages({
       workspaceId: orgId,
       cursor: socialBoundaryCursor,
       onboardingCutoff: socialBoundaryCursor ? null : socialOnboardingCutoff,
@@ -292,8 +331,8 @@ export async function runRegularChatMemoryDigest(
 
     const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
-      await clearRegularChatMemoryDigestDeduplicationKey(orgId)
-      await enqueueRegularChatMemoryDigest({ orgId })
+      yield* effectTryPromise(() => clearRegularChatMemoryDigestDeduplicationKey(orgId))
+      yield* effectTryPromise(() => enqueueRegularChatMemoryDigest({ orgId }))
     }
 
     serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
@@ -306,3 +345,35 @@ export async function runRegularChatMemoryDigest(
     }
   })
 }
+
+export function runRegularChatMemoryDigest(
+  data: RegularChatMemoryDigestJob,
+  services: RegularChatDigestServices,
+): Promise<RegularChatDigestRunResult> {
+  const { databaseService, memoryService, socialChatHistoryService, runtimeAdapters } = services
+  const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
+  const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
+  const workspaceProvider = runtimeAdapters.workspaceProvider
+  if (!workspaceProvider) {
+    serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
+    return Promise.resolve({
+      skipped: true,
+      processedThreadMessages: 0,
+      processedSocialMessages: 0,
+      followUpScheduled: false,
+    })
+  }
+
+  const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
+  const runDigest = () =>
+    Effect.runPromise(
+      runRegularChatMemoryDigestEffect(
+        { databaseService, memoryService, socialChatHistoryService, runtimeAdapters },
+        orgRef,
+        orgId,
+        workspaceProvider,
+      ),
+    )
+
+  return withMemoryLock ? withMemoryLock(orgId, runDigest) : runDigest()
+}