@lota-sdk/core 0.1.24 → 0.1.26

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

@@ -11,17 +11,9 @@ import {
   toTimestamp,
   withMessageCreatedAt,
 } from '@lota-sdk/shared'
-import type {
-  ChatMessage,
-  MessageMetadata,
-  PlanArtifactSubmission,
-  PlanNodeHandoffContext,
-  PlanNodeRunRecord,
-  PlanNodeSpecRecord,
-} from '@lota-sdk/shared'
-import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
+import type { ChatMessage, ConsultSpecialistArgs, MessageMetadata, PlanNodeSpecRecord } from '@lota-sdk/shared'
+import { convertToModelMessages, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
 import type { PrepareStepFunction, StopCondition, ToolLoopAgent, ToolSet, UIMessageStreamWriter } from 'ai'
-import type { z } from 'zod'
 
 import type { CoreWorkstreamProfile } from '../config/agent-defaults'
 import {
@@ -38,17 +30,8 @@ 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 { enqueueMemoryConsolidation } from '../queues/memory-consolidation.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 { enqueueWorkstreamTitleGeneration } from '../queues/workstream-title-generation.queue'
-import { buildAgentPromptContext } from '../runtime/agent-prompt-context'
-import {
-  OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES,
-  buildCompletionCheckStructuredOutputHints,
-} from '../runtime/agent-runtime-policy'
+import { enqueueWorkstreamTitleGeneration } from '../queues/title-generation.queue'
+import { OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES } from '../runtime/agent-runtime-policy'
 import {
   buildSpecialistTaskMessage,
   createAgentMessageMetadata,
@@ -62,32 +45,30 @@ import { parseWorkstreamState } from '../runtime/context-compaction'
 import { CONTEXT_WINDOW_TOKENS } from '../runtime/context-compaction-constants'
 import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
-import {
-  shouldEnqueueMemoryConsolidation,
-  shouldEnqueueMemoryExtraction,
-  shouldEnqueueOnboardingPostChatMemory,
-  shouldEnqueueRegularDigestForWorkstream,
-} from '../runtime/memory-digest-policy'
-import { buildIndexedRepositoriesContext, getPluginService } from '../runtime/plugin-resolution'
+import { runPostTurnSideEffects } from '../runtime/post-turn-side-effects'
 import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
-import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
+import { runSpecialistSession } from '../runtime/specialist-runner'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import {
-  appendPersistedWorkstreamContextToHistoryMessages,
-  buildAgentHistoryMessages,
-  buildConversationSummary,
-  buildReadableUploadMetadataContext,
+  asRecord,
   collectToolOutputErrors,
   extractMessageText,
-  toHistoryMessages,
+  readInstructionSections,
+  readOptionalString,
   toOptionalTrimmedString,
 } from '../runtime/workstream-chat-helpers'
+import {
+  buildPlanTurnInstructionSections,
+  buildPlanTurnPromptMessage,
+  buildPlanTurnSubmitToolDescription,
+} from '../runtime/workstream-plan-turn'
+import type { WorkstreamPlanTurnContext } from '../runtime/workstream-plan-turn'
 import type { WorkstreamState } from '../runtime/workstream-state'
+import { assembleWorkstreamTurnContext } from '../runtime/workstream-turn-context'
 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'
@@ -96,7 +77,6 @@ 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 { ActiveWorkstreamRunConflictError, workstreamService } from './workstream.service'
 
@@ -168,205 +148,11 @@ class WorkstreamTurnError extends AppError {
   }
 }
 
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === 'object' ? (value as Record<string, unknown>) : null
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim().length > 0 ? value : undefined
-}
-
-function readOptionalBoolean(value: unknown): boolean | undefined {
-  return typeof value === 'boolean' ? value : undefined
-}
-
-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)
-}
-
 function optionalInstructionSection(value: unknown): string[] | undefined {
   const section = readOptionalString(value)
   return section ? [section] : undefined
 }
 
