@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -17,13 +17,13 @@ import type { ResolvedAgentConfig, ResolvedAgentFactoryConfig } from '../../conf
 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 { ERROR_TAGS, ForbiddenError } from '../../effect/errors'
 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 { SocialChatHistoryError, makeSocialChatHistoryService } from '../../services/social-chat-history.service'
 import { safeEnqueue } from '../../utils/async'
+import { getErrorMessage } from '../../utils/errors'
 import { buildAgentPromptContext } from '../agent-prompt-context'
 import { createServerRunAbortController } from '../agent-stream-helpers'
 import type {
@@ -61,10 +61,31 @@ export interface SocialChatRuntimeServices {
   queues: LotaQueuesRuntime
 }
 
-class SocialChatServiceError extends Schema.TaggedErrorClass<SocialChatServiceError>()('SocialChatServiceError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class SocialChatServiceError extends Schema.TaggedErrorClass<SocialChatServiceError>()(
+  ERROR_TAGS.SocialChatServiceError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+function toSocialChatServiceError(message: string, cause: unknown): SocialChatServiceError {
+  return new SocialChatServiceError({ message, cause })
+}
+
+function runSlackMessageHandler(params: {
+  kind: 'mention' | 'subscribed-message'
+  thread: Thread
+  message: Message
+  effect: Effect.Effect<
+    void,
+    Cause.UnknownError | ForbiddenError | SocialChatHistoryError | SocialChatServiceError,
+    never
+  >
+}): Promise<void> {
+  return Effect.runPromise(params.effect).catch((cause) => {
+    const error = toSocialChatServiceError(`Failed to handle Slack social-chat ${params.kind}.`, cause)
+    aiLogger.error`Slack social-chat ${params.kind} failed: threadId=${params.thread.id}, messageId=${params.message.id}, error=${getErrorMessage(error)}`
+    throw error
+  })
+}
 
 const DEFAULT_SOCIAL_CHAT_AGENT_ID = 'socialChat'
 const DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME = 'Lota'
@@ -194,8 +215,20 @@ export function createSocialChatRuntime(params: {
     dedupeTtlMs: slackConfig?.dedupeTtlMs ?? DEFAULT_SOCIAL_CHAT_DEDUPE_TTL_MS,
   })
 
-  const initialize = () => Effect.runPromise(effectTryPromise(() => chat.initialize()))
-  const shutdown = () => Effect.runPromise(effectTryPromise(() => chat.shutdown()))
+  const initialize = () =>
+    Effect.runPromise(
+      Effect.tryPromise({
+        try: () => chat.initialize(),
+        catch: (cause) => toSocialChatServiceError('Failed to initialize social chat.', cause),
+      }),
+    )
+  const shutdown = () =>
+    Effect.runPromise(
+      Effect.tryPromise({
+        try: () => chat.shutdown(),
+        catch: (cause) => toSocialChatServiceError('Failed to shut down social chat.', cause),
+      }),
+    )
 
   const handleMessage = (
     thread: Thread,
@@ -224,22 +257,27 @@ export function createSocialChatRuntime(params: {
         }
         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,
-            threadId: messageContext.threadId,
-            messageId: messageContext.messageId,
-            text: messageContext.text,
-            authorId: messageContext.authorId,
-            authorName: messageContext.authorName,
-          }),
-        )
+        const resolvedContext = yield* Effect.tryPromise({
+          try: () =>
+            socialChatConfig.resolveContext({
+              platform: 'slack',
+              channelId: messageContext.channelId,
+              threadId: messageContext.threadId,
+              messageId: messageContext.messageId,
+              text: messageContext.text,
+              authorId: messageContext.authorId,
+              authorName: messageContext.authorName,
+            }),
+          catch: (cause) => toSocialChatServiceError('Failed to resolve social chat context.', cause),
+        })
         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 threadMessages = yield* Effect.tryPromise({
+          try: () => collectThreadMessages(thread, incomingMessage),
+          catch: (cause) => toSocialChatServiceError('Failed to collect thread messages.', cause),
+        })
         const normalizedMessages = threadMessages
           .map((message) =>
             normalizeSocialHistoryMessage({
@@ -285,19 +323,39 @@ export function createSocialChatRuntime(params: {
         const getConsultParticipants = socialChatConfig.getConsultParticipants
 
         const workspace = getWorkspace
-          ? yield* effectTryMaybeAsync(() => getWorkspace(resolvedContext.workspaceId))
+          ? yield* Effect.tryPromise({
+              try: () => getWorkspace(resolvedContext.workspaceId),
+              catch: (cause) => toSocialChatServiceError('Failed to load social chat workspace.', cause),
+            })
           : {}
         const lifecycleState = getLifecycleState
-          ? yield* effectTryMaybeAsync(() => getLifecycleState(workspace))
+          ? yield* Effect.tryPromise({
+              try: () => getLifecycleState(workspace),
+              catch: (cause) => toSocialChatServiceError('Failed to load workspace lifecycle state.', cause),
+            })
           : undefined
         const workspaceProfileState = readProfileProjectionState
-          ? yield* effectTryMaybeAsync(() => readProfileProjectionState(workspace))
+          ? yield* Effect.tryPromise({
+              try: () => readProfileProjectionState(workspace),
+              catch: (cause) => toSocialChatServiceError('Failed to read workspace profile projection state.', cause),
+            })
           : undefined
         const recentDomainEvents = listRecentDomainEvents
-          ? yield* effectTryMaybeAsync(() => listRecentDomainEvents(resolvedContext.workspaceId, 5))
+          ? yield* Effect.tryPromise({
+              try: () => listRecentDomainEvents(resolvedContext.workspaceId, 5),
+              catch: (cause) => toSocialChatServiceError('Failed to load recent workspace domain events.', cause),
+            })
           : ([] as Array<Record<string, unknown>>)
         const promptSummary = buildPromptSummary
-          ? yield* effectTryMaybeAsync(() => buildPromptSummary(resolvedContext.workspaceId)).pipe(
+          ? yield* Effect.tryPromise({
+              try: () => buildPromptSummary(resolvedContext.workspaceId),
+              catch: (cause) => toSocialChatServiceError('Failed to build workspace prompt summary.', cause),
+            }).pipe(
+              Effect.tapError((error) =>
+                Effect.sync(() => {
+                  aiLogger.warn`Slack social-chat buildPromptSummary failed: ${error}`
+                }),
+              ),
               Effect.orElseSucceed(() => undefined),
             )
           : undefined
@@ -316,13 +374,15 @@ export function createSocialChatRuntime(params: {
           lifecycleState?.bootstrapActive || messageContext.text.length === 0
             ? undefined
             : buildRetrievedKnowledgeSection
-              ? yield* effectTryMaybeAsync(() =>
-                  buildRetrievedKnowledgeSection({
-                    workspaceId: workspaceIdString,
-                    userId: userIdString,
-                    query: messageContext.text,
-                  }),
-                )
+              ? yield* Effect.tryPromise({
+                  try: () =>
+                    buildRetrievedKnowledgeSection({
+                      workspaceId: workspaceIdString,
+                      userId: userIdString,
+                      query: messageContext.text,
+                    }),
+                  catch: (cause) => toSocialChatServiceError('Failed to build retrieved knowledge section.', cause),
+                })
               : undefined
 
         const preSeededMemoriesSection = yield* memoryService
@@ -346,37 +406,49 @@ export function createSocialChatRuntime(params: {
                 limit: 3,
                 minConfidence: 0.6,
               })
-              .pipe(Effect.orElseSucceed(() => undefined))
+              .pipe(
+                Effect.tapError((error) =>
+                  Effect.sync(() => {
+                    aiLogger.warn`Slack social-chat memory retrieval failed: ${error}`
+                  }),
+                ),
+                Effect.orElseSucceed(() => undefined),
+              )
 
         let memoryBlock = ''
         const consultedAgents = getConsultParticipants
-          ? yield* effectTryMaybeAsync(() =>
-              getConsultParticipants({
-                workspaceId: resolvedContext.workspaceId,
-                workspaceIdString,
-                platform: 'slack',
-              }),
-            )
+          ? yield* Effect.tryPromise({
+              try: () =>
+                getConsultParticipants({
+                  workspaceId: resolvedContext.workspaceId,
+                  workspaceIdString,
+                  platform: 'slack',
+                }),
+              catch: (cause) => toSocialChatServiceError('Failed to resolve social chat consult participants.', cause),
+            })
           : [...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
-                },
-              }),
-            ),
-          ),
+          yield* Effect.tryPromise({
+            try: () =>
+              socialChatConfig.buildAgentTools(
+                buildBuildToolsParams({
+                  agentId: socialAgentId,
+                  context: resolvedContext,
+                  workspaceIdString,
+                  userIdString,
+                  messageContext,
+                  memoryBlock,
+                  onAppendMemoryBlock: (value: string) => {
+                    memoryBlock = value
+                  },
+                }),
+              ),
+            catch: (cause) =>
+              toSocialChatServiceError(`Failed to build social chat tools for ${socialAgentId}.`, cause),
+          }),
           {
             agentId: socialAgentId,
             channelId: messageContext.channelId,
@@ -403,94 +475,116 @@ export function createSocialChatRuntime(params: {
                   })
                 }
 
-                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 SocialChatServiceError({
-                                    message: `Failed to load pre-seeded memories for specialist ${agentId}.`,
-                                    cause,
+                const { result: specialistRun } = yield* Effect.tryPromise({
+                  try: () =>
+                    runSpecialistSession({
+                      initialMemoryBlock: '',
+                      buildTools: ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
+                        runPromiseWithCurrentContext(
+                          Effect.gen(function* () {
+                            const tools = yield* Effect.tryPromise({
+                              try: () =>
+                                socialChatConfig.buildAgentTools(
+                                  buildBuildToolsParams({
+                                    agentId,
+                                    context: resolvedContext,
+                                    workspaceIdString,
+                                    userIdString,
+                                    messageContext,
+                                    memoryBlock: currentMemoryBlock,
+                                    onAppendMemoryBlock,
                                   }),
-                              ),
-                            )
-                          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,
+                                ),
+                              catch: (cause) =>
+                                toSocialChatServiceError(
+                                  `Failed to build social chat tools for specialist ${agentId}.`,
+                                  cause,
+                                ),
+                            })
+
+                            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(agentConfig, agentId),
-                                task,
-                                transcript,
-                              }),
-                              abortSignal: runAbort.signal,
-                            }),
-                          )
-                        }),
-                      ),
-                  }),
-                )
+                              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.tapError((error) =>
+                                      Effect.sync(() => {
+                                        aiLogger.warn`Slack social-chat participant memory retrieval failed: ${error}`
+                                      }),
+                                    ),
+                                    Effect.orElseSucceed(() => undefined),
+                                  )
+
+                            return yield* Effect.tryPromise({
+                              try: () =>
+                                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,
+                                }),
+                              catch: (cause) =>
+                                toSocialChatServiceError(
+                                  `Failed to run specialist social agent turn for ${agentId}.`,
+                                  cause,
+                                ),
+                            })
+                          }),
+                        ),
+                    }),
+                  catch: (cause) =>
+                    toSocialChatServiceError(`Failed to run social specialist session for ${agentId}.`, cause),
+                })
                 const text = specialistRun.text
                 const createdAt = yield* Clock.currentTimeMillis
 
