@lota-sdk/core 0.4.10 → 0.4.12

package/src/tools/team-think.tool.ts

@@ -3,16 +3,20 @@ import { stepCountIs } from 'ai'
 import type { ToolSet } from 'ai'
 import { Schema, Effect } from 'effect'
 
-import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../config/agent-defaults'
 import { aiLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { effectTryMaybeAsync as effectTryMaybeAsyncShared } from '../effect/helpers'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  RuntimeAdaptersServiceTag,
+  TurnHooksServiceTag,
+} from '../effect/services'
 import { readRuntimeAgentIdentityOverrides } from '../runtime/agent-identity-overrides'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
-import { getRuntimeAdapters, getTurnHooks } from '../runtime/runtime-extensions'
-import type { LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensions'
+import type { LotaRuntimeAdapters, LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensions'
 import { createConsultTeamTool as createConsultTeamToolSdk } from '../runtime/team-consultation/team-consultation-orchestrator'
 import type {
   DefaultRepoSections,
@@ -24,8 +28,9 @@ import type { ReadableUploadMetadata } from '../services/attachment.service'
 
 function buildTeamThinkAgentToolsEffect(
   params: LotaRuntimeTeamThinkToolsParams,
+  runtimeAdapters: LotaRuntimeAdapters,
 ): Effect.Effect<{ tools: ToolSet }, TeamThinkRuntimeError> {
-  const builder = getRuntimeAdapters().buildTeamThinkAgentTools
+  const builder = runtimeAdapters.buildTeamThinkAgentTools
   if (!builder) {
     return Effect.succeed({ tools: {} })
   }
@@ -72,124 +77,137 @@ export function createTeamThinkTool(params: {
   toolProviders?: ToolSet
   abortSignal: AbortSignal
 }) {
-  const agentIdentityOverrides = readRuntimeAgentIdentityOverrides(
-    (params.context as Record<string, unknown> | null | undefined) ?? null,
-  )
-  const participantRunner: TeamConsultationParticipantRunner = {
-    buildParticipantAgent(agentId, runParams) {
-      return Effect.runPromise(
-        Effect.gen(function* () {
-          const currentContext = yield* Effect.context()
-          const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
-          const dynamicInstructionSections = yield* effectTryMaybeAsync(
-            () => params.getAdditionalInstructionSections?.(),
-            'Failed to load dynamic team-think instruction sections.',
-          )
-          const agentResolution = asRecord(
-            yield* effectTryMaybeAsync(
-              () =>
-                getTurnHooks().resolveAgent?.({
-                  agentId,
-                  mode: 'fixedThreadMode',
-                  thread: null,
-                  threadRef: params.threadId,
-                  orgRef: params.orgId,
-                  userRef: params.userId,
-                  onboardingActive: false,
-                  linearInstalled: false,
-                  githubInstalled: params.githubInstalled,
-                  additionalInstructionSections: mergeInstructionSections(
-                    dynamicInstructionSections,
-                    params.additionalInstructionSections,
-                  ),
-                  context: (params.context as Record<string, unknown> | null | undefined) ?? null,
-                }),
-              'Failed to resolve team-think participant agent.',
-            ),
-          )
-          const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
-          const config = getAgentRuntimeConfig({
-            agentId: resolvedAgentId,
-            threadType: 'group' as const,
-            mode: 'fixedThreadMode',
-            onboardingActive: false,
-            linearInstalled: false,
-            systemWorkspaceDetails: runParams.systemWorkspaceDetails,
-            preSeededMemoriesSection: runParams.preSeededMemoriesSection,
-            retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
-            additionalInstructionSections: mergeInstructionSections(
-              dynamicInstructionSections,
-              params.additionalInstructionSections,
-              readInstructionSections(agentResolution?.additionalInstructionSections),
-            ),
-            responseGuardSection: buildTeamConsultationResponseGuard({
+  return Effect.gen(function* () {
+    const turnHooks = yield* TurnHooksServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    const agentConfig = yield* AgentConfigServiceTag
+    const agentFactoryConfig = yield* AgentFactoryServiceTag
+    const agentIdentityOverrides = readRuntimeAgentIdentityOverrides(
+      (params.context as Record<string, unknown> | null | undefined) ?? null,
+    )
+    const participantRunner: TeamConsultationParticipantRunner = {
+      buildParticipantAgent(agentId, runParams) {
+        return Effect.runPromise(
+          Effect.gen(function* () {
+            const currentContext = yield* Effect.context()
+            const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+            const dynamicInstructionSections = yield* effectTryMaybeAsync(
+              () => params.getAdditionalInstructionSections?.(),
+              'Failed to load dynamic team-think instruction sections.',
+            )
+            const agentResolution = asRecord(
+              yield* effectTryMaybeAsync(
+                () =>
+                  turnHooks.resolveAgent?.({
+                    agentId,
+                    mode: 'fixedThreadMode',
+                    thread: null,
+                    threadRef: params.threadId,
+                    orgRef: params.orgId,
+                    userRef: params.userId,
+                    onboardingActive: false,
+                    linearInstalled: false,
+                    githubInstalled: params.githubInstalled,
+                    additionalInstructionSections: mergeInstructionSections(
+                      dynamicInstructionSections,
+                      params.additionalInstructionSections,
+                    ),
+                    context: (params.context as Record<string, unknown> | null | undefined) ?? null,
+                  }),
+                'Failed to resolve team-think participant agent.',
+              ),
+            )
+            const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
+            const config = agentFactoryConfig.getAgentRuntimeConfig({
               agentId: resolvedAgentId,
-              task: runParams.task,
-            }),
-          })
-          const { tools } = yield* buildTeamThinkAgentToolsEffect({
-            agentId: resolvedAgentId,
-            workspaceId: params.orgId,
-            userId: params.userId,
-            workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
-            threadId: params.threadId,
-            githubInstalled: params.githubInstalled,
-            provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
-            availableUploads: params.availableUploads,
-            defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
-            context: params.context,
-            toolProviders: params.toolProviders,
-          })
-          const agentId_ = config.id || resolvedAgentId
-          const configuredMaxSteps = config.maxSteps
-          const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
-          const agentFactory = getResolvedAgentFactoryConfig().createAgent[agentId_]
-          if (!agentFactory) {
-            return yield* new TeamThinkAgentFactoryNotConfiguredError({ agentId: agentId_ })
-          }
-          const agent = agentFactory({
-            mode: 'fixedThreadMode',
-            tools,
-            extraInstructions: config.extraInstructions,
-            maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
-            stopWhen: [stepCountIs(maxSteps)],
-          })
-          const observer = {
-            run: <T>(fn: () => T | Promise<T>): Promise<T> =>
-              runPromiseWithCurrentContext(effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`)),
-            recordError: (error: unknown) => {
-              aiLogger.error`Team-think participant failed (${agentId}): ${error}`
-            },
-            recordAbort: (error: unknown) => {
-              aiLogger.debug`Team-think participant aborted (${agentId}): ${
-                error instanceof Error ? error.message : String(error)
-              }`
-            },
-          }
-          return {
-            agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
-            observer,
-          }
-        }).pipe(Effect.withSpan('tool.teamThink.buildParticipantAgent')),
-      )
-    },
-  }
+              threadType: 'group' as const,
+              mode: 'fixedThreadMode',
+              onboardingActive: false,
+              linearInstalled: false,
+              systemWorkspaceDetails: runParams.systemWorkspaceDetails,
+              preSeededMemoriesSection: runParams.preSeededMemoriesSection,
+              retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
+              additionalInstructionSections: mergeInstructionSections(
+                dynamicInstructionSections,
+                params.additionalInstructionSections,
+                readInstructionSections(agentResolution?.additionalInstructionSections),
+              ),
+              responseGuardSection: buildTeamConsultationResponseGuard({
+                agentConfig,
+                agentId: resolvedAgentId,
+                task: runParams.task,
+              }),
+            })
+            const { tools } = yield* buildTeamThinkAgentToolsEffect(
+              {
+                agentId: resolvedAgentId,
+                workspaceId: params.orgId,
+                userId: params.userId,
+                workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
+                threadId: params.threadId,
+                githubInstalled: params.githubInstalled,
+                provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
+                availableUploads: params.availableUploads,
+                defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
+                context: params.context,
+                toolProviders: params.toolProviders,
+              },
+              runtimeAdapters,
+            )
+            const agentId_ = config.id || resolvedAgentId
+            const configuredMaxSteps = config.maxSteps
+            const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
+            const agentFactory = agentFactoryConfig.createAgent[agentId_]
+            if (!agentFactory) {
+              return yield* new TeamThinkAgentFactoryNotConfiguredError({ agentId: agentId_ })
+            }
+            const agent = agentFactory({
+              mode: 'fixedThreadMode',
+              tools,
+              extraInstructions: config.extraInstructions,
+              maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
+              stopWhen: [stepCountIs(maxSteps)],
+            })
+            const observer = {
+              run: <T>(fn: () => T | Promise<T>): Promise<T> =>
+                runPromiseWithCurrentContext(
+                  effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`),
+                ),
+              recordError: (error: unknown) => {
+                aiLogger.error`Team-think participant failed (${agentId}): ${error}`
+              },
+              recordAbort: (error: unknown) => {
+                aiLogger.debug`Team-think participant aborted (${agentId}): ${
+                  error instanceof Error ? error.message : String(error)
+                }`
+              },
+            }
+            return {
+              agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
+              observer,
+            }
+          }).pipe(Effect.withSpan('tool.teamThink.buildParticipantAgent')),
+        )
+      },
+    }
 
-  return createConsultTeamToolSdk({
-    historyMessages: params.historyMessages,
-    latestUserMessageId: params.latestUserMessageId,
-    availableUploads: params.availableUploads,
-    defaultRepoSectionsByAgent: params.defaultRepoSectionsByAgent,
-    systemWorkspaceDetails: params.systemWorkspaceDetails,
-    getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
-    retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-    displayNamesById: agentIdentityOverrides.displayNamesById,
-    abortSignal: params.abortSignal,
-    participantRunner,
-    onReadError: (agentId, error) => {
-      if (!(error instanceof Error && error.name === 'AbortError')) {
-        aiLogger.error`UI message read failed for team-think participant ${agentId}: ${error}`
-      }
-    },
+    return createConsultTeamToolSdk({
+      agentConfig,
+      historyMessages: params.historyMessages,
+      latestUserMessageId: params.latestUserMessageId,
+      availableUploads: params.availableUploads,
+      defaultRepoSectionsByAgent: params.defaultRepoSectionsByAgent,
+      systemWorkspaceDetails: params.systemWorkspaceDetails,
+      getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
+      retrievedKnowledgeSection: params.retrievedKnowledgeSection,
+      displayNamesById: agentIdentityOverrides.displayNamesById,
+      abortSignal: params.abortSignal,
+      participantRunner,
+      onReadError: (agentId, error) => {
+        if (!(error instanceof Error && error.name === 'AbortError')) {
+          aiLogger.error`UI message read failed for team-think participant ${agentId}: ${error}`
+        }
+      },
+    })
   })
 }

package/src/workers/bootstrap.ts

@@ -2,12 +2,11 @@ import { ConfigProvider, Option, Schema, Effect, Layer, ManagedRuntime, Redacted
 
 import { AiGatewayLive } from '../ai-gateway/ai-gateway'
 import { EmbeddingCacheLive } from '../ai/embedding-cache'
-import { configureLotaLogger, resolveLotaLogLevel, serverLogger } from '../config/logger'
+import { serverLogger } from '../config/logger'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
-import { buildWorkerInfrastructureLayer, setLotaSdkRuntime } from '../effect'
-import { DatabaseServiceTag } from '../effect/services'
+import { buildWorkerInfrastructureLayer } from '../effect'
+import { DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
 import { lotaRuntimeEnvConfig, parseLotaRuntimeConfig, parseWorkerBootstrapEnv } from '../runtime/runtime-config'
-import { getConfiguredPluginDatabaseConnector } from '../runtime/runtime-extensions'
 import { FirecrawlLive } from '../tools/firecrawl-client'
 import { getErrorMessage } from '../utils/errors'
 
@@ -85,7 +84,6 @@ function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime>
   sandboxedWorkerSetupPromise = Effect.runPromise(
     Effect.gen(function* () {
       const runtimeConfig = yield* buildSandboxedWorkerRuntimeConfigEffect()
-      yield* Effect.sync(() => configureLotaLogger(resolveLotaLogLevel(Bun.env.LOG_LEVEL) ?? 'info'))
 
       const infrastructureLayer = buildWorkerInfrastructureLayer(runtimeConfig)
 
@@ -95,10 +93,6 @@ function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime>
 
       const managedRuntime = ManagedRuntime.make(fullLayer)
 
-      yield* Effect.sync(() => {
-        setLotaSdkRuntime(managedRuntime)
-      })
-
       return managedRuntime
     }),
   ).catch((error) => {
@@ -137,11 +131,16 @@ export function initializeSandboxedWorkerRuntime(): Promise<WorkerManagedRuntime
         catch: (error) => toSandboxedWorkerBootstrapError('connect-db', error),
       })
 
+      const runtimeAdapters = yield* Effect.tryPromise({
+        try: () => runtime.runPromise(Effect.service(RuntimeAdaptersServiceTag)),
+        catch: (error) => toSandboxedWorkerBootstrapError('initialize', error),
+      })
+
       yield* Effect.tryPromise({
         try: () =>
           connectWithStartupRetry({
             connect: () => {
-              const connectPluginRuntimeDatabases = getConfiguredPluginDatabaseConnector()
+              const connectPluginRuntimeDatabases = runtimeAdapters.connectPluginDatabases
               return connectPluginRuntimeDatabases ? connectPluginRuntimeDatabases() : Promise.resolve()
             },
             label: 'sandboxed worker plugin database runtime',

package/src/workers/memory-consolidation.worker.ts

@@ -11,6 +11,7 @@ import { TABLES } from '../db/tables'
 import { effectTryPromise } from '../effect/helpers'
 import { DatabaseServiceTag } from '../effect/services'
 import type { MemoryConsolidationJob } from '../queues/memory-consolidation.queue'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { nowDate, unsafeDateFrom } from '../utils/date-time'
 import { getErrorMessage } from '../utils/errors'
 import { initializeSandboxedWorkerRuntime } from './bootstrap'
@@ -59,6 +60,8 @@ const memoryConsolidationDatabaseService: SurrealDBService = await runtime.runPr
   Effect.service(DatabaseServiceTag),
 )
 
+const memoryConsolidationQueueJobService = await runtime.runPromise(Effect.service(QueueJobServiceTag))
+
 function db(): SurrealDBService {
   return memoryConsolidationDatabaseService
 }
@@ -395,4 +398,4 @@ const handler = (job: SandboxedJob<MemoryConsolidationJob>) =>
     ),
   )
 
-export default createTracedWorkerProcessor('memory-consolidation', handler)
+export default createTracedWorkerProcessor('memory-consolidation', handler, memoryConsolidationQueueJobService)

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

@@ -4,10 +4,17 @@ import type { Context } from 'effect'
 
 import { serverLogger } from '../config/logger'
 import { effectTryPromise } from '../effect/helpers'
-import { DatabaseServiceTag, RuntimeAdaptersServiceTag, RuntimeConfigServiceTag } from '../effect/services'
+import {
+  AgentConfigServiceTag,
+  DatabaseServiceTag,
+  RuntimeAdaptersServiceTag,
+  RuntimeConfigServiceTag,
+} from '../effect/services'
 import type { OrganizationLearningJob } from '../queues/organization-learning.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { LearnedSkillServiceTag } from '../services/learned-skill.service'
 import { MemoryServiceTag } from '../services/memory/memory.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
 import { initializeSandboxedWorkerRuntime } from './bootstrap'
 import { runRegularChatMemoryDigest } from './regular-chat-memory-digest.runner'
@@ -19,14 +26,19 @@ import { createTracedWorkerProcessor } from './worker-utils'
 
 const runtime = await initializeSandboxedWorkerRuntime()
 const resolve = <I, T>(tag: Context.Key<I, T>): Promise<T> => runtime.runPromise(Effect.service(tag))
+const agentConfig = await resolve(AgentConfigServiceTag)
+const queues = await resolve(LotaQueuesServiceTag)
 const regularChatDigestServices: RegularChatDigestServices = {
+  agentConfig,
   databaseService: await resolve(DatabaseServiceTag),
   memoryService: await resolve(MemoryServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
   runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
+  organizationLearningQueue: queues.organizationLearning,
 }
 const workerRuntimeConfig = await resolve(RuntimeConfigServiceTag)
 const skillExtractionServices: SkillExtractionServices = {
+  agentConfig,
   databaseService: await resolve(DatabaseServiceTag),
   learnedSkillService: await resolve(LearnedSkillServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
@@ -34,6 +46,7 @@ const skillExtractionServices: SkillExtractionServices = {
   embeddingModel: workerRuntimeConfig.aiGateway.embeddingModel,
   openRouterApiKey: workerRuntimeConfig.aiGateway.openRouterApiKey,
 }
+const organizationLearningQueueJobService = await resolve(QueueJobServiceTag)
 
 // One sandboxed worker handles both organization-learning branches so the
 // queue can dispatch digest and skill jobs without separate worker images.
@@ -62,4 +75,4 @@ const handler = (job: SandboxedJob<OrganizationLearningJob>) =>
     ),
   )
 
-export default createTracedWorkerProcessor('organization-learning', handler)
+export default createTracedWorkerProcessor('organization-learning', handler, organizationLearningQueueJobService)

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

@@ -1,4 +1,3 @@
-import { isAgentName } from '../config/agent-defaults'
 import { compactWhitespace, readRecord, readString } from '../utils/string'
 import type { DigestMessage } from './utils/thread-message-query'
 
@@ -26,7 +25,7 @@ function normalizeFilePartMetadata(part: DigestMessagePart): string | null {
 
 function extractAssistantLabel(
   message: DigestMessageForTranscript,
-  isKnownAgentName: (value: string) => boolean = isAgentName,
+  isKnownAgentName: (value: string) => boolean,
 ): string {
   const metadataAgentId =
     typeof message.metadata?.agentId === 'string' ? message.metadata.agentId.trim().toLowerCase() : ''
@@ -44,11 +43,11 @@ function extractAssistantLabel(
 
 export function buildDigestTranscript(params: {
   messages: DigestMessageForTranscript[]
-  isKnownAgentName?: (value: string) => boolean
+  isKnownAgentName: (value: string) => boolean
 }): { transcript: string; involvedAgentNames: string[] } {
   const lines: string[] = []
   const involvedAgentNames = new Set<string>()
-  const isKnownAgentName = params.isKnownAgentName ?? isAgentName
+  const { isKnownAgentName } = params
 
   for (const message of params.messages) {
     if (message.role !== 'user' && message.role !== 'assistant') continue

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

@@ -3,17 +3,18 @@ import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 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 {
-  clearRegularChatMemoryDigestDeduplicationKey,
-  enqueueRegularChatMemoryDigest,
+import type {
+  OrganizationLearningQueueRuntime,
+  RegularChatMemoryDigestJob,
 } from '../queues/organization-learning.queue'
-import type { RegularChatMemoryDigestJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import type { LotaRuntimeAdapters, LotaRuntimeBackgroundCursor } from '../runtime/runtime-extensions'
 import type { MemoryServiceTag } from '../services/memory/memory.service'
@@ -43,10 +44,12 @@ class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('Me
 const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
 export interface RegularChatDigestServices {
+  agentConfig: ResolvedAgentConfig
   databaseService: SurrealDBService
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
   runtimeAdapters: LotaRuntimeAdapters
+  organizationLearningQueue: OrganizationLearningQueueRuntime
 }
 
 const ExtractedFactSchema = z.object({
@@ -240,7 +243,10 @@ function runRegularChatMemoryDigestEffect(
     }
 
     const combinedMessages = [...threadMessages, ...socialMessages].sort(compareDigestMessageOrder)
-    const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
+    const { transcript, involvedAgentNames } = buildDigestTranscript({
+      messages: combinedMessages,
+      isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
+    })
     const existingMemories = yield* effectTryPromise(() =>
       loadExistingOrganizationMemories(services.databaseService, orgId),
     )
@@ -331,8 +337,10 @@ function runRegularChatMemoryDigestEffect(
 
     const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
-      yield* effectTryPromise(() => clearRegularChatMemoryDigestDeduplicationKey(orgId))
-      yield* effectTryPromise(() => enqueueRegularChatMemoryDigest({ orgId }))
+      yield* effectTryPromise(() =>
+        services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
+      )
+      yield* effectTryPromise(() => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }))
     }
 
     serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
@@ -350,7 +358,7 @@ export function runRegularChatMemoryDigest(
   data: RegularChatMemoryDigestJob,
   services: RegularChatDigestServices,
 ): Promise<RegularChatDigestRunResult> {
-  const { databaseService, memoryService, socialChatHistoryService, runtimeAdapters } = services
+  const { runtimeAdapters } = services
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const workspaceProvider = runtimeAdapters.workspaceProvider
@@ -367,12 +375,11 @@ export function runRegularChatMemoryDigest(
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runDigest = () =>
     Effect.runPromise(
-      runRegularChatMemoryDigestEffect(
-        { databaseService, memoryService, socialChatHistoryService, runtimeAdapters },
-        orgRef,
-        orgId,
-        workspaceProvider,
-      ),
+      runRegularChatMemoryDigestEffect(services, orgRef, orgId, workspaceProvider) as Effect.Effect<
+        RegularChatDigestRunResult,
+        never,
+        never
+      >,
     )
 
   return withMemoryLock ? withMemoryLock(orgId, runDigest) : runDigest()

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

@@ -1,6 +1,8 @@
 import type { Context, Cause } from 'effect'
 import { Effect } from 'effect'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
@@ -27,6 +29,7 @@ const SKILL_EXTRACTION_TIMEOUT_MS = 10 * 60 * 1000
 const MIN_MESSAGE_THRESHOLD = 10
 
 export interface SkillExtractionServices {
+  agentConfig: ResolvedAgentConfig
   databaseService: SurrealDBService
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
@@ -149,7 +152,10 @@ function runSkillExtractionEffect(
     }
 
     const sortedMessages = [...messages].sort(compareDigestMessageOrder)
-    const { transcript } = buildDigestTranscript({ messages: sortedMessages })
+    const { transcript } = buildDigestTranscript({
+      messages: sortedMessages,
+      isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
+    })
 
     const existingSkills = yield* services.learnedSkillService.listForOrg(orgId)
     const existingSkillsSummary =
@@ -301,7 +307,7 @@ export function runSkillExtraction(
   data: SkillExtractionJob,
   services: SkillExtractionServices,
 ): Promise<SkillExtractionRunResult> {
-  const { databaseService, learnedSkillService, socialChatHistoryService, runtimeAdapters } = services
+  const { runtimeAdapters } = services
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const workspaceProvider = runtimeAdapters.workspaceProvider
@@ -317,19 +323,11 @@ export function runSkillExtraction(
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runExtraction = () =>
     Effect.runPromise(
-      runSkillExtractionEffect(
-        {
-          databaseService,
-          learnedSkillService,
-          socialChatHistoryService,
-          runtimeAdapters,
-          embeddingModel: services.embeddingModel,
-        },
-        orgRef,
-        orgId,
-        workspaceProvider,
-        embeddings,
-      ),
+      runSkillExtractionEffect(services, orgRef, orgId, workspaceProvider, embeddings) as Effect.Effect<
+        SkillExtractionRunResult,
+        never,
+        never
+      >,
     )
 
   return withMemoryLock ? withMemoryLock(orgId, runExtraction) : runExtraction()