-export interface PlanTurnUpstreamHandoff {
-  nodeId: string
-  label: string
-  ownerRef: string
-  ownerType: PlanNodeSpecRecord['owner']['executorType']
-  handoffContext: PlanNodeHandoffContext
-}
-
-export interface WorkstreamPlanTurnContext {
-  runId: string
-  nodeId: string
-  planTitle: string
-  nodeSpec: PlanNodeSpecRecord
-  nodeRun: PlanNodeRunRecord
-  resolvedInput: Record<string, unknown>
-  inputArtifacts: PlanArtifactSubmission[]
-  upstreamHandoffs: PlanTurnUpstreamHandoff[]
-}
-
-function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): string {
-  const payload = {
-    runId: planTurn.runId,
-    planTitle: planTurn.planTitle,
-    node: {
-      id: planTurn.nodeSpec.nodeId,
-      label: planTurn.nodeSpec.label,
-      owner: planTurn.nodeSpec.owner,
-      objective: planTurn.nodeSpec.objective,
-      instructions: planTurn.nodeSpec.instructions,
-      outputSchemaRef: planTurn.nodeSpec.outputSchemaRef ?? null,
-      deliverables: planTurn.nodeSpec.deliverables,
-      successCriteria: planTurn.nodeSpec.successCriteria,
-      completionChecks: planTurn.nodeSpec.completionChecks,
-      toolPolicy: planTurn.nodeSpec.toolPolicy,
-      contextPolicy: planTurn.nodeSpec.contextPolicy,
-    },
-    resolvedInput: planTurn.resolvedInput,
-    inputArtifacts: planTurn.inputArtifacts,
-  }
-
-  return [
-    '<plan-turn-execution>',
-    'The runtime has activated a visible execution-plan node inside this workstream.',
-    `Complete node "${planTurn.nodeSpec.label}" for plan "${planTurn.planTitle}".`,
-    'Use only the node contract, resolved input, input artifacts, and upstream handoff context provided here.',
-    'Do not ask the user for more input and do not rely on unstated external context.',
-    'Do not submit placeholders, partial work, or speculative outputs.',
-    'Before submitting, satisfy every required deliverable, success criterion, and completion check for this node.',
-    'Deliverables must use the exact artifact names and kinds declared in the node contract.',
-    'If a deliverable declares schemaRef, include the same schemaRef and a payload that satisfies that schema.',
-    'If outputSchemaRef is declared, structuredOutput must satisfy that schema before you submit.',
-    `When finished, call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once.`,
-    'Always include durable handoffContext for downstream nodes when you submit the final result.',
-    'Do not ask the user for confirmation and do not create or replace execution plans in this turn.',
-    JSON.stringify(payload, null, 2),
-    '</plan-turn-execution>',
-  ].join('\n')
-}
-
-function describePlanTurnDeliverable(deliverable: PlanNodeSpecRecord['deliverables'][number]): string {
-  return [
-    `- ${deliverable.name}`,
-    `kind=${deliverable.kind}`,
-    deliverable.required ? 'required' : 'optional',
-    deliverable.schemaRef ? `schemaRef=${deliverable.schemaRef}` : undefined,
-    deliverable.description ? `description=${deliverable.description}` : undefined,
-  ]
-    .filter(Boolean)
-    .join(' | ')
-}
-
-function describePlanTurnCompletionCheck(check: PlanNodeSpecRecord['completionChecks'][number]): string {
-  return [
-    `- ${check.description}`,
-    `type=${check.type}`,
-    check.blocking ? 'blocking' : 'warning',
-    Object.keys(check.config).length > 0 ? `config=${JSON.stringify(check.config)}` : undefined,
-  ]
-    .filter(Boolean)
-    .join(' | ')
-}
-
-function buildPlanTurnResultContractSection(planTurn: WorkstreamPlanTurnContext): string {
-  const requiredDeliverables = planTurn.nodeSpec.deliverables.filter((deliverable) => deliverable.required)
-  const completionCheckOutputHints = buildCompletionCheckStructuredOutputHints(planTurn.nodeSpec)
-  const deliverableLines =
-    planTurn.nodeSpec.deliverables.length > 0
-      ? planTurn.nodeSpec.deliverables.map(describePlanTurnDeliverable)
-      : ['- none']
-  const completionCheckLines =
-    planTurn.nodeSpec.completionChecks.length > 0
-      ? planTurn.nodeSpec.completionChecks.map(describePlanTurnCompletionCheck)
-      : ['- none']
-
-  return [
-    '<plan-turn-result-contract>',
-    `Call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once with a result object that passes node validation.`,
-    'Validation is strict. Missing required artifacts, schema mismatches, or failed completion checks will fail the node run.',
-    `Required artifacts: ${requiredDeliverables.length > 0 ? requiredDeliverables.map((deliverable) => deliverable.name).join(', ') : 'none'}`,
-    `Structured output: ${
-      planTurn.nodeSpec.outputSchemaRef
-        ? `required and must match schema "${planTurn.nodeSpec.outputSchemaRef}"`
-        : 'optional unless needed by a completion check'
-    }`,
-    'Deliverables:',
-    ...deliverableLines,
-    'Completion checks:',
-    ...completionCheckLines,
-    ...(completionCheckOutputHints.length > 0
-      ? ['Structured output fields required by completion checks:', ...completionCheckOutputHints]
-      : []),
-    'Include notes with a concise completion summary grounded in the submitted artifacts and structuredOutput.',
-    'Always include handoffContext for downstream execution with a durable summary, key decisions, open questions, risks, recommendations, and references when relevant.',
-    '</plan-turn-result-contract>',
-  ].join('\n')
-}
-
-function buildPlanTurnSubmitToolDescription(planTurn: WorkstreamPlanTurnContext): string {
-  const requiredArtifacts =
-    planTurn.nodeSpec.deliverables
-      .filter((deliverable) => deliverable.required)
-      .map((deliverable) => `${deliverable.name} (${deliverable.kind})`)
-      .join(', ') || 'none'
-
-  return [
-    'Submit the final result for the active plan-triggered node turn.',
-    'Call this exactly once when the node output is complete.',
-    `Required artifacts: ${requiredArtifacts}.`,
-    `Structured output: ${
-      planTurn.nodeSpec.outputSchemaRef ? `must satisfy ${planTurn.nodeSpec.outputSchemaRef}` : 'optional'
-    }.`,
-    'Do not submit partial results. Include durable handoffContext for downstream nodes.',
-  ].join(' ')
-}
-
-function buildPlanTurnPromptMessage(planTurn: WorkstreamPlanTurnContext): ChatMessage {
-  return {
-    id: Bun.randomUUIDv7(),
-    role: 'user',
-    parts: [
-      {
-        type: 'text',
-        text: `Execute the active plan node "${planTurn.nodeSpec.label}" now and submit the result with ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME}.`,
-      },
-    ],
-    metadata: { trigger: 'plan-turn', planRunId: planTurn.runId, planNodeId: planTurn.nodeId, createdAt: Date.now() },
-  }
-}
-
-function buildUpstreamHandoffSection(upstreamHandoffs: PlanTurnUpstreamHandoff[]): string | undefined {
-  if (upstreamHandoffs.length === 0) {
-    return undefined
-  }
-
-  return [
-    '<upstream-handoff>',
-    JSON.stringify(
-      upstreamHandoffs.map((handoff) => ({
-        nodeId: handoff.nodeId,
-        label: handoff.label,
-        ownerRef: handoff.ownerRef,
-        ownerType: handoff.ownerType,
-        handoffContext: handoff.handoffContext,
-      })),
-      null,
-      2,
-    ),
-    '</upstream-handoff>',
-  ].join('\n')
-}
-
 function applyPlanTurnToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpecRecord): ToolSet {
   const blockedToolNames = new Set([...OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES, ...nodeSpec.toolPolicy.deny])
   const allowList = nodeSpec.toolPolicy.allow.length > 0 ? new Set(nodeSpec.toolPolicy.allow) : null
@@ -452,29 +238,6 @@ function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: ChatMess
   return nextMessages
 }
 
