@lota-sdk/core 0.1.14 → 0.1.16

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

@@ -1,18 +1,20 @@
 import {
+  WORKSTREAM,
   baseChatMessageSchema,
   CONSULT_SPECIALIST_TOOL_NAME,
   CONSULT_TEAM_TOOL_NAME,
   ConsultSpecialistArgsSchema,
-  dataPartsSchema,
+  dataPartsSchemas,
   messageMetadataSchema,
   toTimestamp,
   withMessageCreatedAt,
 } from '@lota-sdk/shared'
 import type { ChatMessage, MessageMetadata } from '@lota-sdk/shared'
 import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
-import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
+import type { PrepareStepFunction, StopCondition, ToolLoopAgent, ToolSet, UIMessageStreamWriter } from 'ai'
 import type { z } from 'zod'
 
+import type { CoreWorkstreamProfile } from '../config/agent-defaults'
 import {
   agentDisplayNames,
   buildAgentTools,
@@ -20,7 +22,6 @@ import {
   getLeadAgentId,
   getCoreWorkstreamProfile,
   getAgentRuntimeConfig,
-  pluginRuntime,
 } from '../config/agent-defaults'
 import { lotaDebugLogger } from '../config/debug-logger'
 import { aiLogger } from '../config/logger'
@@ -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 {
@@ -54,6 +55,7 @@ import {
   shouldEnqueueOnboardingPostChatMemory,
   shouldEnqueueRegularDigestForWorkstream,
 } from '../runtime/memory-digest-policy'
+import { buildIndexedRepositoriesContext, getPluginService } from '../runtime/plugin-resolution'
 import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
 import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
@@ -81,16 +83,15 @@ 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'
+import { planRunService } from './plan-run.service'
 import { recentActivityService } from './recent-activity.service'
 import { workstreamMessageService } from './workstream-message.service'
 import { workstreamService } from './workstream.service'
 
-type AgentRuntimeConfig = Record<string, unknown>
-type AgentFactory = Record<string, (...args: unknown[]) => Record<string, (...args: unknown[]) => unknown>>
 type ChatStreamChunk = Parameters<UIMessageStreamWriter<ChatMessage>['write']>[0]
 
 interface UIMessageStreamResult {
@@ -105,45 +106,8 @@ function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
   )
 }
 
-function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
-  let current: unknown = pluginRuntime
-  let owner: unknown = undefined
-  for (const key of path) {
-    if (current === null || current === undefined || typeof current !== 'object') return undefined
-    owner = current
-    current = (current as Record<string, unknown>)[key]
-  }
-  if (typeof current !== 'function') {
-    return undefined
-  }
-
-  return owner && typeof owner === 'object'
-    ? (current as (...args: unknown[]) => unknown).bind(owner)
-    : (current as (...args: unknown[]) => unknown)
-}
-
-async function buildIndexedRepositoriesContext(
-  workspaceId: string,
-): Promise<{ provideRepoTool: boolean; defaultSectionsByAgent: Record<string, unknown>; context: string }> {
-  const buildContext = getRuntimeAdapters().workstream?.buildIndexedRepositoriesContext
-  if (!buildContext) {
-    return { provideRepoTool: false, defaultSectionsByAgent: {}, context: '' }
-  }
-
-  const context = await buildContext(workspaceId)
-  return {
-    provideRepoTool: context.provideRepoTool,
-    defaultSectionsByAgent: context.defaultSectionsByAgent,
-    context: context.context ?? '',
-  }
-}
-
 const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
 
