@lota-sdk/core 0.1.5

package/src/services/workstream-turn-preparation.ts

@@ -0,0 +1,1340 @@
+import { toTimestamp, withMessageCreatedAt } from '@lota-sdk/shared/runtime/chat-message-metadata'
+import { baseChatMessageSchema } from '@lota-sdk/shared/schemas/chat-api'
+import { messageMetadataSchema, dataPartsSchema } from '@lota-sdk/shared/schemas/chat-message'
+import type { ChatMessage, MessageMetadata } from '@lota-sdk/shared/schemas/chat-message'
+import {
+  CONSULT_TEAM_TOOL_NAME,
+  CONSULT_SPECIALIST_TOOL_NAME,
+  ConsultSpecialistArgsSchema,
+} from '@lota-sdk/shared/schemas/tools'
+import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
+import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
+import type { z } from 'zod'
+
+import {
+  agentDisplayNames,
+  buildAgentTools,
+  createAgent,
+  getCoreWorkstreamProfile,
+  getAgentRuntimeConfig,
+  pluginRuntime,
+} from '../config/agent-defaults'
+import { aiLogger } from '../config/logger'
+import type { RecordIdRef } from '../db/record-id'
+import { recordIdToString } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import { enqueueContextCompaction } from '../queues/context-compaction.queue'
+import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
+import { enqueueRecentActivityTitleRefinement } from '../queues/recent-activity-title-refinement.queue'
+import { enqueueRegularChatMemoryDigest } from '../queues/regular-chat-memory-digest.queue'
+import { enqueueSkillExtraction } from '../queues/skill-extraction.queue'
+import { buildAgentPromptContext } from '../runtime/agent-prompt-context'
+import {
+  buildSpecialistTaskMessage,
+  createAgentMessageMetadata,
+  createServerRunAbortController,
+} from '../runtime/agent-stream-helpers'
+import { hasApprovalRespondedParts } from '../runtime/approval-continuation'
+import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../runtime/chat-attachments'
+import { hasMessageContent } from '../runtime/chat-message'
+import { waitForCompactionIfNeeded } from '../runtime/chat-run-orchestration'
+import { mergeStateDelta, parseWorkstreamState } from '../runtime/context-compaction'
+import { CONTEXT_SIZE } from '../runtime/context-compaction-constants'
+import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
+import { mergeInstructionSections } from '../runtime/instruction-sections'
+import {
+  shouldEnqueueOnboardingPostChatMemory,
+  shouldEnqueueRegularDigestForWorkstream,
+} from '../runtime/memory-digest-policy'
+import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
+import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
+import { finalizeTurnRun } from '../runtime/turn-lifecycle'
+import {
+  appendCompactionContextToHistoryMessages,
+  buildAgentHistoryMessages,
+  buildConversationSummary,
+  buildReadableUploadMetadataContext,
+  collectToolOutputErrors,
+  extractMessageText,
+  extractTrackerMessageText,
+  toHistoryMessages,
+  toOptionalTrimmedString,
+} from '../runtime/workstream-chat-helpers'
+import {
+  classifyHighImpactResponse,
+  classifyPolicyClasses,
+  resolveReasoningProfile,
+} from '../runtime/workstream-routing-policy'
+import { WorkstreamStateSchema } from '../runtime/workstream-state'
+import type { WorkstreamState, WorkstreamStateDelta } from '../runtime/workstream-state'
+import { chatRunRegistry } from '../services/chat-run-registry.service'
+import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
+import { createTeamThinkTool } from '../tools/team-think.tool'
+import { safeEnqueue } from '../utils/async'
+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 { executionPlanService } from './execution-plan.service'
+import { learnedSkillService } from './learned-skill.service'
+import { memoryService } from './memory.service'
+import { recentActivityService } from './recent-activity.service'
+import { updateWorkstreamChangeTracker } from './workstream-change-tracker.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 {
+  toUIMessageStream(options: Record<string, unknown>): ReadableStream<unknown>
+}
+
+export function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { toUIMessageStream?: unknown }).toUIMessageStream === 'function'
+  )
+}
+
+export 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)
+}
+
+export 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
+
+export function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
+  return parseWorkstreamState(value)
+}
+
+export function extractFirstAbsoluteUrl(text: string): URL | null {
+  const match = text.match(/https?:\/\/[^\s)]+/i)
+  if (!match) return null
+
+  const normalized = match[0].replace(/[.,;!?]+$/g, '')
+  try {
+    return new URL(normalized)
+  } catch {
+    return null
+  }
+}
+
+export function taskRequestsWebsiteRefresh(task: string, forceRefresh: boolean): boolean {
+  return forceRefresh || /\b(refresh|re-run|rerun|run again|extract again|re-extract|overwrite|recrawl)\b/i.test(task)
+}
+
+export function buildInspectWebsiteTrackerTitle(input: unknown): string {
+  if (!input || typeof input !== 'object') return 'Inspect website intelligence'
+
+  const task = typeof (input as { task?: unknown }).task === 'string' ? (input as { task: string }).task.trim() : ''
+  const forceRefresh = (input as { forceRefresh?: unknown }).forceRefresh === true
+  const hostname = extractFirstAbsoluteUrl(task)?.hostname.replace(/^www\./, '') ?? null
+
+  if (hostname && taskRequestsWebsiteRefresh(task, forceRefresh)) {
+    return `Overwrite website-intelligence artifacts for ${hostname}`
+  }
+  if (hostname) {
+    return `Inspect website intelligence for ${hostname}`
+  }
+  return taskRequestsWebsiteRefresh(task, forceRefresh)
+    ? 'Overwrite website-intelligence artifacts'
+    : 'Inspect website intelligence'
+}
+
+export function emitTransientWorkstreamTrackerState(params: {
+  writer?: UIMessageStreamWriter<ChatMessage>
+  workstreamRecord: WorkstreamRecord
+  existingState: WorkstreamState
+  delta: WorkstreamStateDelta
+}): WorkstreamState {
+  const nextState = mergeStateDelta(params.existingState, params.delta, () => Date.now())
+
+  if (params.writer) {
+    params.writer.write({
+      type: 'data-workstreamTracker',
+      data: workstreamService.toPublicWorkstreamDetail({ ...params.workstreamRecord, state: nextState })
+        .workstreamState as unknown as Record<string, unknown>,
+      transient: true,
+    })
+  }
+
+  return nextState
+}
+
+export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
+  return await waitForCompactionIfNeeded({
+    entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
+    entityLabel: 'Workstream',
+    loadEntity: () => workstreamService.getById(workstreamId),
+    isCompacting: (workstream) => workstream.isCompacting === true,
+  })
+}
+
+export function parseChatMessageCandidate(value: unknown): ChatMessage | undefined {
+  const parsed = baseChatMessageSchema.safeParse(value)
+  if (!parsed.success) return undefined
+  return parsed.data as ChatMessage
+}
+
+export function getChatMessageFromToolOutput(output: unknown): ChatMessage | undefined {
+  const directCandidate = parseChatMessageCandidate(output)
+  if (directCandidate) return directCandidate
+
+  if (Array.isArray(output)) {
+    for (let index = output.length - 1; index >= 0; index -= 1) {
+      const candidate = getChatMessageFromToolOutput(output[index])
+      if (candidate) return candidate
+    }
+  }
+
+  if (output && typeof output === 'object' && 'message' in output) {
+    return getChatMessageFromToolOutput((output as { message?: unknown }).message)
+  }
+
+  return undefined
+}
+
+export class WorkstreamTurnError extends AppError {
+  constructor(
+    message: string,
+    readonly statusCode: 400 | 409,
+  ) {
+    super(message, statusCode === 409 ? 'CONFLICT' : 'BAD_REQUEST', statusCode)
+    this.name = 'WorkstreamTurnError'
+  }
+}
+
+export function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : null
+}
+
+export function readOptionalString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value : undefined
+}
+
+export function readOptionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined
+}
+
+export function readInstructionSections(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value
+    .filter((section): section is string => typeof section === 'string')
+    .map((section) => section.trim())
+    .filter((section) => section.length > 0)
+}
+
+export function optionalInstructionSection(value: unknown): string[] | undefined {
+  const section = readOptionalString(value)
+  return section ? [section] : undefined
+}
+
+export interface WorkstreamTurnParams {
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  inputMessage: ChatMessage
+  persistInputMessage?: boolean
+  abortSignal?: AbortSignal
+}
+
+export interface WorkstreamApprovalContinuationParams {
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  approvalMessages: ChatMessage[]
+  abortSignal?: AbortSignal
+}
+
+export type WorkstreamRunCoreParams = {
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  abortSignal?: AbortSignal
+} & (
+  | { kind: 'userTurn'; inputMessage: ChatMessage; persistInputMessage?: boolean }
+  | { kind: 'approvalContinuation'; approvalMessages: ChatMessage[] }
+)
+
+export interface PreparedWorkstreamTurn {
+  originalMessages: ChatMessage[]
+  run: (writer?: UIMessageStreamWriter<ChatMessage>) => Promise<void>
+}
+
+export function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: ChatMessage): ChatMessage[] {
+  const existingIndex = messages.findIndex((message) => message.id === nextMessage.id)
+  if (existingIndex === -1) {
+    return [...messages, nextMessage]
+  }
+
+  const nextMessages = [...messages]
+  nextMessages[existingIndex] = nextMessage
+  return nextMessages
+}
+
+export function buildRecentActivityChatDeepLink(params: {
+  workstream: NormalizedWorkstream
+  workstreamId: string
+  visibleAgentId: string
+}): { route: '/chat'; search: { chat?: string; agent?: string; tab: 'cos' | 'team' | 'workstreams' } } {
+  if (params.workstream.mode === 'direct') {
+    return {
+      route: '/chat',
+      search: { agent: params.visibleAgentId, tab: params.visibleAgentId === 'chief' ? 'cos' : 'team' },
+    }
+  }
+
+  return { route: '/chat', search: { chat: params.workstreamId, tab: 'workstreams' } }
+}
+
+export function buildRecentActivityChatSystemTitle(params: {
+  workstream: NormalizedWorkstream
+  visibleAgentId: string
+}): string {
+  if (params.workstream.mode === 'direct') {
+    return `Conversation with ${agentDisplayNames[params.visibleAgentId]}`
+  }
+
+  return params.workstream.title.trim() || 'Workstream update'
+}
+
+export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams): Promise<PreparedWorkstreamTurn> {
+  const { workstream, workstreamRef, orgRef, userRef, userName } = params
+  const runtimeAdapters = getRuntimeAdapters()
+  const turnHooks = getTurnHooks()
+  const toolProviders = getToolProviders()
+  const workspaceProvider = runtimeAdapters.services?.workspaceProvider
+  const orgIdString = recordIdToString(orgRef, TABLES.ORGANIZATION)
+  const userIdString = recordIdToString(userRef, TABLES.USER)
+  const workstreamIdString = recordIdToString(workstreamRef, TABLES.WORKSTREAM)
+
+  const hydrateMessageFileUrls = (message: ChatMessage): ChatMessage => ({
+    ...message,
+    parts: attachmentService.hydrateSignedFileUrlsInMessageParts({
+      parts: message.parts as Array<Record<string, unknown>>,
+      orgId: orgRef,
+      userId: userRef,
+    }) as ChatMessage['parts'],
+  })
+
+  let inputMessage: ChatMessage | undefined
+  const shouldPersistInputMessage = params.kind === 'userTurn' ? params.persistInputMessage !== false : false
+  const shouldProcessPostRunSideEffects = params.kind === 'approvalContinuation' || shouldPersistInputMessage
+  if (params.kind === 'userTurn') {
+    inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage))
+    if (inputMessage.role !== 'user') {
+      throw new WorkstreamTurnError('Only user messages can be submitted to the workstream runtime.', 400)
+    }
+    if (!hasMessageContent(inputMessage.parts)) {
+      throw new WorkstreamTurnError('Workstream messages must include text or attachments.', 400)
+    }
+    if (workstream.mode === 'direct' && !workstream.agentId) {
+      throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
+    }
+  }
+
+  const workstreamRecord = await waitForWorkstreamCompactionIfNeeded(workstreamRef)
+  if (toOptionalTrimmedString(workstreamRecord.activeRunId)) {
+    throw new WorkstreamTurnError('A chat run is already active.', 409)
+  }
+
+  if (params.kind === 'approvalContinuation') {
+    const approvedAssistantMessage = [...params.approvalMessages]
+      .reverse()
+      .find((m) => m.role === 'assistant' && hasApprovalRespondedParts(m))
+    if (!approvedAssistantMessage) {
+      throw new WorkstreamTurnError('No approval-responded message found.', 400)
+    }
+    await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [approvedAssistantMessage] })
+  }
+
+  const workspacePromise = workspaceProvider ? workspaceProvider.getWorkspace(orgRef) : Promise.resolve({})
+  const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
+  const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
+    workstreamRef,
+    toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined,
+  )
+  const persistedRecentHistoryPromise = workstreamMessageService.listRecentMessages(workstreamRef, 64)
+
+  let userMessage: ChatMessage | undefined
+  if (inputMessage) {
+    userMessage = {
+      ...inputMessage,
+      id: inputMessage.id || Bun.randomUUIDv7(),
+      role: 'user',
+      parts: inputMessage.parts,
+      metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) },
+    }
+  }
+
+  const [workspace, persistedLiveHistory, persistedRecentHistory] = await Promise.all([
+    workspacePromise,
+    persistedLiveHistoryPromise,
+    persistedRecentHistoryPromise,
+  ])
+  const workspaceLifecycleState = workspaceProvider ? await workspaceProvider.getLifecycleState?.(workspace) : undefined
+  const workspaceProfileState = workspaceProvider
+    ? await workspaceProvider.readProfileProjectionState?.(workspace)
+    : undefined
+  const [liveHistory, recentHistory] = await Promise.all([
+    persistedLiveHistory.length === 0
+      ? Promise.resolve([] as ChatMessage[])
+      : validateUIMessages<ChatMessage>({
+          messages: persistedLiveHistory,
+          metadataSchema: messageMetadataSchema,
+          dataSchemas: dataPartsSchema,
+        }).then((messages) => messages.map(hydrateMessageFileUrls)),
+    persistedRecentHistory.length === 0
+      ? Promise.resolve([] as ChatMessage[])
+      : validateUIMessages<ChatMessage>({
+          messages: persistedRecentHistory,
+          metadataSchema: messageMetadataSchema,
+          dataSchemas: dataPartsSchema,
+        }).then((messages) => messages.map(hydrateMessageFileUrls)),
+  ])
+
+  if (userMessage && shouldPersistInputMessage) {
+    await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [userMessage] })
+  }
+
+  const originalMessages = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
+  const allAssistantMessages: ChatMessage[] = []
+  const referenceUserMessage =
+    params.kind === 'userTurn' && !shouldPersistInputMessage
+      ? [...liveHistory].reverse().find((m) => m.role === 'user')
+      : (userMessage ?? [...liveHistory].reverse().find((m) => m.role === 'user'))
+  const messageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
+  const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
+  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 visibleWorkstreamAgentId =
+    workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? 'chief')
+  const coreInstructionSections = coreWorkstreamProfile ? [coreWorkstreamProfile.instructions] : undefined
+  const getLinearInstallationByOrgId = getPluginService([
+    'linear',
+    'services',
+    'linearService',
+    'getInstallationByOrgId',
+  ])
+  const getGithubInstallationForOrganization = getPluginService([
+    'github',
+    'services',
+    'githubService',
+    'getInstallationForOrganization',
+  ])
+
+  const highImpactAssessment = classifyHighImpactResponse({ message: messageText })
+  const policyAssessment = classifyPolicyClasses({ message: messageText })
+  const reasoningProfile = resolveReasoningProfile({
+    message: messageText,
+    forceDeep: highImpactAssessment.classes.length > 0 || policyAssessment.classes.length > 0,
+    explicitProfile: onboardingActive ? 'standard' : undefined,
+  })
+
+  const [linearInstallation, githubInstallation, indexedRepoContext, recentDomainEvents, promptSummary] =
+    await Promise.all([
+      getLinearInstallationByOrgId ? (getLinearInstallationByOrgId(orgRef) as Promise<unknown>) : Promise.resolve(null),
+      getGithubInstallationForOrganization
+        ? (getGithubInstallationForOrganization(orgIdString) as Promise<unknown>)
+        : Promise.resolve(null),
+      buildIndexedRepositoriesContext(orgIdString),
+      workspaceProvider?.listRecentDomainEvents?.(orgRef, 5) ?? Promise.resolve([] as Array<Record<string, unknown>>),
+      workspaceProvider?.buildPromptSummary
+        ? workspaceProvider.buildPromptSummary(orgRef).catch(() => undefined)
+        : Promise.resolve(undefined),
+    ])
+  let linearInstalled = Boolean(linearInstallation)
+  let githubInstalled = Boolean(githubInstallation)
+  let promptContext = buildAgentPromptContext({
+    workspaceName: workspaceProfileState?.workspaceName ?? readOptionalString((workspace as { name?: unknown }).name),
+    summaryBlock: workspaceProfileState?.summaryBlock,
+    structuredProfile: workspaceProfileState?.structuredProfile,
+    promptSummary,
+    userName: userName ?? undefined,
+    recentDomainEvents,
+  })
+  let retrievedKnowledgeSection: string | undefined =
+    onboardingActive || !messageText
+      ? undefined
+      : await workspaceProvider?.buildRetrievedKnowledgeSection?.({
+          workspaceId: orgIdString,
+          userId: userIdString,
+          query: messageText,
+        })
+  const buildContextResult = asRecord(
+    await turnHooks.buildContext?.({
+      workstream,
+      workstreamRef,
+      orgRef,
+      userRef,
+      userName,
+      workspace,
+      onboardingActive,
+      messageText,
+      linearInstalled,
+      githubInstalled,
+      indexedRepoContext,
+      promptContext,
+      workspaceLifecycleState,
+      workspaceProfileState,
+      promptSummary,
+      recentDomainEvents,
+      retrievedKnowledgeSection,
+    }),
+  )
+  const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
+  if (buildContextPromptDetails) {
+    promptContext = { systemWorkspaceDetails: buildContextPromptDetails }
+  }
+  const buildContextRetrievedKnowledge = readOptionalString(buildContextResult?.retrievedKnowledgeSection)
+  if (buildContextRetrievedKnowledge !== undefined) {
+    retrievedKnowledgeSection = buildContextRetrievedKnowledge
+  }
+  const buildContextLinearInstalled = readOptionalBoolean(buildContextResult?.linearInstalled)
+  if (buildContextLinearInstalled !== undefined) {
+    linearInstalled = buildContextLinearInstalled
+  }
+  const buildContextGithubInstalled = readOptionalBoolean(buildContextResult?.githubInstalled)
+  if (buildContextGithubInstalled !== undefined) {
+    githubInstalled = buildContextGithubInstalled
+  }
+  const hookInstructionSections = readInstructionSections(
+    await turnHooks.buildExtraInstructionSections?.({
+      workstream,
+      workstreamRef,
+      orgRef,
+      userRef,
+      userName,
+      workspace,
+      onboardingActive,
+      messageText,
+      linearInstalled,
+      githubInstalled,
+      indexedRepoContext,
+      promptContext,
+      workspaceLifecycleState,
+      workspaceProfileState,
+      promptSummary,
+      recentDomainEvents,
+      retrievedKnowledgeSection,
+      context: buildContextResult,
+    }),
+  )
+
+  let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
+  let workstreamState = initialWorkstreamState
+  const executionPlanInstructionSectionCache = createExecutionPlanInstructionSectionCache({
+    disabled: onboardingActive,
+    loadPlan: async () => await executionPlanService.getActivePlanForWorkstream(workstreamRef),
+  })
+  const getExecutionPlanInstructionSections = async (): Promise<string[] | undefined> =>
+    await executionPlanInstructionSectionCache.getSections()
+  const invalidateExecutionPlanInstructionSections = () => {
+    executionPlanInstructionSectionCache.invalidate()
+  }
+  const preSeededMemoriesByAgent = new Map<string, string | undefined>()
+  const getPreSeededMemoriesSection = async (agentId: string): Promise<string | undefined> => {
+    if (preSeededMemoriesByAgent.has(agentId)) {
+      return preSeededMemoriesByAgent.get(agentId)
+    }
+
+    const preSeededMemories = await memoryService.getTopMemories({
+      orgId: orgIdString,
+      agentName: agentId,
+      limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
+    })
+    preSeededMemoriesByAgent.set(agentId, preSeededMemories)
+    return preSeededMemories
+  }
+
+  const learnedSkillsByAgent = new Map<string, string | undefined>()
+  const getLearnedSkillsSection = async (agentId: string): Promise<string | undefined> => {
+    if (onboardingActive) return undefined
+    if (learnedSkillsByAgent.has(agentId)) return learnedSkillsByAgent.get(agentId)
+
+    const section = await learnedSkillService
+      .retrieveForTurn({ orgId: orgIdString, agentId, query: messageText, limit: 3, minConfidence: 0.6 })
+      .catch((error: unknown) => {
+        aiLogger.warn`Failed to retrieve learned skills for ${agentId}: ${error}`
+        return undefined
+      })
+    learnedSkillsByAgent.set(agentId, section)
+    return section
+  }
+
+  const persistedChatSummary = typeof workstreamRecord.chatSummary === 'string' ? workstreamRecord.chatSummary : ''
+  const messagesForContext = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
+  let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedChatSummary, messagesForContext)
+  const referenceUserMessageId = referenceUserMessage?.id ?? ''
+  const listReadableUploads = (extraMessages: ChatMessage[] = []) =>
+    listReadableUploadsFromChatMessages({
+      messages: [...currentMessages, ...extraMessages],
+      orgId: orgRef,
+      userId: userRef,
+    })
+  const buildRunInputMessages = (extraMessages: ChatMessage[] = []): ChatMessage[] =>
+    buildModelInputMessagesWithUploadMetadata({
+      messages: [...currentMessages, ...extraMessages],
+      latestUserMessageId: referenceUserMessageId,
+      uploadMetadataText: buildReadableUploadMetadataText(listReadableUploads(extraMessages)),
+    })
+
+  return {
+    originalMessages,
+    run: async (writer?: UIMessageStreamWriter<ChatMessage>) => {
+      const executeRun = async () => {
+        const serverRunId = Bun.randomUUIDv7()
+        const runAbort = createServerRunAbortController(params.abortSignal)
+        await workstreamService.setActiveRunId(workstreamRef, serverRunId)
+        chatRunRegistry.register(serverRunId, runAbort.controller)
+
+        try {
+          const buildAgentMetadataPatch = (agentId: string, agentName: string): NonNullable<MessageMetadata> => ({
+            agentId,
+            agentName,
+            reasoningProfile: reasoningProfile.name,
+            highImpactClasses: highImpactAssessment.classes,
+            policyClasses: policyAssessment.classes,
+            semanticTerminationReason: 'none',
+          })
+
+          const createObserver = (agentId: string) => ({
+            run: <T>(fn: () => T | Promise<T>) => Promise.resolve(fn()),
+            recordError: (error: unknown) => {
+              aiLogger.error`Agent run failed (agent=${agentId}): ${error}`
+            },
+            recordAbort: (error: unknown) => {
+              aiLogger.info`Agent run aborted (agent=${agentId}): ${error instanceof Error ? error.message : String(error)}`
+            },
+          })
+
+          const commitAssistantResponse = async (response: ChatMessage, agentId: string, agentName: string) => {
+            const committed = withMessageCreatedAt({
+              ...response,
+              metadata: { ...response.metadata, ...buildAgentMetadataPatch(agentId, agentName) },
+            })
+
+            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)
+            }
+
+            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 executionPlanInstructionSections = await getExecutionPlanInstructionSections()
+            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,
+              }),
+            )
+            const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
+            const config = getAgentRuntimeConfig({
+              agentId: resolvedAgentId,
+              workstreamMode: workstream.mode,
+              mode: streamParams.mode,
+              skills: streamParams.skills,
+              onboardingActive,
+              linearInstalled,
+              reasoningProfile: reasoningProfile.name,
+              systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+              preSeededMemoriesSection: await getPreSeededMemoriesSection(resolvedAgentId),
+              retrievedKnowledgeSection,
+              workstreamMemoryBlock: memoryBlock,
+              workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
+              learnedSkillsSection: await getLearnedSkillsSection(resolvedAgentId),
+              additionalInstructionSections: mergeInstructionSections(
+                executionPlanInstructionSections,
+                streamParams.additionalInstructionSections,
+                hookInstructionSections,
+                readInstructionSections(agentResolution?.additionalInstructionSections),
+                optionalInstructionSection(agentResolution?.extraInstructions),
+              ),
+              context: buildContextResult,
+            }) as AgentRuntimeConfig
+            const modelMessages = await convertToModelMessages(streamParams.messages, {
+              ignoreIncompleteToolCalls: true,
+            })
+            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
+
+            let result: unknown
+            try {
+              result = await streamParams.observer.run(() =>
+                agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
+              )
+            } 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 liveTrackerState: WorkstreamState = workstreamState ?? parseWorkstreamState(null)
+            const liveTrackedToolCalls = new Map<string, string>()
+            try {
+              for (;;) {
+                const { done, value } = await reader.read()
+                if (done) break
+                if (streamParams.writer) {
+                  streamParams.writer.write(value)
+                }
+                if (value.type === 'tool-input-available' && value.toolName === 'inspectWebsite') {
+                  const title = buildInspectWebsiteTrackerTitle(value.input)
+                  liveTrackedToolCalls.set(value.toolCallId, title)
+                  liveTrackerState = emitTransientWorkstreamTrackerState({
+                    writer: streamParams.writer,
+                    workstreamRecord,
+                    existingState: liveTrackerState,
+                    delta: {
+                      taskUpdates: [
+                        {
+                          title,
+                          status: 'in-progress',
+                          owner: streamParams.agentId,
+                          externalId: value.toolCallId,
+                          sourceMessageIds: [],
+                        },
+                      ],
+                    },
+                  })
+                }
+                if (
+                  value.type === 'tool-output-available' &&
+                  value.preliminary !== true &&
+                  liveTrackedToolCalls.has(value.toolCallId)
+                ) {
+                  liveTrackerState = emitTransientWorkstreamTrackerState({
+                    writer: streamParams.writer,
+                    workstreamRecord,
+                    existingState: liveTrackerState,
+                    delta: {
+                      taskUpdates: [
+                        {
+                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
+                          status: 'done',
+                          owner: streamParams.agentId,
+                          externalId: value.toolCallId,
+                          sourceMessageIds: [],
+                        },
+                      ],
+                    },
+                  })
+                  liveTrackedToolCalls.delete(value.toolCallId)
+                }
+                if (
+                  (value.type === 'tool-output-error' || value.type === 'tool-output-denied') &&
+                  liveTrackedToolCalls.has(value.toolCallId)
+                ) {
+                  liveTrackerState = emitTransientWorkstreamTrackerState({
+                    writer: streamParams.writer,
+                    workstreamRecord,
+                    existingState: liveTrackerState,
+                    delta: {
+                      taskUpdates: [
+                        {
+                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
+                          status: 'blocked',
+                          owner: streamParams.agentId,
+                          externalId: value.toolCallId,
+                          sourceMessageIds: [],
+                        },
+                      ],
+                    },
+                  })
+                  liveTrackedToolCalls.delete(value.toolCallId)
+                }
+              }
+            } finally {
+              reader.releaseLock()
+            }
+
+            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 runVisibleAgent = async (runParams: {
+            agentId: string
+            mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+            skills?: string[]
+            additionalInstructionSections?: string[]
+            extraMessages?: ChatMessage[]
+            extraTools?: ToolSet
+          }): Promise<ChatMessage> => {
+            let runMemoryBlock = memoryBlock
+            const tools: ToolSet = {
+              ...((await buildAgentTools({
+                agentId: runParams.agentId,
+                orgId: orgRef,
+                userId: userRef,
+                userName: userName ?? 'there',
+                workstreamId: workstreamRef,
+                orgIdString,
+                workstreamMode: workstream.mode,
+                mode: runParams.mode,
+                linearInstalled,
+                onboardingActive,
+                githubInstalled,
+                provideRepoTool: indexedRepoContext.provideRepoTool,
+                skills: runParams.skills,
+                defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[runParams.agentId],
+                memoryBlock: runMemoryBlock,
+                onAppendMemoryBlock: (value: string) => {
+                  runMemoryBlock = value
+                },
+                availableUploads: listReadableUploads(runParams.extraMessages),
+                includeExecutionPlanTools: runParams.mode !== 'fixedWorkstreamMode',
+                onExecutionPlanChanged: invalidateExecutionPlanInstructionSections,
+                context: buildContextResult,
+              })) as ToolSet),
+              ...toolProviders,
+              ...runParams.extraTools,
+            }
+            const responseMessage = await streamAgentResponse({
+              agentId: runParams.agentId,
+              mode: runParams.mode,
+              messages: buildRunInputMessages(runParams.extraMessages),
+              tools,
+              observer: createObserver(runParams.agentId),
+              skills: runParams.skills,
+              additionalInstructionSections: runParams.additionalInstructionSections,
+              writer,
+            })
+
+            memoryBlock = runMemoryBlock
+
+            return await commitAssistantResponse(
+              responseMessage,
+              runParams.agentId,
+              agentDisplayNames[runParams.agentId] ?? runParams.agentId,
+            )
+          }
+
+          const consultSpecialistTool = createTool({
+            description: 'Consult one specialist teammate for domain-specific guidance before replying to the user.',
+            inputSchema: ConsultSpecialistArgsSchema,
+            execute: async function* (
+              { agentId, task }: z.infer<typeof ConsultSpecialistArgsSchema>,
+              { abortSignal: toolAbortSignal }: { abortSignal?: AbortSignal },
+            ) {
+              let specialistMemoryBlock = memoryBlock
+              const specialistTaskMessage = buildSpecialistTaskMessage({ agentId, task })
+              const specialistTools = await buildAgentTools({
+                agentId,
+                orgId: orgRef,
+                userId: userRef,
+                userName: userName ?? 'there',
+                workstreamId: workstreamRef,
+                orgIdString,
+                workstreamMode: workstream.mode,
+                mode: 'fixedWorkstreamMode',
+                linearInstalled,
+                onboardingActive,
+                githubInstalled,
+                provideRepoTool: indexedRepoContext.provideRepoTool,
+                defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[agentId],
+                memoryBlock: specialistMemoryBlock,
+                onAppendMemoryBlock: (value: string) => {
+                  specialistMemoryBlock = value
+                },
+                availableUploads: listReadableUploads([specialistTaskMessage]),
+                includeExecutionPlanTools: false,
+                context: buildContextResult,
+              })
+
+              const specialistExecutionPlanInstructionSections = await getExecutionPlanInstructionSections()
+              const specialistConfig = getAgentRuntimeConfig({
+                agentId,
+                workstreamMode: workstream.mode,
+                mode: 'fixedWorkstreamMode',
+                onboardingActive,
+                linearInstalled,
+                reasoningProfile: reasoningProfile.name,
+                systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+                preSeededMemoriesSection: await getPreSeededMemoriesSection(agentId),
+                retrievedKnowledgeSection,
+                workstreamMemoryBlock: specialistMemoryBlock,
+                workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
+                learnedSkillsSection: await getLearnedSkillsSection(agentId),
+                additionalInstructionSections: mergeInstructionSections(
+                  specialistExecutionPlanInstructionSections,
+                  coreInstructionSections,
+                  hookInstructionSections,
+                ),
+                context: buildContextResult,
+              }) as AgentRuntimeConfig
+              const observer = createObserver(agentId)
+              const agent = (createAgent as unknown as AgentFactory)[specialistConfig.id as string]({
+                mode: 'fixedWorkstreamMode',
+                tools: { ...(specialistTools as ToolSet), ...toolProviders },
+                extraInstructions: specialistConfig.extraInstructions,
+                stopWhen: [stepCountIs(specialistConfig.maxSteps as number)],
+              })
+              const modelMessages = await convertToModelMessages(buildRunInputMessages([specialistTaskMessage]), {
+                ignoreIncompleteToolCalls: true,
+              })
+              const specialistAbortSignal = toolAbortSignal ?? runAbort.signal
+              let result: unknown
+              try {
+                result = await observer.run(() =>
+                  agent.stream({ messages: modelMessages, abortSignal: specialistAbortSignal }),
+                )
+              } catch (error) {
+                if (specialistAbortSignal.aborted) {
+                  observer.recordAbort(error)
+                } else {
+                  observer.recordError(error)
+                }
+                throw error
+              }
+              if (!hasUIMessageStream(result)) {
+                throw new Error(`Specialist ${agentId} did not expose a UI message stream.`)
+              }
+
+              let finalMessage: ChatMessage | null = null
+              for await (const message of readUIMessageStream<ChatMessage>({
+                stream: result.toUIMessageStream({
+                  generateMessageId: () => Bun.randomUUIDv7(),
+                  sendReasoning: true,
+                  sendSources: true,
+                  sendStart: false,
+                  sendFinish: false,
+                  messageMetadata: createAgentMessageMetadata({
+                    agentId,
+                    agentName: specialistConfig.displayName as string,
+                  }),
+                }) as ReadableStream<never>,
+              })) {
+                finalMessage = withMessageCreatedAt(message)
+                yield finalMessage
+              }
+
+              if (!finalMessage) {
+                throw new Error(`Specialist ${agentId} did not produce a response message.`)
+              }
+
+              for (const toolError of collectToolOutputErrors({ responseMessage: finalMessage })) {
+                aiLogger.warn`Tool execution failed (agent=${agentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
+              }
+
+              memoryBlock = specialistMemoryBlock
+              return finalMessage
+            },
+            toModelOutput: ({ output }) => {
+              const result = getChatMessageFromToolOutput(output)
+              const agentName =
+                typeof result?.metadata?.agentName === 'string' && result.metadata.agentName.trim().length > 0
+                  ? result.metadata.agentName.trim()
+                  : 'Specialist'
+              const summary = result ? extractMessageText(result).trim() : ''
+              return {
+                type: 'text',
+                value: summary ? `${agentName}: ${summary}` : `${agentName} completed the requested task.`,
+              }
+            },
+          })
+
+          const teamThinkTool =
+            workstream.mode === 'group' && !onboardingActive
+              ? createTeamThinkTool({
+                  historyMessages: currentMessages,
+                  latestUserMessageId: referenceUserMessageId,
+                  orgId: orgRef,
+                  userId: userRef,
+                  workstreamId: workstreamRef,
+                  githubInstalled,
+                  availableUploads: listReadableUploads(),
+                  provideRepoTool: indexedRepoContext.provideRepoTool,
+                  defaultRepoSectionsByAgent: indexedRepoContext.defaultSectionsByAgent as never,
+                  reasoningProfile: reasoningProfile.name,
+                  systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+                  getPreSeededMemoriesSection,
+                  retrievedKnowledgeSection,
+                  additionalInstructionSections: mergeInstructionSections(
+                    coreInstructionSections,
+                    hookInstructionSections,
+                  ),
+                  getAdditionalInstructionSections: getExecutionPlanInstructionSections,
+                  context: buildContextResult,
+                  toolProviders,
+                  abortSignal: runAbort.signal,
+                })
+              : null
+
+          if (workstream.mode === 'direct') {
+            if (!workstream.agentId) {
+              throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
+            }
+            await runVisibleAgent({ agentId: workstream.agentId, mode: 'direct' })
+          } else if (params.kind === 'userTurn') {
+            await runVisibleAgent({
+              agentId: visibleWorkstreamAgentId ?? 'chief',
+              mode: 'workstreamMode',
+              skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
+              additionalInstructionSections: mergeInstructionSections(coreInstructionSections, hookInstructionSections),
+              extraTools: {
+                [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool,
+                ...(teamThinkTool ? { [CONSULT_TEAM_TOOL_NAME]: teamThinkTool } : {}),
+              },
+            })
+          } else {
+            await runVisibleAgent({
+              agentId: visibleWorkstreamAgentId ?? 'chief',
+              mode: 'workstreamMode',
+              skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
+              additionalInstructionSections: mergeInstructionSections(coreInstructionSections, hookInstructionSections),
+              extraTools: {
+                [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool,
+                ...(teamThinkTool ? { [CONSULT_TEAM_TOOL_NAME]: teamThinkTool } : {}),
+              },
+            })
+          }
+        } finally {
+          try {
+            const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
+            const latestPersistedState = WorkstreamStateSchema.safeParse(latestWorkstreamRecord.state).success
+              ? WorkstreamStateSchema.parse(latestWorkstreamRecord.state)
+              : null
+
+            await finalizeTurnRun({
+              serverRunId,
+              getEntity: async () => latestWorkstreamRecord,
+              getUncompactedMessages: (cursor) =>
+                workstreamMessageService.listMessagesAfterCursor(workstreamRef, cursor),
+              assessCompaction: (summaryText, messages) =>
+                contextCompactionRuntime.shouldCompactHistory({
+                  summaryText,
+                  liveMessages: messages,
+                  contextSize: CONTEXT_SIZE,
+                }),
+              enqueueCompaction: () =>
+                enqueueContextCompaction({
+                  domain: 'workstream',
+                  entityId: workstreamIdString,
+                  contextSize: CONTEXT_SIZE,
+                }).then(() => {}),
+              unregisterRun: (runId) => chatRunRegistry.unregister(runId),
+              clearActiveRunId: (runId) => workstreamService.clearActiveRunIdIfMatches(workstreamRef, runId),
+              disposeAbort: () => runAbort.dispose(),
+            })
+
+            let trackerAwareWorkstreamRecord = latestWorkstreamRecord
+            let trackerAwarePersistedState = latestPersistedState
+
+            if (!onboardingActive && allAssistantMessages.length > 0) {
+              const activeExecutionPlan = await executionPlanService.getActivePlanForWorkstream(workstreamRef)
+              const trackerUpdated = await updateWorkstreamChangeTracker({
+                workstreamId: workstreamRef,
+                title: latestWorkstreamRecord.title ?? workstream.title,
+                mode: workstream.mode,
+                ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
+                ...(visibleWorkstreamAgentId ? { visibleAgentId: visibleWorkstreamAgentId } : {}),
+                hasActiveExecutionPlan: activeExecutionPlan !== null,
+                previousSummary:
+                  typeof latestWorkstreamRecord.chatSummary === 'string' ? latestWorkstreamRecord.chatSummary : null,
+                existingState: latestPersistedState,
+                userMessageText: referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : null,
+                assistantMessages: allAssistantMessages
+                  .map((message) => {
+                    const text = extractTrackerMessageText(message).trim()
+                    if (!text) return null
+                    const label =
+                      typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
+                        ? message.metadata.agentName.trim()
+                        : typeof message.metadata?.agentId === 'string' && message.metadata.agentId.trim().length > 0
+                          ? message.metadata.agentId.trim()
+                          : (visibleWorkstreamAgentId ?? 'Assistant')
+                    return { label, text }
+                  })
+                  .filter((message): message is { label: string; text: string } => Boolean(message)),
+              })
+
+              if (trackerUpdated) {
+                const trackedWorkstreamRecord = await workstreamService.getWorkstreamRecord(workstreamRef)
+                trackerAwareWorkstreamRecord = trackedWorkstreamRecord
+                trackerAwarePersistedState = parsePersistedWorkstreamState(trackedWorkstreamRecord.state)
+                if (writer) {
+                  writer.write({
+                    type: 'data-workstreamTracker',
+                    data: workstreamService.toPublicWorkstreamDetail(trackedWorkstreamRecord)
+                      .workstreamState as unknown as Record<string, unknown>,
+                    transient: true,
+                  })
+                }
+              }
+            }
+
+            if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
+              const agentMessages = buildAgentHistoryMessages(allAssistantMessages)
+              const historyMessagesForMemory = appendCompactionContextToHistoryMessages(
+                toHistoryMessages(recentHistory),
+                { chatSummary: trackerAwareWorkstreamRecord.chatSummary, persistedState: trackerAwarePersistedState },
+              )
+
+              const userMessageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
+              const readableUploads = listReadableUploads()
+              const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
+              const hasAttachmentContext = Boolean(attachmentMetadataContext)
+              if (
+                shouldEnqueueOnboardingPostChatMemory({
+                  onboardingActive,
+                  userMessageText,
+                  hasAttachmentContext,
+                  agentMessageCount: agentMessages.length,
+                })
+              ) {
+                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 ?? 'chief',
+                      }),
+                      sourceLabel: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
+                      deepLink: buildRecentActivityChatDeepLink({
+                        workstream,
+                        workstreamId: workstreamIdString,
+                        visibleAgentId: visibleWorkstreamAgentId ?? 'chief',
+                      }),
+                      metadata: {
+                        agentId: visibleWorkstreamAgentId ?? 'chief',
+                        agentName: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
+                        workstreamId: workstreamIdString,
+                        workstreamTitle: trackerAwareWorkstreamRecord.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 })) {
+                await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: orgIdString }), {
+                  operationName: 'regular chat memory digest enqueue',
+                })
+              }
+
+              if (shouldEnqueueSkillExtraction({ onboardingActive })) {
+                await safeEnqueue(() => enqueueSkillExtraction({ orgId: orgIdString }), {
+                  operationName: 'skill extraction enqueue',
+                })
+              }
+            }
+
+            if (allAssistantMessages.length > 0) {
+              await turnHooks.afterTurn?.({
+                workstream,
+                workstreamRef,
+                orgRef,
+                userRef,
+                userName,
+                onboardingActive,
+                referenceUserMessage,
+                assistantMessages: allAssistantMessages,
+                latestWorkstreamRecord: trackerAwareWorkstreamRecord,
+                latestPersistedState: trackerAwarePersistedState,
+                context: buildContextResult,
+              })
+            }
+          } catch (postRunError) {
+            aiLogger.error`Workstream post-run cleanup failed: ${postRunError}`
+          }
+        }
+      }
+
+      await executeRun()
+    },
+  }
+}