-function buildRecentActivityChatDeepLink(params: {
-  workstream: NormalizedWorkstream
-  workstreamId: string
-  visibleAgentId: string
-}): { route: string; search: Record<string, string> } {
-  if (params.workstream.mode === 'direct') {
-    return { route: 'direct-workstream', search: { workstreamId: params.workstreamId, agentId: params.visibleAgentId } }
-  }
-
-  return { route: 'group-workstream', search: { workstreamId: params.workstreamId } }
-}
-
-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'
-}
-
 interface StreamAgentResponseContext {
   turnHooks: ReturnType<typeof getTurnHooks>
   workstream: NormalizedWorkstream
@@ -489,7 +252,7 @@ interface StreamAgentResponseContext {
   getExecutionPlanInstructionSections: () => Promise<string[] | undefined>
   getPreSeededMemoriesSection: (agentId: string) => Promise<string | undefined>
   getWorkstreamStateSection: () => Promise<string | undefined>
-  getLearnedSkillsSection: (agentId: string) => Promise<string | undefined>
+  getLearnedSkillsSection: (agentId: string, queryText?: string) => Promise<string | undefined>
   promptContext: { systemWorkspaceDetails?: string }
   retrievedKnowledgeSection: string | undefined
   memoryBlock: string
@@ -509,6 +272,7 @@ interface StreamAgentResponseParams {
   }
   skills?: string[]
   additionalInstructionSections?: string[]
+  includeExecutionPlanTools?: boolean
   writer?: UIMessageStreamWriter<ChatMessage>
   stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>
   prepareStep?: PrepareStepFunction<ToolSet>
@@ -541,12 +305,27 @@ async function streamAgentResponse(
   )
   agentTimer.step('hook:resolveAgent')
   const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
+  const latestUserMessage = [...streamParams.messages].reverse().find((message) => message.role === 'user')
+  const latestUserMessageText = latestUserMessage ? extractMessageText(latestUserMessage).trim() : undefined
   const [preSeededMemoriesSection, workstreamStateSection, learnedSkillsSection] = await Promise.all([
     ctx.getPreSeededMemoriesSection(resolvedAgentId),
     ctx.getWorkstreamStateSection(),
-    ctx.getLearnedSkillsSection(resolvedAgentId),
+    ctx.getLearnedSkillsSection(resolvedAgentId, latestUserMessageText),
   ])
   agentTimer.step('parallel-fetch(memories+state+skills)')
+  const toolNames = new Set(Object.keys(streamParams.tools))
+  const hasRetrievalTools = [
+    'memorySearch',
+    'conversationSearch',
+    'queryKnowledge',
+    'researchTopic',
+    'fetchWebpage',
+    'inspectWebsite',
+  ].some((toolName) => toolNames.has(toolName))
+  const hasDomainRoutingSkills =
+    (streamParams.skills ?? []).some((skill) => skill.startsWith('cpo-') || skill.startsWith('mentor-')) ||
+    resolvedAgentId === 'cpo' ||
+    resolvedAgentId === 'mentor'
   const config = getAgentRuntimeConfig({
     agentId: resolvedAgentId,
     workstreamMode: ctx.workstream.mode,
@@ -560,6 +339,12 @@ async function streamAgentResponse(
     workstreamMemoryBlock: ctx.memoryBlock,
     workstreamStateSection,
     learnedSkillsSection,
+    userMessageText: latestUserMessageText,
+    ruleOptions: {
+      includeExecutionPlanRule: streamParams.includeExecutionPlanTools,
+      includeMemr3Rule: hasRetrievalTools,
+      includeDomainReasoningFallbackRule: hasDomainRoutingSkills,
+    },
     additionalInstructionSections: mergeInstructionSections(
       executionPlanInstructionSections,
       streamParams.additionalInstructionSections,
@@ -651,165 +436,12 @@ async function streamAgentResponse(
   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()
   const turnHooks = getTurnHooks()
   const toolProviders = getToolProviders()
-  const workspaceProvider = runtimeAdapters.services?.workspaceProvider
+  const workspaceProvider = runtimeAdapters.workspaceProvider
   const orgIdString = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const userIdString = recordIdToString(userRef, TABLES.USER)
   const workstreamIdString = recordIdToString(workstreamRef, TABLES.WORKSTREAM)
@@ -843,8 +475,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   const timer = lotaDebugLogger.timer('prepare')
 
-  // Start workspace fetch early — does not depend on compaction gate
-  const workspacePromise = workspaceProvider ? workspaceProvider.getWorkspace(orgRef) : Promise.resolve({})
+  // Start workspace fetch early unless approval handling will short-circuit the turn.
+  const workspacePromise =
+    params.kind !== 'approvalContinuation' && workspaceProvider
+      ? workspaceProvider.getWorkspace(orgRef)
+      : Promise.resolve({})
 
   const workstreamRecord = await waitForWorkstreamCompactionIfNeeded(workstreamRef)
   timer.step('compaction-gate')
@@ -875,7 +510,27 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     workstreamRef,
     persistedCompactionCursor,
   )
-  const persistedRecentHistoryPromise = workstreamMessageService.listRecentMessages(workstreamRef, 64)
+  let recentHistoryPromise: Promise<ChatMessage[]> | null = null
+  const loadRecentHistory = async (): Promise<ChatMessage[]> => {
+    if (!recentHistoryPromise) {
+      recentHistoryPromise = workstreamMessageService
+        .listRecentMessages(workstreamRef, 64)
+        .then(async (persistedRecentHistory) => {
+          if (persistedRecentHistory.length === 0) {
+            return [] as ChatMessage[]
+          }
+
+          const messages = await validateUIMessages<ChatMessage>({
+            messages: persistedRecentHistory,
+            metadataSchema: messageMetadataSchema,
+            dataSchemas: dataPartsSchemas,
+          })
+          return messages.map(hydrateMessageFileUrls)
+        })
+    }
+
+    return await recentHistoryPromise
+  }
 
   let userMessage: ChatMessage | undefined
   if (inputMessage) {
@@ -888,34 +543,15 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     }
   }
 
-  const [workspace, persistedLiveHistory, persistedRecentHistory] = await Promise.all([
-    workspacePromise,
-    persistedLiveHistoryPromise,
-    persistedRecentHistoryPromise,
-  ])
-  timer.step('fetch-workspace+history')
-  const workspaceLifecycleState = workspaceProvider ? await workspaceProvider.getLifecycleState?.(workspace) : undefined
-  timer.step('workspace-lifecycle-state')
-  const workspaceProfileState = workspaceProvider
-    ? await workspaceProvider.readProfileProjectionState?.(workspace)
-    : undefined
-  timer.step('workspace-profile-state')
-  const [liveHistory, recentHistory] = await Promise.all([
-    persistedLiveHistory.length === 0
-      ? Promise.resolve([] as ChatMessage[])
-      : validateUIMessages<ChatMessage>({
-          messages: persistedLiveHistory,
-          metadataSchema: messageMetadataSchema,
-          dataSchemas: dataPartsSchemas,
-        }).then((messages) => messages.map(hydrateMessageFileUrls)),
-    persistedRecentHistory.length === 0
-      ? Promise.resolve([] as ChatMessage[])
-      : validateUIMessages<ChatMessage>({
-          messages: persistedRecentHistory,
-          metadataSchema: messageMetadataSchema,
-          dataSchemas: dataPartsSchemas,
-        }).then((messages) => messages.map(hydrateMessageFileUrls)),
-  ])
+  const persistedLiveHistory = await persistedLiveHistoryPromise
+  timer.step('fetch-history')
+  const liveHistory = await (persistedLiveHistory.length === 0
+    ? Promise.resolve([] as ChatMessage[])
+    : validateUIMessages<ChatMessage>({
+        messages: persistedLiveHistory,
+        metadataSchema: messageMetadataSchema,
+        dataSchemas: dataPartsSchemas,
+      }).then((messages) => messages.map(hydrateMessageFileUrls)))
   timer.step('validate+hydrate-history')
 
   if (userMessage && shouldPersistInputMessage) {
@@ -938,6 +574,18 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         ? extractMessageText(referenceUserMessage).trim()
         : ''
 
+  const respondedBy = recordIdToString(userRef, TABLES.USER)
+  if (params.kind === 'approvalContinuation') {
+    await executionPlanService.applyApprovalResponseFromMessages({
+      workstreamId: workstreamRef,
+      approvalMessages: params.approvalMessages,
+      respondedBy,
+    })
+    timer.step('approval-continuation')
+
+    return { originalMessages, run: async () => ({ inputMessageId: referenceUserMessage?.id, assistantMessages: [] }) }
+  }
+
   if (
     params.kind === 'userTurn' &&
     workstream.mode === 'group' &&
@@ -952,7 +600,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     )
   }
 
-  const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
   if (workstream.core && !workstream.coreType) {
     throw new WorkstreamTurnError('Core workstreams require a core type.', 400)
   }
@@ -963,112 +610,31 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     params.agentIdOverride ??
     (workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId))
   const coreInstructionSections = coreWorkstreamProfile ? [coreWorkstreamProfile.instructions] : undefined
-  const getLinearInstallationByOrgId = getPluginService([
-    'linear',
-    'services',
-    'linearService',
-    'getInstallationByOrgId',
-  ])
-  const getGithubInstallationForOrganization = getPluginService([
-    'github',
-    'services',
-    'githubService',
-    'getInstallationForOrganization',
-  ])
-
-  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),
-    ])
-  timer.step('parallel-context-fetch(plugins+repos+events+summary)')
-  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,
+  const assembledContext = await assembleWorkstreamTurnContext({
+    workstream,
+    workstreamRef,
+    orgRef,
+    userRef,
+    userName,
+    orgIdString,
+    userIdString,
+    messageText,
+    workspacePromise,
+    workspaceProvider,
+    turnHooks,
+    onStep: (step) => timer.step(step),
   })
-  let retrievedKnowledgeSection: string | undefined =
-    onboardingActive || !messageText
-      ? undefined
-      : await workspaceProvider?.buildRetrievedKnowledgeSection?.({
-          workspaceId: orgIdString,
-          userId: userIdString,
-          query: messageText,
-        })
-  timer.step('rag-knowledge-retrieval')
-  const buildContextResult = asRecord(
-    await turnHooks.buildContext?.({
-      workstream,
-      workstreamRef,
-      orgRef,
-      userRef,
-      userName,
-      workspace,
-      onboardingActive,
-      messageText,
-      linearInstalled,
-      githubInstalled,
-      indexedRepoContext,
-      promptContext,
-      workspaceLifecycleState,
-      workspaceProfileState,
-      promptSummary,
-      recentDomainEvents,
-      retrievedKnowledgeSection,
-    }),
-  )
-  timer.step('hook:buildContext')
-  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,
-    }),
-  )
-  timer.step('hook:buildExtraInstructionSections')
+  const {
+    workspace,
+    onboardingActive,
+    linearInstalled,
+    githubInstalled,
+    indexedRepoContext,
+    promptContext,
+    retrievedKnowledgeSection,
+    buildContextResult,
+    hookInstructionSections,
+  } = assembledContext
 
   let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
   let workstreamState = initialWorkstreamState