-function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
-  return parseWorkstreamState(value)
-}
-
 function stripExecutionPlanFieldsFromWorkstreamState(
   state: WorkstreamState | null | undefined,
   hasExecutionPlan: boolean,
@@ -154,7 +118,7 @@ function stripExecutionPlanFieldsFromWorkstreamState(
 }
 
 async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
-  return await waitForCompactionIfNeeded({
+  return waitForCompactionIfNeeded({
     entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
     entityLabel: 'Workstream',
     loadEntity: () => workstreamService.getById(workstreamId),
@@ -231,7 +195,7 @@ export interface WorkstreamTurnParams {
   userRef: RecordIdRef
   userName?: string | null
   inputMessage: ChatMessage
-  persistInputMessage?: boolean
+  skipInputMessagePersistence?: boolean
   abortSignal?: AbortSignal
   streamId?: string
 }
@@ -256,7 +220,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 +264,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 Record<string, unknown>
+  agentTimer.step('build-agent-config')
+  const modelMessages = await convertToModelMessages(streamParams.messages, { ignoreIncompleteToolCalls: true })
+  agentTimer.step('convert-model-messages')
+  const agent = createAgent[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,
+  }) as ToolLoopAgent<never, ToolSet>
+  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, Date.now())
+      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.error`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,11 +616,11 @@ 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') {
-    inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage))
+    inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage, Date.now()))
     if (inputMessage.role !== 'user') {
       throw new WorkstreamTurnError('Only user messages can be submitted to the workstream runtime.', 400)
     }
@@ -358,7 +654,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     timer.step('persist-approval-message')
   }
 
-  const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
+  const initialWorkstreamState = parseWorkstreamState(workstreamRecord.state)
   const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
   const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
     workstreamRef,
@@ -370,7 +666,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   if (inputMessage) {
     userMessage = {
       ...inputMessage,
-      id: inputMessage.id || Bun.randomUUIDv7(),
+      id: inputMessage.id,
       role: 'user',
       parts: inputMessage.parts,
       metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) },
@@ -395,14 +691,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 +709,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')
@@ -425,6 +721,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     workstream.mode === 'group' &&
     !workstream.core &&
     workstreamRecord.nameGenerated !== true &&
+    workstreamRecord.title === WORKSTREAM.DEFAULT_TITLE &&
     messageText.length > 0
   ) {
     void safeEnqueue(
@@ -437,14 +734,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)
@@ -569,18 +860,21 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   let workstreamState = initialWorkstreamState
   const executionPlanInstructionSectionCache = createExecutionPlanInstructionSectionCache({
     disabled: onboardingActive,
-    loadPlan: async () => await executionPlanService.getActivePlanForWorkstream(workstreamRef),
+    loadPlans: async () => {
+      const runs = await planRunService.getActiveRunRecords(workstreamRef)
+      return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
+    },
   })
-  const getExecutionPlan = async () => await executionPlanInstructionSectionCache.getPlan()
+  const getExecutionPlans = async () => await executionPlanInstructionSectionCache.getPlans()
   const getExecutionPlanInstructionSections = async (): Promise<string[] | undefined> =>
     await executionPlanInstructionSectionCache.getSections()
   const invalidateExecutionPlanInstructionSections = () => {
     executionPlanInstructionSectionCache.invalidate()
   }
   const getWorkstreamStateSection = async (): Promise<string | undefined> => {
-    const executionPlan = await getExecutionPlan()
+    const executionPlans = await getExecutionPlans()
     return contextCompactionRuntime.formatWorkstreamStateForPrompt(
-      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, Boolean(executionPlan)),
+      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, executionPlans.length > 0),
     )
   }
   const respondedBy = recordIdToString(userRef, TABLES.USER)
@@ -626,7 +920,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
       })
@@ -691,181 +985,39 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           })
 
           const commitAssistantResponse = async (response: ChatMessage, agentId: string, agentName: string) => {
-            const committed = withMessageCreatedAt({
-              ...response,
-              metadata: { ...response.metadata, ...buildAgentMetadataPatch(agentId, agentName) },
-            })
+            const committed = withMessageCreatedAt(
+              { ...response, metadata: { ...response.metadata, ...buildAgentMetadataPatch(agentId, agentName) } },
+              Date.now(),
+            )
 
             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: {
@@ -878,6 +1030,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           }): Promise<ChatMessage> => {
             const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
+            const includeExecutionPlanTools = runParams.mode !== 'fixedWorkstreamMode' && !onboardingActive
             const tools: ToolSet = {
               ...((await buildAgentTools({
                 agentId: runParams.agentId,
@@ -899,7 +1052,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   runMemoryBlock = value
                 },
                 availableUploads: listReadableUploads(runParams.extraMessages),
-                includeExecutionPlanTools: runParams.mode !== 'fixedWorkstreamMode',
+                includeExecutionPlanTools,
                 onExecutionPlanChanged: invalidateExecutionPlanInstructionSections,
                 context: buildContextResult,
               })) as ToolSet),
@@ -907,7 +1060,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),
@@ -921,7 +1075,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             visibleTimer.step('stream-agent-response')
             memoryBlock = runMemoryBlock
 
-            return await commitAssistantResponse(
+            return commitAssistantResponse(
               responseMessage,
               runParams.agentId,
               agentDisplayNames[runParams.agentId] ?? runParams.agentId,
@@ -996,14 +1150,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   hookInstructionSections,
                 ),
                 context: buildContextResult,
-              }) as AgentRuntimeConfig
+              }) as Record<string, unknown>
               const observer = createObserver(agentId)
-              const agent = (createAgent as unknown as AgentFactory)[specialistConfig.id as string]({
+              const agent = createAgent[specialistConfig.id as string]({
                 mode: 'fixedWorkstreamMode',
                 tools: { ...(specialistTools as ToolSet), ...toolProviders },
                 extraInstructions: specialistConfig.extraInstructions,
                 stopWhen: [stepCountIs(specialistConfig.maxSteps as number)],
-              })
+              }) as ToolLoopAgent<never, ToolSet>
               const modelMessages = await convertToModelMessages(buildRunInputMessages([specialistTaskMessage]), {
                 ignoreIncompleteToolCalls: true,
               })
@@ -1039,7 +1193,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   }),
                 }) as ReadableStream<never>,
               })) {
-                finalMessage = withMessageCreatedAt(message)
+                finalMessage = withMessageCreatedAt(message, Date.now())
                 yield finalMessage
               }
 
@@ -1115,7 +1269,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         } finally {
           try {
             const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
-            const latestPersistedState = parsePersistedWorkstreamState(latestWorkstreamRecord.state)
+            const latestPersistedState = parseWorkstreamState(latestWorkstreamRecord.state)
 
             await finalizeTurnRun({
               serverRunId,
@@ -1126,14 +1280,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 +1298,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) {