@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -1,8 +1,9 @@
-import { Effect, Schema } from 'effect'
+import { Cause, Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
@@ -10,7 +11,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { effectTryPromise } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import type {
   OrganizationLearningQueueRuntime,
   RegularChatMemoryDigestJob,
@@ -19,7 +20,7 @@ import { createHelperModelRuntime } from '../runtime/helper-model'
 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 { makeRegularChatMemoryDigestAgentFactory } 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'
@@ -35,8 +36,9 @@ import type { DigestMessage } from './utils/thread-message-query'
 // 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({})
+const encodeJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Json))
 
-class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('MemoryDigestError', {
+class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()(ERROR_TAGS.MemoryDigestError, {
   message: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -45,6 +47,7 @@ const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
 export interface RegularChatDigestServices {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   databaseService: SurrealDBService
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
@@ -156,7 +159,9 @@ function hasNewEligibleThreadMessages(params: {
           : null
 
       if (!query) return false
-      const rows = yield* effectTryPromise(() => params.db.query<unknown>(query))
+      const rows = yield* params.db
+        .query<unknown>(query)
+        .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
       return rows.length > 0
     }),
   )
@@ -164,20 +169,20 @@ function hasNewEligibleThreadMessages(params: {
 
 function loadExistingOrganizationMemories(db: SurrealDBService, orgId: string): Promise<Array<{ content: string }>> {
   return Effect.runPromise(
-    effectTryPromise(() =>
-      db.queryMany(
+    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`,
+         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,
-      ),
-    ),
+      )
+      .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause))),
   )
 }
 
@@ -196,33 +201,50 @@ function runRegularChatMemoryDigestEffect(
       return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const workspace = yield* effectTryPromise(() => workspaceProvider.getWorkspace(orgRef))
+    const workspace = yield* Effect.tryPromise({
+      try: () => workspaceProvider.getWorkspace(orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const lifecycleState = workspaceProvider.getLifecycleState
-      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.getLifecycleState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(workspaceProvider.getLifecycleState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : 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 = workspaceProvider.readProfileProjectionState
-      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.readProfileProjectionState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(workspaceProvider.readProfileProjectionState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
 
-    const existingThreadCursor = yield* effectTryPromise(() => getBackgroundCursor('regular-chat-digest', orgRef))
+    const existingThreadCursor = yield* Effect.tryPromise({
+      try: () => getBackgroundCursor('regular-chat-digest', orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const threadOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingThreadCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const threadIds = yield* effectTryPromise(() => listThreadIdsForOrg(services.databaseService, orgRef))
-    const threadMessages = yield* effectTryPromise(() =>
-      listEligibleThreadMessages({
-        db: services.databaseService,
-        threadIds,
-        cursor: existingThreadCursor,
-        onboardingCutoff: threadOnboardingCutoff,
-      }),
-    )
+    const threadIds = yield* Effect.tryPromise({
+      try: () => listThreadIdsForOrg(services.databaseService, orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const threadMessages = yield* Effect.tryPromise({
+      try: () =>
+        listEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: existingThreadCursor,
+          onboardingCutoff: threadOnboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const existingSocialCursor = yield* services.socialChatHistoryService.getBackgroundCursor(
       'regular-chat-digest',
       orgId,
@@ -247,30 +269,36 @@ function runRegularChatMemoryDigestEffect(
       messages: combinedMessages,
       isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
     })
-    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 existingMemories = yield* Effect.tryPromise({
+      try: () => loadExistingOrganizationMemories(services.databaseService, orgId),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const currentStructuredProfile = yield* Schema.decodeUnknownEffect(Schema.Json)(
+      projectionState?.structuredProfile ?? {},
+    ).pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
+
+    const synthesis = yield* Effect.tryPromise({
+      try: () =>
+        helperModelRuntime.generateHelperStructured({
+          tag: 'regular-chat-memory-digest',
+          createAgent: makeRegularChatMemoryDigestAgentFactory(services.aiGatewayModels),
+          timeoutMs: REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS,
+          messages: [
+            {
+              role: 'user',
+              content: buildPrompt({
+                workspaceName: projectionState?.workspaceName || 'Workspace',
+                currentSummaryBlock: projectionState?.summaryBlock ?? '',
+                currentStructuredProfile: encodeJsonString(currentStructuredProfile),
+                existingMemories: buildMemoryContext(existingMemories),
+                transcript,
+              }),
+            },
+          ],
+          schema: RegularChatMemoryDigestOutputSchema,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const summaryBlock = normalizeBlock(synthesis.summaryBlock)
     if (!summaryBlock) {
@@ -309,25 +337,31 @@ function runRegularChatMemoryDigestEffect(
       })
     }
 
-    yield* effectTryPromise(() =>
-      applyProfileProjection(orgRef, { summaryBlock, structuredPatch: synthesis.structuredProfilePatch }),
-    )
+    yield* Effect.tryPromise({
+      try: () => applyProfileProjection(orgRef, { summaryBlock, structuredPatch: synthesis.structuredProfilePatch }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     if (processedThreadCursor) {
-      yield* effectTryPromise(() => setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor))
+      yield* Effect.tryPromise({
+        try: () => setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
     if (processedSocialCursor) {
       yield* services.socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
     }
 
     const threadBoundaryCursor = processedThreadCursor ?? existingThreadCursor
-    const hasMoreThreadMessages = yield* effectTryPromise(() =>
-      hasNewEligibleThreadMessages({
-        db: services.databaseService,
-        threadIds,
-        cursor: threadBoundaryCursor,
-        onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
-      }),
-    )
+    const hasMoreThreadMessages = yield* Effect.tryPromise({
+      try: () =>
+        hasNewEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: threadBoundaryCursor,
+          onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
     const hasMoreSocialMessages = yield* services.socialChatHistoryService.hasWorkspaceMessages({
       workspaceId: orgId,
@@ -337,10 +371,14 @@ function runRegularChatMemoryDigestEffect(
 
     const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
-      yield* effectTryPromise(() =>
-        services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
-      )
-      yield* effectTryPromise(() => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }))
+      yield* Effect.tryPromise({
+        try: () => services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
+      yield* Effect.tryPromise({
+        try: () => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
 
     serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`

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

@@ -1,6 +1,7 @@
-import type { Context, Cause } from 'effect'
-import { Effect } from 'effect'
+import { Cause, Effect } from 'effect'
+import type { Context } from 'effect'
 
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
@@ -8,16 +9,15 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { effectTryPromise } from '../effect/helpers'
 import { ProviderEmbeddings } from '../embeddings/provider'
 import type { SkillExtractionJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import type { LotaRuntimeAdapters } from '../runtime/runtime-extensions'
 import type { LearnedSkillServiceTag } from '../services/learned-skill.service'
 import type { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
-import { createSkillExtractorAgent, SkillExtractionOutputSchema } from '../system-agents/skill-extractor.agent'
+import { makeSkillExtractorAgentFactory, 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'
+import { makeSkillManagerAgentFactory, SkillManagerOutputSchema } from '../system-agents/skill-manager.agent'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
 import {
   compareDigestMessageOrder,
@@ -30,12 +30,14 @@ const MIN_MESSAGE_THRESHOLD = 10
 
 export interface SkillExtractionServices {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   databaseService: SurrealDBService
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
   runtimeAdapters: LotaRuntimeAdapters
   embeddingModel: string
   openRouterApiKey?: string
+  runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>
 }
 
 interface SkillExtractionRunResult {
@@ -110,21 +112,31 @@ function runSkillExtractionEffect(
   return Effect.gen(function* () {
     const getBackgroundCursor = cursorAwareWorkspaceProvider.getBackgroundCursor.bind(cursorAwareWorkspaceProvider)
     const setBackgroundCursor = cursorAwareWorkspaceProvider.setBackgroundCursor.bind(cursorAwareWorkspaceProvider)
-    const workspace = yield* effectTryPromise(() => cursorAwareWorkspaceProvider.getWorkspace(orgRef))
+    const workspace = yield* Effect.tryPromise({
+      try: () => cursorAwareWorkspaceProvider.getWorkspace(orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const lifecycleState = cursorAwareWorkspaceProvider.getLifecycleState
-      ? yield* effectTryPromise(() => Promise.resolve(cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping skill extraction for ${orgId}: onboarding is not completed`
       return { skipped: true, processedMessages: 0, extractedSkills: 0 }
     }
     const projectionState = cursorAwareWorkspaceProvider.readProfileProjectionState
-      ? yield* effectTryPromise(() =>
-          Promise.resolve(cursorAwareWorkspaceProvider.readProfileProjectionState?.(workspace)),
-        )
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(cursorAwareWorkspaceProvider.readProfileProjectionState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
 
-    const existingCursor = yield* effectTryPromise(() => getBackgroundCursor('skill-extraction', orgRef))
+    const existingCursor = yield* Effect.tryPromise({
+      try: () => getBackgroundCursor('skill-extraction', orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const onboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
@@ -135,10 +147,20 @@ function runSkillExtractionEffect(
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const threadIds = yield* effectTryPromise(() => listThreadIdsForOrg(services.databaseService, orgRef))
-    const threadMessages = yield* effectTryPromise(() =>
-      listEligibleThreadMessages({ db: services.databaseService, threadIds, cursor: existingCursor, onboardingCutoff }),
-    )
+    const threadIds = yield* Effect.tryPromise({
+      try: () => listThreadIdsForOrg(services.databaseService, orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const threadMessages = yield* Effect.tryPromise({
+      try: () =>
+        listEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: existingCursor,
+          onboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const socialMessages = yield* services.socialChatHistoryService.listWorkspaceMessages({
       workspaceId: orgId,
       cursor: existingSocialCursor,
@@ -163,24 +185,26 @@ function runSkillExtractionEffect(
         ? existingSkills.map((skill, i) => `${i + 1}. ${skill.name}: ${skill.description}`).join('\n')
         : 'None'
 
-    const extraction = yield* effectTryPromise(() =>
-      helperModelRuntime.generateHelperStructured({
-        tag: 'skill-extraction',
-        createAgent: createSkillExtractorAgent,
-        timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
-        messages: [
-          {
-            role: 'user',
-            content: buildExtractionPrompt({
-              workspaceName: projectionState?.workspaceName || 'Workspace',
-              transcript,
-              existingSkills: existingSkillsSummary,
-            }),
-          },
-        ],
-        schema: SkillExtractionOutputSchema,
-      }),
-    )
+    const extraction = yield* Effect.tryPromise({
+      try: () =>
+        helperModelRuntime.generateHelperStructured({
+          tag: 'skill-extraction',
+          createAgent: makeSkillExtractorAgentFactory(services.aiGatewayModels),
+          timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
+          messages: [
+            {
+              role: 'user',
+              content: buildExtractionPrompt({
+                workspaceName: projectionState?.workspaceName || 'Workspace',
+                transcript,
+                existingSkills: existingSkillsSummary,
+              }),
+            },
+          ],
+          schema: SkillExtractionOutputSchema,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const skillCandidates = extraction.candidates.filter((c) => c.classification === 'skill')
 
@@ -195,37 +219,42 @@ function runSkillExtractionEffect(
 
         const mostSimilar = yield* services.learnedSkillService.findMostSimilar(orgId, candidate.description)
 
-        const managerResult = yield* effectTryPromise(() =>
-          helperModelRuntime.generateHelperStructured({
-            tag: 'skill-manager',
-            createAgent: createSkillManagerAgent,
-            timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
-            messages: [
-              {
-                role: 'user',
-                content: buildManagerPrompt({
-                  candidate,
-                  existingSkill: mostSimilar
-                    ? {
-                        name: mostSimilar.name,
-                        description: mostSimilar.description,
-                        instructions: mostSimilar.instructions,
-                        version: mostSimilar.version,
-                      }
-                    : null,
-                }),
-              },
-            ],
-            schema: SkillManagerOutputSchema,
-          }),
-        )
+        const managerResult = yield* Effect.tryPromise({
+          try: () =>
+            helperModelRuntime.generateHelperStructured({
+              tag: 'skill-manager',
+              createAgent: makeSkillManagerAgentFactory(services.aiGatewayModels),
+              timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
+              messages: [
+                {
+                  role: 'user',
+                  content: buildManagerPrompt({
+                    candidate,
+                    existingSkill: mostSimilar
+                      ? {
+                          name: mostSimilar.name,
+                          description: mostSimilar.description,
+                          instructions: mostSimilar.instructions,
+                          version: mostSimilar.version,
+                        }
+                      : null,
+                  }),
+                },
+              ],
+              schema: SkillManagerOutputSchema,
+            }),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
 
         if (managerResult.decision === 'discard') {
           serverLogger.info`Discarding skill candidate ${candidate.name}: ${managerResult.reason}`
           return 0
         }
 
-        const embedding = yield* effectTryPromise(() => embeddings.embedQuery(candidate.description))
+        const embedding = yield* Effect.tryPromise({
+          try: () => embeddings.embedQuery(candidate.description),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
         if (embedding.length === 0) {
           serverLogger.warn`Skipping skill candidate ${candidate.name}: empty embedding`
           return 0
@@ -253,7 +282,10 @@ function runSkillExtractionEffect(
         if (mostSimilar && managerResult.mergedSkill) {
           const merged = managerResult.mergedSkill
           const mergedHash = services.learnedSkillService.generateHash(merged.description, merged.instructions)
-          const mergedEmbedding = yield* effectTryPromise(() => embeddings.embedQuery(merged.description))
+          const mergedEmbedding = yield* Effect.tryPromise({
+            try: () => embeddings.embedQuery(merged.description),
+            catch: (cause) => new Cause.UnknownError(cause),
+          })
 
           yield* services.learnedSkillService.update(mostSimilar.id, {
             name: merged.name,
@@ -291,7 +323,10 @@ function runSkillExtractionEffect(
     const lastThreadMessage = threadMessages.at(-1)
     const lastSocialMessage = socialMessages.at(-1)
     if (lastThreadMessage) {
-      yield* effectTryPromise(() => setBackgroundCursor('skill-extraction', orgRef, lastThreadMessage.cursor))
+      yield* Effect.tryPromise({
+        try: () => setBackgroundCursor('skill-extraction', orgRef, lastThreadMessage.cursor),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
     if (lastSocialMessage) {
       yield* services.socialChatHistoryService.setBackgroundCursor('skill-extraction', orgId, lastSocialMessage.cursor)
@@ -319,10 +354,11 @@ export function runSkillExtraction(
   const embeddings = new ProviderEmbeddings({
     modelId: services.embeddingModel,
     openRouterApiKey: services.openRouterApiKey,
+    runPromise: services.runPromise,
   })
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runExtraction = () =>
-    Effect.runPromise(
+    services.runPromise(
       runSkillExtractionEffect(services, orgRef, orgId, workspaceProvider, embeddings) as Effect.Effect<
         SkillExtractionRunResult,
         never,

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

@@ -6,10 +6,8 @@ import type {
   RepositoryStructureSignal,
   RepositoryStructureSummary,
 } from '@lota-sdk/shared'
-import type { Cause } from 'effect'
-import { Effect } from 'effect'
+import { Cause, Effect } from 'effect'
 
-import { effectTryPromise } from '../../effect/helpers'
 import { nowIsoDateTimeString } from '../../utils/date-time'
 
 const EXTRACTOR_VERSION = 'repository-structure-extractor.v1'
@@ -152,14 +150,18 @@ function collectRelativeFilePathsEffect(
 ): Effect.Effect<string[], Cause.UnknownError, never> {
   return Effect.gen(function* () {
     const absoluteDir = currentDir ? joinPath(rootDir, currentDir) : rootDir
-    const entries = yield* effectTryPromise(() =>
-      Array.fromAsync(new Bun.Glob('*').scan({ cwd: absoluteDir, onlyFiles: false, absolute: false })),
-    )
+    const entries = yield* Effect.tryPromise({
+      try: () => Array.fromAsync(new Bun.Glob('*').scan({ cwd: absoluteDir, onlyFiles: false, absolute: false })),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const filePaths: string[] = []
     for (const entry of entries) {
       const relativePath = currentDir ? joinPath(currentDir, entry) : normalizePath(entry)
-      const stats = yield* effectTryPromise(() => Bun.file(joinPath(rootDir, relativePath)).stat())
+      const stats = yield* Effect.tryPromise({
+        try: () => Bun.file(joinPath(rootDir, relativePath)).stat(),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
 
       if (stats.isDirectory()) {
         if (IGNORED_DIR_NAMES.has(entry)) continue
@@ -179,7 +181,10 @@ function readPackageJsonEffect(
   rootDir: string,
   relativePath: string,
 ): Effect.Effect<PackageJson | null, Cause.UnknownError, never> {
-  return effectTryPromise(() => Bun.file(joinPath(rootDir, relativePath)).text()).pipe(
+  return Effect.tryPromise({
+    try: () => Bun.file(joinPath(rootDir, relativePath)).text(),
+    catch: (cause) => new Cause.UnknownError(cause),
+  }).pipe(
     Effect.map((raw) => {
       try {
         const parsed: unknown = JSON.parse(raw)