@@ -1091,17 +657,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       stripExecutionPlanFieldsFromWorkstreamState(workstreamState, executionPlans.length > 0),
     )
   }
-  const respondedBy = recordIdToString(userRef, TABLES.USER)
-  if (params.kind === 'approvalContinuation') {
-    const appliedApproval = await executionPlanService.applyApprovalResponseFromMessages({
-      workstreamId: workstreamRef,
-      approvalMessages: params.approvalMessages,
-      respondedBy,
-    })
-    if (appliedApproval) {
-      invalidateExecutionPlanInstructionSections()
-    }
-  } else if (userMessage) {
+  if (userMessage) {
     const appliedHumanInput = await executionPlanService.applyHumanInputFromUserMessage({
       workstreamId: workstreamRef,
       message: userMessage,
@@ -1112,6 +668,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     }
   }
   timer.step('execution-plan-input')
+
   const preSeededMemoriesByAgent = new Map<string, string | undefined>()
   const getPreSeededMemoriesSection = async (agentId: string): Promise<string | undefined> => {
     if (preSeededMemoriesByAgent.has(agentId)) {
@@ -1128,17 +685,18 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   }
 
   const learnedSkillsByAgent = new Map<string, string | undefined>()
-  const getLearnedSkillsSection = async (agentId: string): Promise<string | undefined> => {
+  const getLearnedSkillsSection = async (agentId: string, queryText = messageText): Promise<string | undefined> => {
     if (onboardingActive) return undefined
-    if (learnedSkillsByAgent.has(agentId)) return learnedSkillsByAgent.get(agentId)
+    const cacheKey = `${agentId}::${queryText}`
+    if (learnedSkillsByAgent.has(cacheKey)) return learnedSkillsByAgent.get(cacheKey)
 
     const section = await learnedSkillService
-      .retrieveForTurn({ orgId: orgIdString, agentId, query: messageText, limit: 3, minConfidence: 0.6 })
+      .retrieveForTurn({ orgId: orgIdString, agentId, query: queryText, limit: 3, minConfidence: 0.6 })
       .catch((error) => {
         aiLogger.warn`Failed to retrieve learned skills for ${agentId}: ${error}`
         return undefined
       })
-    learnedSkillsByAgent.set(agentId, section)
+    learnedSkillsByAgent.set(cacheKey, section)
     return section
   }
 
@@ -1161,6 +719,36 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       latestUserMessageId: referenceUserMessageId,
       uploadMetadataText: buildReadableUploadMetadataText(listReadableUploads(extraMessages)),
     })
+  const buildTurnToolParams = (toolParams: {
+    agentId: string
+    mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+    memoryBlock: string
+    onAppendMemoryBlock: (value: string) => void
+    extraMessages?: ChatMessage[]
+    skills?: string[]
+    includeExecutionPlanTools: boolean
+  }) => ({
+    agentId: toolParams.agentId,
+    orgId: orgRef,
+    userId: userRef,
+    userName: userName ?? 'there',
+    workstreamId: workstreamRef,
+    orgIdString,
+    workstreamMode: workstream.mode,
+    mode: toolParams.mode,
+    linearInstalled,
+    onboardingActive,
+    githubInstalled,
+    provideRepoTool: indexedRepoContext.provideRepoTool,
+    skills: toolParams.skills,
+    defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[toolParams.agentId],
+    memoryBlock: toolParams.memoryBlock,
+    onAppendMemoryBlock: toolParams.onAppendMemoryBlock,
+    availableUploads: listReadableUploads(toolParams.extraMessages),
+    includeExecutionPlanTools: toolParams.includeExecutionPlanTools,
+    onExecutionPlanChanged: invalidateExecutionPlanInstructionSections,
+    context: buildContextResult,
+  })
 
   timer.step('preparation-complete')
 
@@ -1171,10 +759,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         const runTimer = lotaDebugLogger.timer('run')
         const serverRunId = Bun.randomUUIDv7()
         const runAbort = createServerRunAbortController(params.abortSignal)
-        await Promise.all([
-          workstreamService.setActiveRunId(workstreamRef, serverRunId),
-          params.streamId ? workstreamService.setActiveStreamId(workstreamRef, params.streamId) : undefined,
-        ])
+        await workstreamService.setActiveTurn(workstreamRef, serverRunId, params.streamId ?? null)
         chatRunRegistry.register(serverRunId, runAbort.controller)
         runTimer.step('set-active-run+stream')
 
@@ -1254,30 +839,19 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             const includeExecutionPlanTools =
               runParams.includeExecutionPlanTools ?? (runParams.mode !== 'fixedWorkstreamMode' && !onboardingActive)
             const rawTools: 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,
-                onExecutionPlanChanged: invalidateExecutionPlanInstructionSections,
-                context: buildContextResult,
-              })) as ToolSet),
+              ...((await buildAgentTools(
+                buildTurnToolParams({
+                  agentId: runParams.agentId,
+                  mode: runParams.mode,
+                  skills: runParams.skills,
+                  memoryBlock: runMemoryBlock,
+                  onAppendMemoryBlock: (value: string) => {
+                    runMemoryBlock = value
+                  },
+                  extraMessages: runParams.extraMessages,
+                  includeExecutionPlanTools,
+                }),
+              )) as ToolSet),
               ...toolProviders,
               ...runParams.extraTools,
             }
