@lota-sdk/core 0.4.9 → 0.4.11

package/src/runtime/social-chat/social-chat.ts

@@ -10,20 +10,19 @@ import type { ChatMessage, ConsultSpecialistArgs } from '@lota-sdk/shared'
 import { tool as createTool } from 'ai'
 import { Chat, ConsoleLogger } from 'chat'
 import type { Message, Thread, WebhookOptions } from 'chat'
-import type { Context } from 'effect'
-import { Cause, Clock, Effect } from 'effect'
+import type { Context, Cause } from 'effect'
+import { Clock, Effect, Schema } from 'effect'
 
-import { getAgentDisplayNames, getTeamConsultParticipants } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig, ResolvedAgentFactoryConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import { recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { ForbiddenError } from '../../effect/errors'
 import { effectTryMaybeAsync, effectTryPromise } from '../../effect/helpers'
-import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../../queues/organization-learning.queue'
-import { enqueuePostChatMemory } from '../../queues/post-chat-memory.queue'
+import type { LotaQueuesRuntime } from '../../queues/queues.service'
 import type { LearnedSkillServiceTag } from '../../services/learned-skill.service'
 import type { MemoryServiceTag } from '../../services/memory/memory.service'
-import type { makeSocialChatHistoryService } from '../../services/social-chat-history.service'
+import type { SocialChatHistoryError, makeSocialChatHistoryService } from '../../services/social-chat-history.service'
 import { safeEnqueue } from '../../utils/async'
 import { buildAgentPromptContext } from '../agent-prompt-context'
 import { createServerRunAbortController } from '../agent-stream-helpers'
@@ -32,7 +31,7 @@ import type {
   LotaRuntimeSocialChatConfig,
   LotaSocialChatResolvedContext,
 } from '../runtime-config'
-import { getRuntimeAdapters } from '../runtime-extensions'
+import type { LotaRuntimeAdapters } from '../runtime-extensions'
 import { runSpecialistSession } from '../specialist-runner'
 import {
   buildAgentHistoryMessages,
@@ -58,8 +57,15 @@ export interface SocialChatRuntimeServices {
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: ReturnType<typeof makeSocialChatHistoryService>
+  runtimeAdapters: LotaRuntimeAdapters
+  queues: LotaQueuesRuntime
 }
 
+class SocialChatServiceError extends Schema.TaggedErrorClass<SocialChatServiceError>()('SocialChatServiceError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
 const DEFAULT_SOCIAL_CHAT_AGENT_ID = 'socialChat'
 const DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME = 'Lota'
 const DEFAULT_SOCIAL_CHAT_STATE_PREFIX = 'lota:social:chat-sdk'
@@ -107,8 +113,8 @@ function createAssistantMessage(params: {
   }
 }
 
-function getAgentDisplayName(agentId: string): string {
-  return getAgentDisplayNames()[agentId] ?? agentId
+function getAgentDisplayName(agentConfig: ResolvedAgentConfig, agentId: string): string {
+  return agentConfig.displayNames[agentId] ?? agentId
 }
 
 function toSafeJobIdSegment(value: string): string {
@@ -152,6 +158,8 @@ function buildBuildToolsParams(params: {
 }
 
 export function createSocialChatRuntime(params: {
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: ResolvedAgentFactoryConfig
   redisClient: SocialChatStateRedisClient
   socialChat?: LotaRuntimeSocialChatConfig
   services: SocialChatRuntimeServices
@@ -192,384 +200,427 @@ export function createSocialChatRuntime(params: {
   const handleMessage = (
     thread: Thread,
     incomingMessage: Message,
-  ): Effect.Effect<void, Cause.UnknownError | ForbiddenError, never> =>
-    Effect.gen(function* () {
-      const { memoryService, learnedSkillService, socialChatHistoryService } = params.services
-      const currentContext = yield* Effect.context()
-      const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
-      const rawSlackMessage = incomingMessage.raw as { channel?: unknown } | undefined
-      const channelId = toOptionalTrimmedString(rawSlackMessage?.channel) ?? thread.channelId
-      const messageContext: SlackSocialMessageContext = {
-        channelId,
-        threadId: thread.id,
-        messageId: incomingMessage.id,
-        text: incomingMessage.text.trim(),
-        authorId: toOptionalTrimmedString(incomingMessage.author.userId) ?? undefined,
-        authorName: readSlackAuthorName(incomingMessage),
-      }
-      aiLogger.info`Slack social-chat message received: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, messageId=${messageContext.messageId}, author=${messageContext.authorName ?? 'unknown'}, textLength=${messageContext.text.length}`
-
-      const resolvedContext = yield* effectTryMaybeAsync(() =>
-        socialChatConfig.resolveContext({
-          platform: 'slack',
-          channelId: messageContext.channelId,
-          threadId: messageContext.threadId,
-          messageId: messageContext.messageId,
-          text: messageContext.text,
-          authorId: messageContext.authorId,
-          authorName: messageContext.authorName,
-        }),
-      )
-      const workspaceIdString = recordIdToString(resolvedContext.workspaceId, TABLES.ORGANIZATION)
-      const userIdString = recordIdToString(resolvedContext.userId, TABLES.USER)
-      aiLogger.info`Slack social-chat context resolved: workspaceId=${workspaceIdString}, userId=${userIdString}`
-
-      const threadMessages = yield* effectTryPromise(() => collectThreadMessages(thread, incomingMessage))
-      const normalizedMessages = threadMessages
-        .map((message) =>
-          normalizeSocialHistoryMessage({
-            workspaceId: workspaceIdString,
+  ): Effect.Effect<
+    void,
+    Cause.UnknownError | ForbiddenError | SocialChatHistoryError | SocialChatServiceError,
+    never
+  > =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const { memoryService, learnedSkillService, socialChatHistoryService } = params.services
+        const agentConfig = params.agentConfig
+        const agentFactoryConfig = params.agentFactoryConfig
+        const currentContext = yield* Effect.context()
+        const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+        const rawSlackMessage = incomingMessage.raw as { channel?: unknown } | undefined
+        const channelId = toOptionalTrimmedString(rawSlackMessage?.channel) ?? thread.channelId
+        const messageContext: SlackSocialMessageContext = {
+          channelId,
+          threadId: thread.id,
+          messageId: incomingMessage.id,
+          text: incomingMessage.text.trim(),
+          authorId: toOptionalTrimmedString(incomingMessage.author.userId) ?? undefined,
+          authorName: readSlackAuthorName(incomingMessage),
+        }
+        aiLogger.debug`Slack social-chat message received: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, messageId=${messageContext.messageId}, author=${messageContext.authorName ?? 'unknown'}, textLength=${messageContext.text.length}`
+
+        const resolvedContext = yield* effectTryMaybeAsync(() =>
+          socialChatConfig.resolveContext({
+            platform: 'slack',
             channelId: messageContext.channelId,
-            agentId: socialAgentId,
-            agentDisplayName: socialAgentDisplayName,
-            message,
+            threadId: messageContext.threadId,
+            messageId: messageContext.messageId,
+            text: messageContext.text,
+            authorId: messageContext.authorId,
+            authorName: messageContext.authorName,
           }),
         )
-        .filter((message): message is NonNullable<typeof message> => message !== null)
-      yield* socialChatHistoryService.upsertMessages(normalizedMessages)
-
-      const historyBeforeReply = yield* socialChatHistoryService.listThreadMessages({
-        workspaceId: workspaceIdString,
-        threadId: messageContext.threadId,
-      })
-      const currentUserMessage =
-        historyBeforeReply.find((message) => message.messageId === incomingMessage.id) ?? historyBeforeReply.at(-1)
-      const priorHistory = currentUserMessage
-        ? historyBeforeReply.filter((message) => message.cursor.id !== currentUserMessage.cursor.id)
-        : historyBeforeReply
-
-      const workspaceProvider = getRuntimeAdapters().workspaceProvider
-      const getWorkspace = workspaceProvider?.getWorkspace
-        ? workspaceProvider.getWorkspace.bind(workspaceProvider)
-        : undefined
-      const getLifecycleState = workspaceProvider?.getLifecycleState
-        ? workspaceProvider.getLifecycleState.bind(workspaceProvider)
-        : undefined
-      const readProfileProjectionState = workspaceProvider?.readProfileProjectionState
-        ? workspaceProvider.readProfileProjectionState.bind(workspaceProvider)
-        : undefined
-      const listRecentDomainEvents = workspaceProvider?.listRecentDomainEvents
-        ? workspaceProvider.listRecentDomainEvents.bind(workspaceProvider)
-        : undefined
-      const buildPromptSummary = workspaceProvider?.buildPromptSummary
-        ? workspaceProvider.buildPromptSummary.bind(workspaceProvider)
-        : undefined
-      const buildRetrievedKnowledgeSection = workspaceProvider?.buildRetrievedKnowledgeSection
-        ? workspaceProvider.buildRetrievedKnowledgeSection.bind(workspaceProvider)
-        : undefined
-      const getConsultParticipants = socialChatConfig.getConsultParticipants
-
-      const workspace = getWorkspace ? yield* effectTryMaybeAsync(() => getWorkspace(resolvedContext.workspaceId)) : {}
-      const lifecycleState = getLifecycleState
-        ? yield* effectTryMaybeAsync(() => getLifecycleState(workspace))
-        : undefined
-      const workspaceProfileState = readProfileProjectionState
-        ? yield* effectTryMaybeAsync(() => readProfileProjectionState(workspace))
-        : undefined
-      const recentDomainEvents = listRecentDomainEvents
-        ? yield* effectTryMaybeAsync(() => listRecentDomainEvents(resolvedContext.workspaceId, 5))
-        : ([] as Array<Record<string, unknown>>)
-      const promptSummary = buildPromptSummary
-        ? yield* effectTryMaybeAsync(() => buildPromptSummary(resolvedContext.workspaceId)).pipe(
-            Effect.orElseSucceed(() => undefined),
+        const workspaceIdString = recordIdToString(resolvedContext.workspaceId, TABLES.ORGANIZATION)
+        const userIdString = recordIdToString(resolvedContext.userId, TABLES.USER)
+        aiLogger.debug`Slack social-chat context resolved: workspaceId=${workspaceIdString}, userId=${userIdString}`
+
+        const threadMessages = yield* effectTryPromise(() => collectThreadMessages(thread, incomingMessage))
+        const normalizedMessages = threadMessages
+          .map((message) =>
+            normalizeSocialHistoryMessage({
+              workspaceId: workspaceIdString,
+              channelId: messageContext.channelId,
+              agentId: socialAgentId,
+              agentDisplayName: socialAgentDisplayName,
+              message,
+            }),
           )
-        : undefined
-
-      const promptContext = buildAgentPromptContext({
-        workspaceName:
-          workspaceProfileState?.workspaceName ??
-          toOptionalTrimmedString((workspace as { name?: unknown }).name) ??
-          undefined,
-        summaryBlock: workspaceProfileState?.summaryBlock,
-        promptSummary,
-        userName: messageContext.authorName,
-        recentDomainEvents,
-      })
-      const retrievedKnowledgeSection =
-        lifecycleState?.bootstrapActive || messageContext.text.length === 0
-          ? undefined
-          : buildRetrievedKnowledgeSection
-            ? yield* effectTryMaybeAsync(() =>
-                buildRetrievedKnowledgeSection({
-                  workspaceId: workspaceIdString,
-                  userId: userIdString,
-                  query: messageContext.text,
+          .filter((message): message is NonNullable<typeof message> => message !== null)
+        yield* socialChatHistoryService.upsertMessages(normalizedMessages)
+
+        const historyBeforeReply = yield* socialChatHistoryService.listThreadMessages({
+          workspaceId: workspaceIdString,
+          threadId: messageContext.threadId,
+        })
+        const currentUserMessage =
+          historyBeforeReply.find((message) => message.messageId === incomingMessage.id) ?? historyBeforeReply.at(-1)
+        const priorHistory = currentUserMessage
+          ? historyBeforeReply.filter((message) => message.cursor.id !== currentUserMessage.cursor.id)
+          : historyBeforeReply
+
+        const workspaceProvider = params.services.runtimeAdapters.workspaceProvider
+        const getWorkspace = workspaceProvider?.getWorkspace
+          ? workspaceProvider.getWorkspace.bind(workspaceProvider)
+          : undefined
+        const getLifecycleState = workspaceProvider?.getLifecycleState
+          ? workspaceProvider.getLifecycleState.bind(workspaceProvider)
+          : undefined
+        const readProfileProjectionState = workspaceProvider?.readProfileProjectionState
+          ? workspaceProvider.readProfileProjectionState.bind(workspaceProvider)
+          : undefined
+        const listRecentDomainEvents = workspaceProvider?.listRecentDomainEvents
+          ? workspaceProvider.listRecentDomainEvents.bind(workspaceProvider)
+          : undefined
+        const buildPromptSummary = workspaceProvider?.buildPromptSummary
+          ? workspaceProvider.buildPromptSummary.bind(workspaceProvider)
+          : undefined
+        const buildRetrievedKnowledgeSection = workspaceProvider?.buildRetrievedKnowledgeSection
+          ? workspaceProvider.buildRetrievedKnowledgeSection.bind(workspaceProvider)
+          : undefined
+        const getConsultParticipants = socialChatConfig.getConsultParticipants
+
+        const workspace = getWorkspace
+          ? yield* effectTryMaybeAsync(() => getWorkspace(resolvedContext.workspaceId))
+          : {}
+        const lifecycleState = getLifecycleState
+          ? yield* effectTryMaybeAsync(() => getLifecycleState(workspace))
+          : undefined
+        const workspaceProfileState = readProfileProjectionState
+          ? yield* effectTryMaybeAsync(() => readProfileProjectionState(workspace))
+          : undefined
+        const recentDomainEvents = listRecentDomainEvents
+          ? yield* effectTryMaybeAsync(() => listRecentDomainEvents(resolvedContext.workspaceId, 5))
+          : ([] as Array<Record<string, unknown>>)
+        const promptSummary = buildPromptSummary
+          ? yield* effectTryMaybeAsync(() => buildPromptSummary(resolvedContext.workspaceId)).pipe(
+              Effect.orElseSucceed(() => undefined),
+            )
+          : undefined
+
+        const promptContext = buildAgentPromptContext({
+          workspaceName:
+            workspaceProfileState?.workspaceName ??
+            toOptionalTrimmedString((workspace as { name?: unknown }).name) ??
+            undefined,
+          summaryBlock: workspaceProfileState?.summaryBlock,
+          promptSummary,
+          userName: messageContext.authorName,
+          recentDomainEvents,
+        })
+        const retrievedKnowledgeSection =
+          lifecycleState?.bootstrapActive || messageContext.text.length === 0
+            ? undefined
+            : buildRetrievedKnowledgeSection
+              ? yield* effectTryMaybeAsync(() =>
+                  buildRetrievedKnowledgeSection({
+                    workspaceId: workspaceIdString,
+                    userId: userIdString,
+                    query: messageContext.text,
+                  }),
+                )
+              : undefined
+
+        const preSeededMemoriesSection = yield* memoryService
+          .getTopMemories({ orgId: workspaceIdString, agentName: socialAgentId, limit: PRESEEDED_MEMORY_LOOKUP_LIMIT })
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new SocialChatServiceError({
+                  message: `Failed to load pre-seeded memories for ${socialAgentId}.`,
+                  cause,
                 }),
-              )
-            : undefined
-
-      const preSeededMemoriesSection = yield* memoryService
-        .getTopMemories({ orgId: workspaceIdString, agentName: socialAgentId, limit: PRESEEDED_MEMORY_LOOKUP_LIMIT })
-        .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
-      const learnedSkillsSection = lifecycleState?.bootstrapActive
-        ? undefined
-        : yield* learnedSkillService
-            .retrieveForTurn({
-              orgId: workspaceIdString,
-              agentId: socialAgentId,
-              query: messageContext.text,
-              limit: 3,
-              minConfidence: 0.6,
-            })
-            .pipe(Effect.orElseSucceed(() => undefined))
-
-      let memoryBlock = ''
-      const consultedAgents = getConsultParticipants
-        ? yield* effectTryMaybeAsync(() =>
-            getConsultParticipants({ workspaceId: resolvedContext.workspaceId, workspaceIdString, platform: 'slack' }),
+            ),
           )
-        : [...getTeamConsultParticipants()]
-      const consultParticipants = [...new Set(consultedAgents)].filter((agentId) => agentId !== socialAgentId)
-      const executedToolNames: string[] = []
-
-      const baseTools = withLoggedSocialToolSet(
-        yield* effectTryMaybeAsync(() =>
-          socialChatConfig.buildAgentTools(
-            buildBuildToolsParams({
-              agentId: socialAgentId,
-              context: resolvedContext,
-              workspaceIdString,
-              userIdString,
-              messageContext,
-              memoryBlock,
-              onAppendMemoryBlock: (value: string) => {
-                memoryBlock = value
-              },
-            }),
+        const learnedSkillsSection = lifecycleState?.bootstrapActive
+          ? undefined
+          : yield* learnedSkillService
+              .retrieveForTurn({
+                orgId: workspaceIdString,
+                agentId: socialAgentId,
+                query: messageContext.text,
+                limit: 3,
+                minConfidence: 0.6,
+              })
+              .pipe(Effect.orElseSucceed(() => undefined))
+
+        let memoryBlock = ''
+        const consultedAgents = getConsultParticipants
+          ? yield* effectTryMaybeAsync(() =>
+              getConsultParticipants({
+                workspaceId: resolvedContext.workspaceId,
+                workspaceIdString,
+                platform: 'slack',
+              }),
+            )
+          : [...agentConfig.teamConsultParticipants]
+        const consultParticipants = [...new Set(consultedAgents)].filter((agentId) => agentId !== socialAgentId)
+        const executedToolNames: string[] = []
+
+        const baseTools = withLoggedSocialToolSet(
+          yield* effectTryMaybeAsync(() =>
+            socialChatConfig.buildAgentTools(
+              buildBuildToolsParams({
+                agentId: socialAgentId,
+                context: resolvedContext,
+                workspaceIdString,
+                userIdString,
+                messageContext,
+                memoryBlock,
+                onAppendMemoryBlock: (value: string) => {
+                  memoryBlock = value
+                },
+              }),
+            ),
           ),
-        ),
-        {
-          agentId: socialAgentId,
-          channelId: messageContext.channelId,
-          threadId: messageContext.threadId,
-          executedToolNames,
-        },
-      )
-
-      const transcript = buildSocialChatThreadTranscript(historyBeforeReply)
-      const runAbort = createServerRunAbortController()
-
-      const consultSpecialistTool = createTool({
-        description: 'Consult one specialist teammate for targeted guidance before replying to the user.',
-        inputSchema: ConsultSpecialistArgsSchema,
-        execute: ({ agentId, task }: ConsultSpecialistArgs) =>
-          runPromiseWithCurrentContext(
-            Effect.gen(function* () {
-              if (!consultParticipants.includes(agentId)) {
-                return yield* new ForbiddenError({
-                  message: `Agent "${agentId}" is not an allowed social-chat specialist.`,
-                })
-              }
-
-              const { result: specialistRun } = yield* effectTryMaybeAsync(() =>
-                runSpecialistSession({
-                  initialMemoryBlock: '',
-                  buildTools: ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
-                    runPromiseWithCurrentContext(
-                      Effect.gen(function* () {
-                        const tools = yield* effectTryMaybeAsync(() =>
-                          socialChatConfig.buildAgentTools(
-                            buildBuildToolsParams({
-                              agentId,
-                              context: resolvedContext,
-                              workspaceIdString,
-                              userIdString,
-                              messageContext,
-                              memoryBlock: currentMemoryBlock,
-                              onAppendMemoryBlock,
-                            }),
-                          ),
-                        )
-
-                        return withLoggedSocialToolSet(tools, {
-                          agentId,
-                          channelId: messageContext.channelId,
-                          threadId: messageContext.threadId,
-                          executedToolNames,
-                        })
-                      }),
-                    ),
-                  run: ({ tools }) =>
-                    runPromiseWithCurrentContext(
-                      Effect.gen(function* () {
-                        const specialistPreSeededMemories = yield* memoryService
-                          .getTopMemories({
-                            orgId: workspaceIdString,
-                            agentName: agentId,
-                            limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
-                          })
-                          .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
-                        const specialistLearnedSkills = lifecycleState?.bootstrapActive
-                          ? undefined
-                          : yield* learnedSkillService
-                              .retrieveForTurn({
-                                orgId: workspaceIdString,
+          {
+            agentId: socialAgentId,
+            channelId: messageContext.channelId,
+            threadId: messageContext.threadId,
+            executedToolNames,
+          },
+        )
+
+        const transcript = buildSocialChatThreadTranscript(agentConfig, historyBeforeReply)
+        const runAbort = yield* Effect.acquireRelease(
+          Effect.sync(() => createServerRunAbortController()),
+          (controller) => Effect.sync(() => controller.dispose()),
+        )
+
+        const consultSpecialistTool = createTool({
+          description: 'Consult one specialist teammate for targeted guidance before replying to the user.',
+          inputSchema: ConsultSpecialistArgsSchema,
+          execute: ({ agentId, task }: ConsultSpecialistArgs) =>
+            runPromiseWithCurrentContext(
+              Effect.gen(function* () {
+                if (!consultParticipants.includes(agentId)) {
+                  return yield* new ForbiddenError({
+                    message: `Agent "${agentId}" is not an allowed social-chat specialist.`,
+                  })
+                }
+
+                const { result: specialistRun } = yield* effectTryMaybeAsync(() =>
+                  runSpecialistSession({
+                    initialMemoryBlock: '',
+                    buildTools: ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
+                      runPromiseWithCurrentContext(
+                        Effect.gen(function* () {
+                          const tools = yield* effectTryMaybeAsync(() =>
+                            socialChatConfig.buildAgentTools(
+                              buildBuildToolsParams({
                                 agentId,
-                                query: task,
-                                limit: 3,
-                                minConfidence: 0.6,
-                              })
-                              .pipe(Effect.orElseSucceed(() => undefined))
-
-                        return yield* effectTryPromise(() =>
-                          runSocialAgentTurn({
+                                context: resolvedContext,
+                                workspaceIdString,
+                                userIdString,
+                                messageContext,
+                                memoryBlock: currentMemoryBlock,
+                                onAppendMemoryBlock,
+                              }),
+                            ),
+                          )
+
+                          return withLoggedSocialToolSet(tools, {
                             agentId,
-                            mode: 'fixedThreadMode',
-                            threadType: 'group',
-                            onboardingActive: lifecycleState?.bootstrapActive ?? false,
-                            linearInstalled: false,
-                            systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-                            preSeededMemoriesSection: specialistPreSeededMemories,
-                            retrievedKnowledgeSection,
-                            learnedSkillsSection: specialistLearnedSkills,
-                            userMessageText: task,
-                            additionalInstructionSections: [
-                              `You are supporting ${socialAgentDisplayName} in a Slack social-chat thread. Stay within your role.`,
-                            ],
-                            tools,
-                            prompt: buildSpecialistSocialChatPrompt({
-                              requesterName: socialAgentDisplayName,
-                              agentName: getAgentDisplayName(agentId),
-                              task,
-                              transcript,
+                            channelId: messageContext.channelId,
+                            threadId: messageContext.threadId,
+                            executedToolNames,
+                          })
+                        }),
+                      ),
+                    run: ({ tools }) =>
+                      runPromiseWithCurrentContext(
+                        Effect.gen(function* () {
+                          const specialistPreSeededMemories = yield* memoryService
+                            .getTopMemories({
+                              orgId: workspaceIdString,
+                              agentName: agentId,
+                              limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
+                            })
+                            .pipe(
+                              Effect.mapError(
+                                (cause) =>
+                                  new SocialChatServiceError({
+                                    message: `Failed to load pre-seeded memories for specialist ${agentId}.`,
+                                    cause,
+                                  }),
+                              ),
+                            )
+                          const specialistLearnedSkills = lifecycleState?.bootstrapActive
+                            ? undefined
+                            : yield* learnedSkillService
+                                .retrieveForTurn({
+                                  orgId: workspaceIdString,
+                                  agentId,
+                                  query: task,
+                                  limit: 3,
+                                  minConfidence: 0.6,
+                                })
+                                .pipe(Effect.orElseSucceed(() => undefined))
+
+                          return yield* effectTryPromise(() =>
+                            runSocialAgentTurn({
+                              agentFactoryConfig,
+                              agentId,
+                              mode: 'fixedThreadMode',
+                              threadType: 'group',
+                              onboardingActive: lifecycleState?.bootstrapActive ?? false,
+                              linearInstalled: false,
+                              systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+                              preSeededMemoriesSection: specialistPreSeededMemories,
+                              retrievedKnowledgeSection,
+                              learnedSkillsSection: specialistLearnedSkills,
+                              userMessageText: task,
+                              additionalInstructionSections: [
+                                `You are supporting ${socialAgentDisplayName} in a Slack social-chat thread. Stay within your role.`,
+                              ],
+                              tools,
+                              prompt: buildSpecialistSocialChatPrompt({
+                                requesterName: socialAgentDisplayName,
+                                agentName: getAgentDisplayName(agentConfig, agentId),
+                                task,
+                                transcript,
+                              }),
+                              abortSignal: runAbort.signal,
                             }),
-                            abortSignal: runAbort.signal,
-                          }),
-                        )
-                      }),
-                    ),
-                }),
-              )
-              const text = specialistRun.text
-              const createdAt = yield* Clock.currentTimeMillis
-
-              return createAssistantMessage({ agentId, agentName: getAgentDisplayName(agentId), text, createdAt })
+                          )
+                        }),
+                      ),
+                  }),
+                )
+                const text = specialistRun.text
+                const createdAt = yield* Clock.currentTimeMillis
+
+                return createAssistantMessage({
+                  agentId,
+                  agentName: getAgentDisplayName(agentConfig, agentId),
+                  text,
+                  createdAt,
+                })
+              }),
+            ),
+          toModelOutput: ({ output }) => {
+            const message = output
+            const agentName =
+              typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
+                ? message.metadata.agentName.trim()
+                : 'Specialist'
+            const summary = extractMessageText(message).trim()
+            return {
+              type: 'text',
+              value: summary ? `${agentName}: ${summary}` : `${agentName} completed the requested task.`,
+            }
+          },
+        })
+
+        yield* effectTryPromise(() => thread.startTyping('Thinking...')).pipe(Effect.orElseSucceed(() => undefined))
+        aiLogger.debug`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
+        const leadRun = yield* effectTryPromise(() =>
+          runSocialAgentTurn({
+            agentFactoryConfig,
+            agentId: socialAgentId,
+            mode: 'threadMode',
+            threadType: 'group',
+            onboardingActive: lifecycleState?.bootstrapActive ?? false,
+            linearInstalled: false,
+            systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+            preSeededMemoriesSection,
+            retrievedKnowledgeSection,
+            learnedSkillsSection,
+            userMessageText: messageContext.text,
+            additionalInstructionSections: [buildSocialChatIdentitySection(socialAgentDisplayName)],
+            tools: { ...baseTools, [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool },
+            prompt: buildLeadSocialChatPrompt({
+              agentDisplayName: socialAgentDisplayName,
+              channelId: messageContext.channelId,
+              threadId: messageContext.threadId,
+              transcript,
+              latestUserMessage: messageContext.text,
+              latestAuthorName: messageContext.authorName,
             }),
-          ),
-        toModelOutput: ({ output }) => {
-          const message = output
-          const agentName =
-            typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
-              ? message.metadata.agentName.trim()
-              : 'Specialist'
-          const summary = extractMessageText(message).trim()
-          return {
-            type: 'text',
-            value: summary ? `${agentName}: ${summary}` : `${agentName} completed the requested task.`,
-          }
-        },
-      })
-
-      yield* effectTryPromise(() => thread.startTyping('Thinking...')).pipe(Effect.orElseSucceed(() => undefined))
-      aiLogger.info`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
-      const leadRun = yield* effectTryPromise(() =>
-        runSocialAgentTurn({
-          agentId: socialAgentId,
-          mode: 'threadMode',
-          threadType: 'group',
-          onboardingActive: lifecycleState?.bootstrapActive ?? false,
-          linearInstalled: false,
-          systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-          preSeededMemoriesSection,
-          retrievedKnowledgeSection,
-          learnedSkillsSection,
-          userMessageText: messageContext.text,
-          additionalInstructionSections: [buildSocialChatIdentitySection(socialAgentDisplayName)],
-          tools: { ...baseTools, [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool },
-          prompt: buildLeadSocialChatPrompt({
-            agentDisplayName: socialAgentDisplayName,
-            channelId: messageContext.channelId,
-            threadId: messageContext.threadId,
-            transcript,
-            latestUserMessage: messageContext.text,
-            latestAuthorName: messageContext.authorName,
+            abortSignal: runAbort.signal,
           }),
-          abortSignal: runAbort.signal,
-        }),
-      )
-      const responseText = leadRun.text
-
-      const replyMarkdown = buildSlackSocialReplyMarkdown({ replyMarkdown: responseText, executedToolNames })
-      const sentMessage = yield* effectTryPromise(() => thread.post({ markdown: replyMarkdown }))
-      aiLogger.info`Slack social-chat reply posted: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, replyMessageId=${sentMessage.id}`
-      const normalizedResponse = normalizeSocialHistoryMessage({
-        workspaceId: workspaceIdString,
-        channelId: messageContext.channelId,
-        agentId: socialAgentId,
-        agentDisplayName: socialAgentDisplayName,
-        message: sentMessage,
-        textOverride: responseText,
-      })
-      if (normalizedResponse) {
-        yield* socialChatHistoryService.upsertMessages([normalizedResponse])
-      }
-
-      const priorHistoryMessages = toHistoryMessages(priorHistory)
-      const agentMessages = normalizedResponse ? buildAgentHistoryMessages([normalizedResponse]) : []
-      if (messageContext.text && agentMessages.length > 0) {
+        )
+        const responseText = leadRun.text
+
+        const replyMarkdown = buildSlackSocialReplyMarkdown({ replyMarkdown: responseText, executedToolNames })
+        const sentMessage = yield* effectTryPromise(() => thread.post({ markdown: replyMarkdown }))
+        aiLogger.debug`Slack social-chat reply posted: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, replyMessageId=${sentMessage.id}`
+        const normalizedResponse = normalizeSocialHistoryMessage({
+          workspaceId: workspaceIdString,
+          channelId: messageContext.channelId,
+          agentId: socialAgentId,
+          agentDisplayName: socialAgentDisplayName,
+          message: sentMessage,
+          textOverride: responseText,
+        })
+        if (normalizedResponse) {
+          yield* socialChatHistoryService.upsertMessages([normalizedResponse])
+        }
+
+        const priorHistoryMessages = toHistoryMessages(agentConfig, priorHistory)
+        const agentMessages = normalizedResponse ? buildAgentHistoryMessages(agentConfig, [normalizedResponse]) : []
+        if (messageContext.text && agentMessages.length > 0) {
+          yield* effectTryPromise(() =>
+            safeEnqueue(
+              () =>
+                params.services.queues.postChatMemory.enqueuePostChatMemory(
+                  {
+                    orgId: workspaceIdString,
+                    threadId: `social:slack:${messageContext.threadId}`,
+                    sourceId: createSocialChatCursorId({
+                      workspaceId: workspaceIdString,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                    }),
+                    userMessage: messageContext.text,
+                    historyMessages: priorHistoryMessages,
+                    agentMessages,
+                    memoryBlock: memoryBlock.trim() ? memoryBlock : undefined,
+                    source: 'social_chat',
+                    sourceMetadata: {
+                      platform: 'slack',
+                      channelId: messageContext.channelId,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                      authorId: messageContext.authorId,
+                      authorName: messageContext.authorName,
+                    },
+                  },
+                  {
+                    dedupeKey: createSocialMemoryDedupeKey({
+                      workspaceId: workspaceIdString,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                    }),
+                  },
+                ),
+              { operationName: 'social post-chat memory extraction enqueue' },
+            ),
+          )
+        }
+
         yield* effectTryPromise(() =>
           safeEnqueue(
             () =>
-              enqueuePostChatMemory(
-                {
-                  orgId: workspaceIdString,
-                  threadId: `social:slack:${messageContext.threadId}`,
-                  sourceId: createSocialChatCursorId({
-                    workspaceId: workspaceIdString,
-                    threadId: messageContext.threadId,
-                    messageId: messageContext.messageId,
-                  }),
-                  userMessage: messageContext.text,
-                  historyMessages: priorHistoryMessages,
-                  agentMessages,
-                  memoryBlock: memoryBlock.trim() ? memoryBlock : undefined,
-                  source: 'social_chat',
-                  sourceMetadata: {
-                    platform: 'slack',
-                    channelId: messageContext.channelId,
-                    threadId: messageContext.threadId,
-                    messageId: messageContext.messageId,
-                    authorId: messageContext.authorId,
-                    authorName: messageContext.authorName,
-                  },
-                },
-                {
-                  dedupeKey: createSocialMemoryDedupeKey({
-                    workspaceId: workspaceIdString,
-                    threadId: messageContext.threadId,
-                    messageId: messageContext.messageId,
-                  }),
-                },
-              ),
-            { operationName: 'social post-chat memory extraction enqueue' },
+              params.services.queues.organizationLearning.enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }),
+            { operationName: 'social regular chat memory digest enqueue' },
+          ),
+        )
+        yield* effectTryPromise(() =>
+          safeEnqueue(
+            () => params.services.queues.organizationLearning.enqueueSkillExtraction({ orgId: workspaceIdString }),
+            { operationName: 'social skill extraction enqueue' },
           ),
         )
-      }
-
-      yield* effectTryPromise(() =>
-        safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }), {
-          operationName: 'social regular chat memory digest enqueue',
-        }),
-      )
-      yield* effectTryPromise(() =>
-        safeEnqueue(() => enqueueSkillExtraction({ orgId: workspaceIdString }), {
-          operationName: 'social skill extraction enqueue',
-        }),
-      )
-    })
+      }),
+    )
 
   chat.onNewMention((thread, message) => {
-    aiLogger.info`Slack social-chat new mention received: threadId=${thread.id}, messageId=${message.id}`
+    aiLogger.debug`Slack social-chat new mention received: threadId=${thread.id}, messageId=${message.id}`
     return Effect.runPromise(
       Effect.gen(function* () {
         yield* effectTryPromise(() => thread.subscribe())
@@ -578,7 +629,7 @@ export function createSocialChatRuntime(params: {
     )
   })
   chat.onSubscribedMessage((thread, message) => {
-    aiLogger.info`Slack social-chat subscribed thread message received: threadId=${thread.id}, messageId=${message.id}`
+    aiLogger.debug`Slack social-chat subscribed thread message received: threadId=${thread.id}, messageId=${message.id}`
     return Effect.runPromise(handleMessage(thread, message))
   })