@lota-sdk/core 0.1.13 → 0.1.15

package/src/services/{workstream-turn-preparation.ts → workstream-turn-preparation.service.ts}

@@ -3,7 +3,7 @@ import {
   CONSULT_SPECIALIST_TOOL_NAME,
   CONSULT_TEAM_TOOL_NAME,
   ConsultSpecialistArgsSchema,
-  dataPartsSchema,
+  dataPartsSchemas,
   messageMetadataSchema,
   toTimestamp,
   withMessageCreatedAt,
@@ -13,6 +13,7 @@ import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as creat
 import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
 import type { z } from 'zod'
 
+import type { CoreWorkstreamProfile } from '../config/agent-defaults'
 import {
   agentDisplayNames,
   buildAgentTools,
@@ -45,7 +46,7 @@ import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataT
 import { hasMessageContent } from '../runtime/chat-message'
 import { waitForCompactionIfNeeded } from '../runtime/chat-run-orchestration'
 import { parseWorkstreamState } from '../runtime/context-compaction'
-import { CONTEXT_SIZE } from '../runtime/context-compaction-constants'
+import { CONTEXT_WINDOW_TOKENS } from '../runtime/context-compaction-constants'
 import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import {
@@ -81,7 +82,7 @@ import { toIsoDateTimeString } from '../utils/date-time'
 import { AppError } from '../utils/errors'
 import { attachmentService } from './attachment.service'
 import { listReadableUploadsFromChatMessages } from './chat-attachments.service'
-import { contextCompactionRuntime } from './context-compaction-runtime'
+import { contextCompactionRuntime } from './context-compaction-runtime.singleton'
 import { executionPlanService } from './execution-plan.service'
 import { learnedSkillService } from './learned-skill.service'
 import { memoryService } from './memory.service'
@@ -231,7 +232,7 @@ export interface WorkstreamTurnParams {
   userRef: RecordIdRef
   userName?: string | null
   inputMessage: ChatMessage
-  persistInputMessage?: boolean
+  skipInputMessagePersistence?: boolean
   abortSignal?: AbortSignal
   streamId?: string
 }
@@ -256,7 +257,7 @@ type WorkstreamRunCoreParams = {
   abortSignal?: AbortSignal
   streamId?: string
 } & (
-  | { kind: 'userTurn'; inputMessage: ChatMessage; persistInputMessage?: boolean }
+  | { kind: 'userTurn'; inputMessage: ChatMessage; skipInputMessagePersistence?: boolean }
   | { kind: 'approvalContinuation'; approvalMessages: ChatMessage[] }
   | { kind: 'nativeToolApprovalTurn'; approvalMessages: ChatMessage[] }
 )
@@ -300,6 +301,338 @@ function buildRecentActivityChatSystemTitle(params: {
   return params.workstream.title.trim() || 'Workstream update'
 }
 
+interface StreamAgentResponseContext {
+  turnHooks: ReturnType<typeof getTurnHooks>
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  onboardingActive: boolean
+  linearInstalled: boolean
+  githubInstalled: boolean
+  reasoningProfileName: string
+  buildContextResult: Record<string, unknown> | null
+  getExecutionPlanInstructionSections: () => Promise<string[] | undefined>
+  getPreSeededMemoriesSection: (agentId: string) => Promise<string | undefined>
+  getWorkstreamStateSection: () => Promise<string | undefined>
+  getLearnedSkillsSection: (agentId: string) => Promise<string | undefined>
+  promptContext: { systemWorkspaceDetails?: string }
+  retrievedKnowledgeSection: string | undefined
+  memoryBlock: string
+  hookInstructionSections: string[]
+  runAbortSignal: AbortSignal
+}
+
+interface StreamAgentResponseParams {
+  agentId: string
+  mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+  messages: ChatMessage[]
+  tools: ToolSet
+  observer: {
+    run: <T>(fn: () => T | Promise<T>) => Promise<T>
+    recordError: (error: unknown) => void
+    recordAbort: (error: unknown) => void
+  }
+  skills?: string[]
+  additionalInstructionSections?: string[]
+  writer?: UIMessageStreamWriter<ChatMessage>
+  stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>
+  prepareStep?: PrepareStepFunction<ToolSet>
+  abortSignal?: AbortSignal
+}
+
+async function streamAgentResponse(
+  ctx: StreamAgentResponseContext,
+  streamParams: StreamAgentResponseParams,
+): Promise<ChatMessage> {
+  const agentTimer = lotaDebugLogger.timer(`agent:${streamParams.agentId}`)
+  const executionPlanInstructionSections = await ctx.getExecutionPlanInstructionSections()
+  agentTimer.step('get-execution-plan')
+  const agentResolution = asRecord(
+    await ctx.turnHooks.resolveAgent?.({
+      agentId: streamParams.agentId,
+      mode: streamParams.mode,
+      workstream: ctx.workstream,
+      workstreamRef: ctx.workstreamRef,
+      orgRef: ctx.orgRef,
+      userRef: ctx.userRef,
+      userName: ctx.userName,
+      onboardingActive: ctx.onboardingActive,
+      linearInstalled: ctx.linearInstalled,
+      githubInstalled: ctx.githubInstalled,
+      reasoningProfile: ctx.reasoningProfileName,
+      skills: streamParams.skills,
+      additionalInstructionSections: streamParams.additionalInstructionSections,
+      context: ctx.buildContextResult,
+    }),
+  )
+  agentTimer.step('hook:resolveAgent')
+  const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
+  const [preSeededMemoriesSection, workstreamStateSection, learnedSkillsSection] = await Promise.all([
+    ctx.getPreSeededMemoriesSection(resolvedAgentId),
+    ctx.getWorkstreamStateSection(),
+    ctx.getLearnedSkillsSection(resolvedAgentId),
+  ])
+  agentTimer.step('parallel-fetch(memories+state+skills)')
+  const config = getAgentRuntimeConfig({
+    agentId: resolvedAgentId,
+    workstreamMode: ctx.workstream.mode,
+    mode: streamParams.mode,
+    skills: streamParams.skills,
+    onboardingActive: ctx.onboardingActive,
+    linearInstalled: ctx.linearInstalled,
+    reasoningProfile: ctx.reasoningProfileName,
+    systemWorkspaceDetails: ctx.promptContext.systemWorkspaceDetails,
+    preSeededMemoriesSection,
+    retrievedKnowledgeSection: ctx.retrievedKnowledgeSection,
+    workstreamMemoryBlock: ctx.memoryBlock,
+    workstreamStateSection,
+    learnedSkillsSection,
+    additionalInstructionSections: mergeInstructionSections(
+      executionPlanInstructionSections,
+      streamParams.additionalInstructionSections,
+      ctx.hookInstructionSections,
+      readInstructionSections(agentResolution?.additionalInstructionSections),
+      optionalInstructionSection(agentResolution?.extraInstructions),
+    ),
+    context: ctx.buildContextResult,
+  }) as AgentRuntimeConfig
+  agentTimer.step('build-agent-config')
+  const modelMessages = await convertToModelMessages(streamParams.messages, { ignoreIncompleteToolCalls: true })
+  agentTimer.step('convert-model-messages')
+  const agent = (createAgent as unknown as AgentFactory)[config.id as string]({
+    mode: streamParams.mode,
+    tools: streamParams.tools,
+    extraInstructions: config.extraInstructions,
+    stopWhen: (agentResolution?.stopWhen as StopCondition<ToolSet> | Array<StopCondition<ToolSet>> | undefined) ??
+      streamParams.stopWhen ?? [stepCountIs(config.maxSteps as number)],
+    prepareStep: (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
+  })
+  const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
+  agentTimer.step('agent-construction')
+
+  let result: unknown
+  try {
+    result = await streamParams.observer.run(() =>
+      agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
+    )
+    agentTimer.step('agent.stream()-resolved')
+  } catch (error) {
+    if (agentAbortSignal.aborted) {
+      streamParams.observer.recordAbort(error)
+    } else {
+      streamParams.observer.recordError(error)
+    }
+    throw error
+  }
+  if (!hasUIMessageStream(result)) {
+    throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)
+  }
+
+  let responseMessage: ChatMessage | null = null
+  let resolveFinishedStream!: () => void
+  const finishedStream = new Promise<void>((resolve) => {
+    resolveFinishedStream = resolve
+  })
+
+  const uiStream = result.toUIMessageStream({
+    generateMessageId: () => Bun.randomUUIDv7(),
+    originalMessages: streamParams.messages,
+    sendReasoning: true,
+    sendSources: true,
+    messageMetadata: createAgentMessageMetadata({ agentId: resolvedAgentId, agentName: config.displayName as string }),
+    onFinish: ({ responseMessage: finishedResponseMessage }: { responseMessage: ChatMessage }) => {
+      responseMessage = withMessageCreatedAt(finishedResponseMessage)
+      resolveFinishedStream()
+    },
+  }) as ReadableStream<ChatStreamChunk>
+  const reader = uiStream.getReader()
+  let firstChunkLogged = false
+  try {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (!firstChunkLogged) {
+        agentTimer.step('first-stream-chunk')
+        firstChunkLogged = true
+      }
+      if (streamParams.writer) {
+        streamParams.writer.write(value)
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+  agentTimer.step('stream-complete')
+
+  await finishedStream
+  // responseMessage is set inside the stream callback — linter cannot track cross-callback assignment
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (responseMessage === null) {
+    throw new Error(`Agent run for ${resolvedAgentId} did not produce a response message.`)
+  }
+
+  for (const toolError of collectToolOutputErrors({ responseMessage: responseMessage })) {
+    aiLogger.warn`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
+  }
+
+  return responseMessage
+}
+
+interface PostTurnSideEffectsParams {
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  orgIdString: string
+  workstreamIdString: string
+  onboardingActive: boolean
+  workspace: unknown
+  allAssistantMessages: ChatMessage[]
+  referenceUserMessage: ChatMessage | undefined
+  referenceUserMessageId: string
+  recentHistory: ChatMessage[]
+  listReadableUploads: () => ReturnType<typeof listReadableUploadsFromChatMessages>
+  memoryBlock: string
+  visibleWorkstreamAgentId: string | null | undefined
+  defaultLeadAgentId: string
+  latestWorkstreamRecord: WorkstreamRecord
+  latestPersistedState: WorkstreamState | null
+  turnHooks: ReturnType<typeof getTurnHooks>
+  buildContextResult: Record<string, unknown> | null
+  isUserTurn: boolean
+}
+
+async function runPostTurnSideEffects(params: PostTurnSideEffectsParams): Promise<void> {
+  const turnCount = await workstreamService.incrementTurnCount(params.workstreamRef)
+  const agentMessages = buildAgentHistoryMessages(params.allAssistantMessages)
+  const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(
+    toHistoryMessages(params.recentHistory),
+    { compactionSummary: params.latestWorkstreamRecord.compactionSummary, persistedState: params.latestPersistedState },
+  )
+
+  const userMessageText = params.referenceUserMessage ? extractMessageText(params.referenceUserMessage).trim() : ''
+  const readableUploads = params.listReadableUploads()
+  const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
+  const hasAttachmentContext = Boolean(attachmentMetadataContext)
+  const shouldExtractMemory = params.onboardingActive
+    ? shouldEnqueueOnboardingPostChatMemory({
+        onboardingActive: params.onboardingActive,
+        userMessageText,
+        hasAttachmentContext,
+        agentMessageCount: agentMessages.length,
+      })
+    : shouldEnqueueMemoryExtraction({ onboardingActive: params.onboardingActive, turnCount }) &&
+      userMessageText.length > 0
+
+  if (shouldExtractMemory) {
+    const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
+    await safeEnqueue(
+      () =>
+        enqueuePostChatMemory({
+          orgId: params.orgIdString,
+          workstreamId: params.workstreamIdString,
+          sourceId: params.referenceUserMessageId,
+          onboardStatus: readOptionalString((params.workspace as { onboardStatus?: unknown }).onboardStatus),
+          userMessage: memoryUserMessage,
+          historyMessages: historyMessagesForMemory,
+          agentMessages,
+          memoryBlock: params.memoryBlock.trim() ? params.memoryBlock : undefined,
+          attachmentContext: attachmentMetadataContext,
+        }),
+      { operationName: 'post-chat memory extraction enqueue' },
+    )
+  }
+
+  if (params.isUserTurn && params.referenceUserMessage) {
+    const conversationSummary = buildConversationSummary({
+      userMessageText,
+      assistantMessages: params.allAssistantMessages,
+    })
+    if (conversationSummary) {
+      const effectiveAgentId = params.visibleWorkstreamAgentId ?? params.defaultLeadAgentId
+      const recentActivityResult = await recentActivityService.recordEvent({
+        orgId: params.orgRef,
+        userId: params.userRef,
+        source: 'system',
+        event: {
+          sourceEventId: `chat-turn:${params.referenceUserMessageId}`,
+          kind: 'chat.turn.completed',
+          targetKind: 'workstream',
+          targetId: params.workstreamIdString,
+          mergeKey: `workstream:${params.workstreamIdString}`,
+          title: buildRecentActivityChatSystemTitle({
+            workstream: params.workstream,
+            visibleAgentId: effectiveAgentId,
+          }),
+          sourceLabel: agentDisplayNames[effectiveAgentId],
+          deepLink: buildRecentActivityChatDeepLink({
+            workstream: params.workstream,
+            workstreamId: params.workstreamIdString,
+            visibleAgentId: effectiveAgentId,
+          }),
+          metadata: {
+            agentId: effectiveAgentId,
+            agentName: agentDisplayNames[effectiveAgentId],
+            workstreamId: params.workstreamIdString,
+            workstreamTitle: params.latestWorkstreamRecord.title ?? params.workstream.title,
+            workstreamMode: params.workstream.mode,
+            ...(params.workstream.coreType ? { coreType: params.workstream.coreType } : {}),
+            userMessageText,
+            assistantSummary: conversationSummary,
+            messageId: params.referenceUserMessageId,
+          },
+          occurredAt: toIsoDateTimeString(params.referenceUserMessage.metadata?.createdAt ?? Date.now()),
+        },
+      })
+
+      await safeEnqueue(
+        async () => {
+          const enqueuePostChatOrgAction = getRuntimeAdapters().queues?.enqueuePostChatOrgAction
+          if (!enqueuePostChatOrgAction) {
+            return
+          }
+
+          await enqueuePostChatOrgAction({
+            orgId: params.orgIdString,
+            workstreamId: params.workstreamIdString,
+            sourceId: params.referenceUserMessageId,
+            sourceCreatedAt: params.referenceUserMessage?.metadata?.createdAt ?? Date.now(),
+            conversationSummary,
+          })
+        },
+        { operationName: 'post-chat org action enqueue' },
+      )
+
+      if (recentActivityService.isMeaningfulRefinementCandidate(recentActivityResult.item)) {
+        await safeEnqueue(() => enqueueRecentActivityTitleRefinement({ activityId: recentActivityResult.item.id }), {
+          operationName: 'recent activity title refinement enqueue',
+        })
+      }
+    }
+  }
+
+  if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: params.orgIdString }), {
+      operationName: 'regular chat memory digest enqueue',
+    })
+  }
+
+  if (shouldEnqueueSkillExtraction({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueSkillExtraction({ orgId: params.orgIdString }), {
+      operationName: 'skill extraction enqueue',
+    })
+  }
+
+  if (shouldEnqueueMemoryConsolidation({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueMemoryConsolidation({ scopeId: params.orgIdString }), {
+      operationName: 'memory consolidation enqueue',
+    })
+  }
+}
+
 export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams): Promise<PreparedWorkstreamTurn> {
   const { workstream, workstreamRef, orgRef, userRef, userName } = params
   const runtimeAdapters = getRuntimeAdapters()
@@ -320,7 +653,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   })
 
   let inputMessage: ChatMessage | undefined
-  const shouldPersistInputMessage = params.kind === 'userTurn' ? params.persistInputMessage !== false : false
+  const shouldPersistInputMessage = params.kind === 'userTurn' ? params.skipInputMessagePersistence !== true : false
   const shouldProcessPostRunSideEffects =
     params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn' || shouldPersistInputMessage
   if (params.kind === 'userTurn') {
@@ -373,7 +706,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       id: inputMessage.id || Bun.randomUUIDv7(),
       role: 'user',
       parts: inputMessage.parts,
-      metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) },
+      metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) ?? Date.now() },
     }
   }
 
@@ -395,14 +728,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       : validateUIMessages<ChatMessage>({
           messages: persistedLiveHistory,
           metadataSchema: messageMetadataSchema,
-          dataSchemas: dataPartsSchema,
+          dataSchemas: dataPartsSchemas,
         }).then((messages) => messages.map(hydrateMessageFileUrls)),
     persistedRecentHistory.length === 0
       ? Promise.resolve([] as ChatMessage[])
       : validateUIMessages<ChatMessage>({
           messages: persistedRecentHistory,
           metadataSchema: messageMetadataSchema,
-          dataSchemas: dataPartsSchema,
+          dataSchemas: dataPartsSchemas,
         }).then((messages) => messages.map(hydrateMessageFileUrls)),
   ])
   timer.step('validate+hydrate-history')
@@ -413,7 +746,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   }
 
   const originalMessages = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
-  const allAssistantMessages: ChatMessage[] = []
+  let allAssistantMessages: ChatMessage[] = []
   const referenceUserMessage =
     params.kind === 'userTurn' && !shouldPersistInputMessage
       ? [...liveHistory].reverse().find((m) => m.role === 'user')
@@ -437,14 +770,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   if (workstream.core && !workstream.coreType) {
     throw new WorkstreamTurnError('Core workstreams require a core type.', 400)
   }
-  const coreWorkstreamProfile: { config: { agentId: string }; instructions: string; skills?: string[] } | null =
-    workstream.core && workstream.coreType
-      ? (getCoreWorkstreamProfile(workstream.coreType) as unknown as {
-          config: { agentId: string }
-          instructions: string
-          skills?: string[]
-        })
-      : null
+  const coreWorkstreamProfile: CoreWorkstreamProfile | null =
+    workstream.core && workstream.coreType ? getCoreWorkstreamProfile(workstream.coreType) : null
   const defaultLeadAgentId = getLeadAgentId()
   const visibleWorkstreamAgentId =
     workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId)
@@ -626,7 +953,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
     const section = await learnedSkillService
       .retrieveForTurn({ orgId: orgIdString, agentId, query: messageText, limit: 3, minConfidence: 0.6 })
-      .catch((error: unknown) => {
+      .catch((error) => {
         aiLogger.warn`Failed to retrieve learned skills for ${agentId}: ${error}`
         return undefined
       })
@@ -697,175 +1024,33 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             })
 
             await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [committed] })
-            const currentMessageIndex = currentMessages.findIndex((item) => item.id === committed.id)
-            if (currentMessageIndex >= 0) {
-              currentMessages[currentMessageIndex] = committed
-            } else {
-              currentMessages = [...currentMessages, committed]
-            }
-
-            const assistantIndex = allAssistantMessages.findIndex((item) => item.id === committed.id)
-            if (assistantIndex >= 0) {
-              allAssistantMessages[assistantIndex] = committed
-            } else {
-              allAssistantMessages.push(committed)
-            }
+            currentMessages = upsertChatHistoryMessage(currentMessages, committed)
+            allAssistantMessages = upsertChatHistoryMessage(allAssistantMessages, committed)
 
             return committed
           }
 
-          const streamAgentResponse = async (streamParams: {
-            agentId: string
-            mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
-            messages: ChatMessage[]
-            tools: ToolSet
-            observer: ReturnType<typeof createObserver>
-            skills?: string[]
-            additionalInstructionSections?: string[]
-            writer?: UIMessageStreamWriter<ChatMessage>
-            stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>
-            prepareStep?: PrepareStepFunction<ToolSet>
-            abortSignal?: AbortSignal
-          }): Promise<ChatMessage> => {
-            const agentTimer = lotaDebugLogger.timer(`agent:${streamParams.agentId}`)
-            const executionPlanInstructionSections = await getExecutionPlanInstructionSections()
-            agentTimer.step('get-execution-plan')
-            const agentResolution = asRecord(
-              await turnHooks.resolveAgent?.({
-                agentId: streamParams.agentId,
-                mode: streamParams.mode,
-                workstream,
-                workstreamRef,
-                orgRef,
-                userRef,
-                userName,
-                onboardingActive,
-                linearInstalled,
-                githubInstalled,
-                reasoningProfile: reasoningProfile.name,
-                skills: streamParams.skills,
-                additionalInstructionSections: streamParams.additionalInstructionSections,
-                context: buildContextResult,
-              }),
-            )
-            agentTimer.step('hook:resolveAgent')
-            const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
-            const [preSeededMemoriesSection, workstreamStateSection, learnedSkillsSection] = await Promise.all([
-              getPreSeededMemoriesSection(resolvedAgentId),
-              getWorkstreamStateSection(),
-              getLearnedSkillsSection(resolvedAgentId),
-            ])
-            agentTimer.step('parallel-fetch(memories+state+skills)')
-            const config = getAgentRuntimeConfig({
-              agentId: resolvedAgentId,
-              workstreamMode: workstream.mode,
-              mode: streamParams.mode,
-              skills: streamParams.skills,
-              onboardingActive,
-              linearInstalled,
-              reasoningProfile: reasoningProfile.name,
-              systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-              preSeededMemoriesSection,
-              retrievedKnowledgeSection,
-              workstreamMemoryBlock: memoryBlock,
-              workstreamStateSection,
-              learnedSkillsSection,
-              additionalInstructionSections: mergeInstructionSections(
-                executionPlanInstructionSections,
-                streamParams.additionalInstructionSections,
-                hookInstructionSections,
-                readInstructionSections(agentResolution?.additionalInstructionSections),
-                optionalInstructionSection(agentResolution?.extraInstructions),
-              ),
-              context: buildContextResult,
-            }) as AgentRuntimeConfig
-            agentTimer.step('build-agent-config')
-            const modelMessages = await convertToModelMessages(streamParams.messages, {
-              ignoreIncompleteToolCalls: true,
-            })
-            agentTimer.step('convert-model-messages')
-            const agent = (createAgent as unknown as AgentFactory)[config.id as string]({
-              mode: streamParams.mode,
-              tools: streamParams.tools,
-              extraInstructions: config.extraInstructions,
-              stopWhen: (agentResolution?.stopWhen as
-                | StopCondition<ToolSet>
-                | Array<StopCondition<ToolSet>>
-                | undefined) ??
-                streamParams.stopWhen ?? [stepCountIs(config.maxSteps as number)],
-              prepareStep:
-                (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
-            })
-            const agentAbortSignal = streamParams.abortSignal ?? runAbort.signal
-            agentTimer.step('agent-construction')
-
-            let result: unknown
-            try {
-              result = await streamParams.observer.run(() =>
-                agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
-              )
-              agentTimer.step('agent.stream()-resolved')
-            } catch (error) {
-              if (agentAbortSignal.aborted) {
-                streamParams.observer.recordAbort(error)
-              } else {
-                streamParams.observer.recordError(error)
-              }
-              throw error
-            }
-            if (!hasUIMessageStream(result)) {
-              throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)
-            }
-
-            let responseMessage: ChatMessage | null = null
-            let resolveFinishedStream!: () => void
-            const finishedStream = new Promise<void>((resolve) => {
-              resolveFinishedStream = resolve
-            })
-
-            const uiStream = result.toUIMessageStream({
-              generateMessageId: () => Bun.randomUUIDv7(),
-              originalMessages: streamParams.messages,
-              sendReasoning: true,
-              sendSources: true,
-              messageMetadata: createAgentMessageMetadata({
-                agentId: resolvedAgentId,
-                agentName: config.displayName as string,
-              }),
-              onFinish: ({ responseMessage: finishedResponseMessage }: { responseMessage: ChatMessage }) => {
-                responseMessage = withMessageCreatedAt(finishedResponseMessage)
-                resolveFinishedStream()
-              },
-            }) as ReadableStream<ChatStreamChunk>
-            const reader = uiStream.getReader()
-            let firstChunkLogged = false
-            try {
-              for (;;) {
-                const { done, value } = await reader.read()
-                if (done) break
-                if (!firstChunkLogged) {
-                  agentTimer.step('first-stream-chunk')
-                  firstChunkLogged = true
-                }
-                if (streamParams.writer) {
-                  streamParams.writer.write(value)
-                }
-              }
-            } finally {
-              reader.releaseLock()
-            }
-            agentTimer.step('stream-complete')
-
-            const finalizedResponseMessage = await finishedStream.then(() => responseMessage)
-            if (finalizedResponseMessage === null) {
-              throw new Error(`Agent run for ${resolvedAgentId} did not produce a response message.`)
-            }
-
-            for (const toolError of collectToolOutputErrors({ responseMessage: finalizedResponseMessage })) {
-              aiLogger.warn`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
-            }
-
-            return finalizedResponseMessage
+          const streamCtx: StreamAgentResponseContext = {
+            turnHooks,
+            workstream,
+            workstreamRef,
+            orgRef,
+            userRef,
+            userName,
+            onboardingActive,
+            linearInstalled,
+            githubInstalled,
+            reasoningProfileName: reasoningProfile.name,
+            buildContextResult,
+            getExecutionPlanInstructionSections,
+            getPreSeededMemoriesSection,
+            getWorkstreamStateSection,
+            getLearnedSkillsSection,
+            promptContext,
+            retrievedKnowledgeSection,
+            memoryBlock,
+            hookInstructionSections,
+            runAbortSignal: runAbort.signal,
           }
 
           const runVisibleAgent = async (runParams: {
@@ -907,7 +1092,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               ...runParams.extraTools,
             }
             visibleTimer.step('build-agent-tools')
-            const responseMessage = await streamAgentResponse({
+            streamCtx.memoryBlock = memoryBlock
+            const responseMessage = await streamAgentResponse(streamCtx, {
               agentId: runParams.agentId,
               mode: runParams.mode,
               messages: buildRunInputMessages(runParams.extraMessages),
@@ -1126,14 +1312,15 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 contextCompactionRuntime.shouldCompactHistory({
                   summaryText,
                   liveMessages: messages,
-                  contextSize: CONTEXT_SIZE,
+                  contextSize: CONTEXT_WINDOW_TOKENS,
                 }),
-              enqueueCompaction: () =>
-                enqueueContextCompaction({
+              enqueueCompaction: async () => {
+                await enqueueContextCompaction({
                   domain: 'workstream',
                   entityId: workstreamIdString,
-                  contextSize: CONTEXT_SIZE,
-                }).then(() => {}),
+                  contextSize: CONTEXT_WINDOW_TOKENS,
+                })
+              },
               unregisterRun: (runId) => chatRunRegistry.unregister(runId),
               clearActiveRunId: (runId) => workstreamService.clearActiveRunIdIfMatches(workstreamRef, runId),
               disposeAbort: () => runAbort.dispose(),
@@ -1143,130 +1330,30 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             })
 
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
-              const turnCount = await workstreamService.incrementTurnCount(workstreamRef)
-              const agentMessages = buildAgentHistoryMessages(allAssistantMessages)
-              const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(
-                toHistoryMessages(recentHistory),
-                { compactionSummary: latestWorkstreamRecord.compactionSummary, persistedState: latestPersistedState },
-              )
-
-              const userMessageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
-              const readableUploads = listReadableUploads()
-              const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
-              const hasAttachmentContext = Boolean(attachmentMetadataContext)
-              const shouldExtractMemory = onboardingActive
-                ? shouldEnqueueOnboardingPostChatMemory({
-                    onboardingActive,
-                    userMessageText,
-                    hasAttachmentContext,
-                    agentMessageCount: agentMessages.length,
-                  })
-                : shouldEnqueueMemoryExtraction({ onboardingActive, turnCount }) && userMessageText.length > 0
-
-              if (shouldExtractMemory) {
-                const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
-                await safeEnqueue(
-                  () =>
-                    enqueuePostChatMemory({
-                      orgId: orgIdString,
-                      workstreamId: workstreamIdString,
-                      sourceId: referenceUserMessageId,
-                      onboardStatus: readOptionalString((workspace as { onboardStatus?: unknown }).onboardStatus),
-                      userMessage: memoryUserMessage,
-                      historyMessages: historyMessagesForMemory,
-                      agentMessages,
-                      memoryBlock: memoryBlock.trim() ? memoryBlock : undefined,
-                      attachmentContext: attachmentMetadataContext,
-                    }),
-                  { operationName: 'post-chat memory extraction enqueue' },
-                )
-              }
-
-              if (params.kind === 'userTurn' && referenceUserMessage) {
-                const conversationSummary = buildConversationSummary({
-                  userMessageText,
-                  assistantMessages: allAssistantMessages,
-                })
-                if (conversationSummary) {
-                  const recentActivityResult = await recentActivityService.recordEvent({
-                    orgId: orgRef,
-                    userId: userRef,
-                    source: 'system',
-                    event: {
-                      sourceEventId: `chat-turn:${referenceUserMessageId}`,
-                      kind: 'chat.turn.completed',
-                      targetKind: 'workstream',
-                      targetId: workstreamIdString,
-                      mergeKey: `workstream:${workstreamIdString}`,
-                      title: buildRecentActivityChatSystemTitle({
-                        workstream,
-                        visibleAgentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
-                      }),
-                      sourceLabel: agentDisplayNames[visibleWorkstreamAgentId ?? defaultLeadAgentId],
-                      deepLink: buildRecentActivityChatDeepLink({
-                        workstream,
-                        workstreamId: workstreamIdString,
-                        visibleAgentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
-                      }),
-                      metadata: {
-                        agentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
-                        agentName: agentDisplayNames[visibleWorkstreamAgentId ?? defaultLeadAgentId],
-                        workstreamId: workstreamIdString,
-                        workstreamTitle: latestWorkstreamRecord.title ?? workstream.title,
-                        workstreamMode: workstream.mode,
-                        ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
-                        userMessageText,
-                        assistantSummary: conversationSummary,
-                        messageId: referenceUserMessageId,
-                      },
-                      occurredAt: toIsoDateTimeString(referenceUserMessage.metadata?.createdAt ?? Date.now()),
-                    },
-                  })
-
-                  await safeEnqueue(
-                    async () => {
-                      const enqueuePostChatOrgAction = getRuntimeAdapters().queues?.enqueuePostChatOrgAction
-                      if (!enqueuePostChatOrgAction) {
-                        return
-                      }
-
-                      await enqueuePostChatOrgAction({
-                        orgId: orgIdString,
-                        workstreamId: workstreamIdString,
-                        sourceId: referenceUserMessageId,
-                        sourceCreatedAt: referenceUserMessage.metadata?.createdAt ?? Date.now(),
-                        conversationSummary,
-                      })
-                    },
-                    { operationName: 'post-chat org action enqueue' },
-                  )
-
-                  if (recentActivityService.isMeaningfulRefinementCandidate(recentActivityResult.item)) {
-                    await safeEnqueue(
-                      () => enqueueRecentActivityTitleRefinement({ activityId: recentActivityResult.item.id }),
-                      { operationName: 'recent activity title refinement enqueue' },
-                    )
-                  }
-                }
-              }
-
-              if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive, turnCount })) {
-                await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: orgIdString }), {
-                  operationName: 'regular chat memory digest enqueue',
-                })
-              }
-
-              if (shouldEnqueueSkillExtraction({ onboardingActive, turnCount })) {
-                await safeEnqueue(() => enqueueSkillExtraction({ orgId: orgIdString }), {
-                  operationName: 'skill extraction enqueue',
-                })
-              }
-
-              if (shouldEnqueueMemoryConsolidation({ onboardingActive, turnCount })) {
-                await safeEnqueue(() => enqueueMemoryConsolidation({ scopeId: orgIdString }), {
-                  operationName: 'memory consolidation enqueue',
-                })
-              }
+              await runPostTurnSideEffects({
+                workstream,
+                workstreamRef,
+                orgRef,
+                userRef,
+                userName,
+                orgIdString,
+                workstreamIdString,
+                onboardingActive,
+                workspace,
+                allAssistantMessages,
+                referenceUserMessage,
+                referenceUserMessageId,
+                recentHistory,
+                listReadableUploads: () => listReadableUploads(),
+                memoryBlock,
+                visibleWorkstreamAgentId,
+                defaultLeadAgentId,
+                latestWorkstreamRecord,
+                latestPersistedState,
+                turnHooks,
+                buildContextResult,
+                isUserTurn: params.kind === 'userTurn',
+              })
             }
 
             if (allAssistantMessages.length > 0) {