@@ -1292,6 +866,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               observer: createObserver(runParams.agentId),
               skills: runParams.skills,
               additionalInstructionSections: runParams.additionalInstructionSections,
+              includeExecutionPlanTools,
               writer,
             })
 
@@ -1306,12 +881,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             )
           }
 
-          // Execution-plan approval continuations mutate plan state and persist the approval message,
-          // but they do not begin a new visible agent turn.
-          if (params.kind === 'approvalContinuation') {
-            return { inputMessageId: referenceUserMessage?.id, assistantMessages: [] }
-          }
-
           if (params.kind === 'planTurn') {
             const planTurn = params.planTurn
             const submitPlanTurnNodeResultTool = createTool({
@@ -1330,10 +899,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             await runVisibleAgent({
               agentId: planTurn.nodeSpec.owner.ref,
               mode: workstream.mode === 'direct' ? 'direct' : 'workstreamMode',
-              additionalInstructionSections: mergeInstructionSections(
-                [buildPlanTurnExecutionSection(planTurn), buildPlanTurnResultContractSection(planTurn)],
-                optionalInstructionSection(buildUpstreamHandoffSection(planTurn.upstreamHandoffs)),
-              ),
+              additionalInstructionSections: buildPlanTurnInstructionSections(planTurn),
               extraMessages: [buildPlanTurnPromptMessage(planTurn)],
               includeExecutionPlanTools: false,
               extraTools: { [SUBMIT_PLAN_TURN_RESULT_TOOL_NAME]: submitPlanTurnNodeResultTool },
@@ -1345,120 +911,43 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               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>,
+                { agentId, task }: ConsultSpecialistArgs,
                 { 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,
-                  specialistPreSeededMemories,
-                  specialistWorkstreamState,
-                  specialistLearnedSkills,
-                ] = await Promise.all([
-                  getExecutionPlanInstructionSections(),
-                  getPreSeededMemoriesSection(agentId),
-                  getWorkstreamStateSection(),
-                  getLearnedSkillsSection(agentId),
-                ])
-                const specialistConfig = getAgentRuntimeConfig({
-                  agentId,
-                  workstreamMode: workstream.mode,
-                  mode: 'fixedWorkstreamMode',
-                  onboardingActive,
-                  linearInstalled,
-                  systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-                  preSeededMemoriesSection: specialistPreSeededMemories,
-                  retrievedKnowledgeSection,
-                  workstreamMemoryBlock: specialistMemoryBlock,
-                  workstreamStateSection: specialistWorkstreamState,
-                  learnedSkillsSection: specialistLearnedSkills,
-                  additionalInstructionSections: mergeInstructionSections(
-                    specialistExecutionPlanInstructionSections,
-                    coreInstructionSections,
-                    hookInstructionSections,
-                  ),
-                  context: buildContextResult,
-                }) as Record<string, unknown>
-                const observer = createObserver(agentId)
-                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,
-                })
                 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, Date.now())
-                  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
+                const { result: finalMessage, memoryBlock: nextMemoryBlock } = await runSpecialistSession({
+                  initialMemoryBlock: memoryBlock,
+                  buildTools: async ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
+                    (await buildAgentTools(
+                      buildTurnToolParams({
+                        agentId,
+                        mode: 'fixedWorkstreamMode',
+                        memoryBlock: currentMemoryBlock,
+                        onAppendMemoryBlock,
+                        extraMessages: [specialistTaskMessage],
+                        includeExecutionPlanTools: false,
+                      }),
+                    )) as ToolSet,
+                  run: async ({ tools, memoryBlock: currentMemoryBlock }) =>
+                    await streamAgentResponse(
+                      { ...streamCtx, memoryBlock: currentMemoryBlock },
+                      {
+                        agentId,
+                        mode: 'fixedWorkstreamMode',
+                        messages: buildRunInputMessages([specialistTaskMessage]),
+                        tools: { ...tools, ...toolProviders },
+                        observer: createObserver(agentId),
+                        additionalInstructionSections: coreInstructionSections,
+                        includeExecutionPlanTools: false,
+                        abortSignal: specialistAbortSignal,
+                      },
+                    ),
+                })
+                const committedFinalMessage = withMessageCreatedAt(finalMessage, Date.now())
+                memoryBlock = nextMemoryBlock
+                yield committedFinalMessage
+                return committedFinalMessage
               },
               toModelOutput: ({ output }) => {
                 const result = getChatMessageFromToolOutput(output)
@@ -1545,11 +1034,17 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 })
               },
               unregisterRun: (runId) => chatRunRegistry.unregister(runId),