@@ -516,38 +610,53 @@ export function createSocialChatRuntime(params: {
           },
         })
 
-        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,
+        yield* Effect.tryPromise({
+          try: () => thread.startTyping('Thinking...'),
+          catch: (cause) => toSocialChatServiceError('Failed to start Slack typing indicator.', cause),
+        }).pipe(
+          Effect.tapError((error) =>
+            Effect.sync(() => {
+              aiLogger.warn`Slack social-chat startTyping failed: ${error}`
             }),
-            abortSignal: runAbort.signal,
-          }),
+          ),
+          Effect.orElseSucceed(() => undefined),
         )
+        aiLogger.debug`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
+        const leadRun = yield* Effect.tryPromise({
+          try: () =>
+            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,
+              }),
+              abortSignal: runAbort.signal,
+            }),
+          catch: (cause) => toSocialChatServiceError(`Failed to run social agent turn for ${socialAgentId}.`, cause),
+        })
         const responseText = leadRun.text
 
         const replyMarkdown = buildSlackSocialReplyMarkdown({ replyMarkdown: responseText, executedToolNames })
-        const sentMessage = yield* effectTryPromise(() => thread.post({ markdown: replyMarkdown }))
+        const sentMessage = yield* Effect.tryPromise({
+          try: () => thread.post({ markdown: replyMarkdown }),
+          catch: (cause) => toSocialChatServiceError('Failed to post Slack social chat reply.', cause),
+        })
         aiLogger.debug`Slack social-chat reply posted: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, replyMessageId=${sentMessage.id}`
         const normalizedResponse = normalizeSocialHistoryMessage({
           workspaceId: workspaceIdString,
@@ -564,73 +673,92 @@ export function createSocialChatRuntime(params: {
         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,
+          yield* Effect.tryPromise({
+            try: () =>
+              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' },
-            ),
-          )
+                    {
+                      dedupeKey: createSocialMemoryDedupeKey({
+                        workspaceId: workspaceIdString,
+                        threadId: messageContext.threadId,
+                        messageId: messageContext.messageId,
+                      }),
+                    },
+                  ),
+                { operationName: 'social post-chat memory extraction enqueue' },
+              ),
+            catch: (cause) => toSocialChatServiceError('Failed to enqueue social post-chat memory extraction.', cause),
+          })
         }
 
-        yield* effectTryPromise(() =>
-          safeEnqueue(
-            () =>
-              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* Effect.tryPromise({
+          try: () =>
+            safeEnqueue(
+              () =>
+                params.services.queues.organizationLearning.enqueueRegularChatMemoryDigest({
+                  orgId: workspaceIdString,
+                }),
+              { operationName: 'social regular chat memory digest enqueue' },
+            ),
+          catch: (cause) => toSocialChatServiceError('Failed to enqueue social regular chat memory digest.', cause),
+        })
+        yield* Effect.tryPromise({
+          try: () =>
+            safeEnqueue(
+              () => params.services.queues.organizationLearning.enqueueSkillExtraction({ orgId: workspaceIdString }),
+              { operationName: 'social skill extraction enqueue' },
+            ),
+          catch: (cause) => toSocialChatServiceError('Failed to enqueue social skill extraction.', cause),
+        })
       }),
     )
 
   chat.onNewMention((thread, message) => {
     aiLogger.debug`Slack social-chat new mention received: threadId=${thread.id}, messageId=${message.id}`
-    return Effect.runPromise(
-      Effect.gen(function* () {
-        yield* effectTryPromise(() => thread.subscribe())
+    return runSlackMessageHandler({
+      kind: 'mention',
+      thread,
+      message,
+      effect: Effect.gen(function* () {
+        yield* Effect.tryPromise({
+          try: () => thread.subscribe(),
+          catch: (cause) => toSocialChatServiceError('Failed to subscribe to Slack thread.', cause),
+        })
         return yield* handleMessage(thread, message)
       }),
-    )
+    })
   })
   chat.onSubscribedMessage((thread, message) => {
     aiLogger.debug`Slack social-chat subscribed thread message received: threadId=${thread.id}, messageId=${message.id}`
-    return Effect.runPromise(handleMessage(thread, message))
+    return runSlackMessageHandler({
+      kind: 'subscribed-message',
+      thread,
+      message,
+      effect: handleMessage(thread, message),
+    })
   })
 
   return {
@@ -639,7 +767,12 @@ export function createSocialChatRuntime(params: {
     shutdown,
     webhooks: {
       slack: (request: Request, options?: WebhookOptions) =>
-        Effect.runPromise(effectTryPromise(() => chat.webhooks.slack(request, options))),
+        Effect.runPromise(
+          Effect.tryPromise({
+            try: () => chat.webhooks.slack(request, options),
+            catch: (cause) => toSocialChatServiceError('Failed to handle Slack social chat webhook.', cause),
+          }),
+        ),
     },
   }
 }