-              clearActiveRunId: (runId) => workstreamService.clearActiveRunIdIfMatches(workstreamRef, runId),
+              clearActiveRunId: async (runId) => {
+                const activeStreamId = await workstreamService.getActiveStreamId(workstreamRef)
+                await workstreamService.clearActiveTurn(workstreamRef, { runId, streamId: activeStreamId })
+              },
               disposeAbort: () => runAbort.dispose(),
               activeStreamId: params.streamId,
-              clearActiveStreamId: (streamId) =>
-                workstreamService.clearActiveStreamIdIfMatches(workstreamRef, streamId),
+              clearActiveStreamId: async (streamId) => {
+                const activeRunId = await workstreamService.getActiveRunId(workstreamRef)
+                if (!activeRunId) return
+                await workstreamService.clearActiveTurn(workstreamRef, { runId: activeRunId, streamId })
+              },
             })
 
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
@@ -1566,15 +1061,13 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 allAssistantMessages,
                 referenceUserMessage,
                 referenceUserMessageId,
-                recentHistory,
+                loadRecentHistory,
                 listReadableUploads: () => listReadableUploads(),
                 memoryBlock,
                 visibleWorkstreamAgentId,
                 defaultLeadAgentId,
                 latestWorkstreamRecord,
                 latestPersistedState,
-                turnHooks,
-                buildContextResult,
                 isUserTurn: params.kind === 'userTurn',
               })
             }