@lota-sdk/core 0.1.9 → 0.1.12

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

@@ -1,12 +1,14 @@
-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,
+  baseChatMessageSchema,
   CONSULT_SPECIALIST_TOOL_NAME,
+  CONSULT_TEAM_TOOL_NAME,
   ConsultSpecialistArgsSchema,
-} from '@lota-sdk/shared/schemas/tools'
+  dataPartsSchema,
+  messageMetadataSchema,
+  toTimestamp,
+  withMessageCreatedAt,
+} from '@lota-sdk/shared'
+import type { ChatMessage, MessageMetadata } from '@lota-sdk/shared'
 import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
 import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
 import type { z } from 'zod'
@@ -15,10 +17,12 @@ import {
   agentDisplayNames,
   buildAgentTools,
   createAgent,
+  getLeadAgentId,
   getCoreWorkstreamProfile,
   getAgentRuntimeConfig,
   pluginRuntime,
 } from '../config/agent-defaults'
+import { lotaDebugLogger } from '../config/debug-logger'
 import { aiLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
@@ -93,7 +97,7 @@ interface UIMessageStreamResult {
   toUIMessageStream(options: Record<string, unknown>): ReadableStream<unknown>
 }
 
-export function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
+function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
   return (
     typeof value === 'object' &&
     value !== null &&
@@ -101,7 +105,7 @@ export function hasUIMessageStream(value: unknown): value is UIMessageStreamResu
   )
 }
 
-export function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
+function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
   let current: unknown = pluginRuntime
   let owner: unknown = undefined
   for (const key of path) {
@@ -118,7 +122,7 @@ export function getPluginService(path: string[]): ((...args: unknown[]) => unkno
     : (current as (...args: unknown[]) => unknown)
 }
 
-export async function buildIndexedRepositoriesContext(
+async function buildIndexedRepositoriesContext(
   workspaceId: string,
 ): Promise<{ provideRepoTool: boolean; defaultSectionsByAgent: Record<string, unknown>; context: string }> {
   const buildContext = getRuntimeAdapters().workstream?.buildIndexedRepositoriesContext
@@ -136,11 +140,20 @@ export async function buildIndexedRepositoriesContext(
 
 const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
 
-export function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
+function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
   return parseWorkstreamState(value)
 }
 
-export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
+function stripExecutionPlanFieldsFromWorkstreamState(
+  state: WorkstreamState | null | undefined,
+  hasExecutionPlan: boolean,
+): WorkstreamState | null | undefined {
+  if (!state || !hasExecutionPlan) return state
+
+  return { ...state, currentPlan: null, tasks: [], artifacts: [] }
+}
+
+async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
   return await waitForCompactionIfNeeded({
     entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
     entityLabel: 'Workstream',
@@ -149,13 +162,13 @@ export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordId
   })
 }
 
-export function parseChatMessageCandidate(value: unknown): ChatMessage | undefined {
+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 {
+function getChatMessageFromToolOutput(output: unknown): ChatMessage | undefined {
   const directCandidate = parseChatMessageCandidate(output)
   if (directCandidate) return directCandidate
 
@@ -173,7 +186,7 @@ export function getChatMessageFromToolOutput(output: unknown): ChatMessage | und
   return undefined
 }
 
-export class WorkstreamTurnError extends AppError {
+class WorkstreamTurnError extends AppError {
   constructor(
     message: string,
     readonly statusCode: 400 | 409,
@@ -183,19 +196,19 @@ export class WorkstreamTurnError extends AppError {
   }
 }
 
-export function asRecord(value: unknown): Record<string, unknown> | null {
+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 {
+function readOptionalString(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim().length > 0 ? value : undefined
 }
 
-export function readOptionalBoolean(value: unknown): boolean | undefined {
+function readOptionalBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined
 }
 
-export function readInstructionSections(value: unknown): string[] {
+function readInstructionSections(value: unknown): string[] {
   if (!Array.isArray(value)) {
     return []
   }
@@ -206,7 +219,7 @@ export function readInstructionSections(value: unknown): string[] {
     .filter((section) => section.length > 0)
 }
 
-export function optionalInstructionSection(value: unknown): string[] | undefined {
+function optionalInstructionSection(value: unknown): string[] | undefined {
   const section = readOptionalString(value)
   return section ? [section] : undefined
 }
@@ -220,6 +233,7 @@ export interface WorkstreamTurnParams {
   inputMessage: ChatMessage
   persistInputMessage?: boolean
   abortSignal?: AbortSignal
+  streamId?: string
 }
 
 export interface WorkstreamApprovalContinuationParams {
@@ -230,26 +244,29 @@ export interface WorkstreamApprovalContinuationParams {
   userName?: string | null
   approvalMessages: ChatMessage[]
   abortSignal?: AbortSignal
+  streamId?: string
 }
 
-export type WorkstreamRunCoreParams = {
+type WorkstreamRunCoreParams = {
   workstream: NormalizedWorkstream
   workstreamRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
   abortSignal?: AbortSignal
+  streamId?: string
 } & (
   | { kind: 'userTurn'; inputMessage: ChatMessage; persistInputMessage?: boolean }
   | { kind: 'approvalContinuation'; approvalMessages: ChatMessage[] }
+  | { kind: 'nativeToolApprovalTurn'; approvalMessages: ChatMessage[] }
 )
 
-export interface PreparedWorkstreamTurn {
+interface PreparedWorkstreamTurn {
   originalMessages: ChatMessage[]
   run: (writer?: UIMessageStreamWriter<ChatMessage>) => Promise<void>
 }
 
-export function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: ChatMessage): ChatMessage[] {
+function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: ChatMessage): ChatMessage[] {
   const existingIndex = messages.findIndex((message) => message.id === nextMessage.id)
   if (existingIndex === -1) {
     return [...messages, nextMessage]
@@ -260,22 +277,19 @@ export function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: C
   return nextMessages
 }
 
-export function buildRecentActivityChatDeepLink(params: {
+function buildRecentActivityChatDeepLink(params: {
   workstream: NormalizedWorkstream
   workstreamId: string
   visibleAgentId: string
-}): { route: '/chat'; search: { chat?: string; agent?: string; tab: 'cos' | 'team' | 'workstreams' } } {
+}): { route: string; search: Record<string, string> } {
   if (params.workstream.mode === 'direct') {
-    return {
-      route: '/chat',
-      search: { agent: params.visibleAgentId, tab: params.visibleAgentId === 'chief' ? 'cos' : 'team' },
-    }
+    return { route: 'direct-workstream', search: { workstreamId: params.workstreamId, agentId: params.visibleAgentId } }
   }
 
-  return { route: '/chat', search: { chat: params.workstreamId, tab: 'workstreams' } }
+  return { route: 'group-workstream', search: { workstreamId: params.workstreamId } }
 }
 
-export function buildRecentActivityChatSystemTitle(params: {
+function buildRecentActivityChatSystemTitle(params: {
   workstream: NormalizedWorkstream
   visibleAgentId: string
 }): string {
@@ -307,7 +321,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   let inputMessage: ChatMessage | undefined
   const shouldPersistInputMessage = params.kind === 'userTurn' ? params.persistInputMessage !== false : false
-  const shouldProcessPostRunSideEffects = params.kind === 'approvalContinuation' || shouldPersistInputMessage
+  const shouldProcessPostRunSideEffects =
+    params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn' || shouldPersistInputMessage
   if (params.kind === 'userTurn') {
     inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage))
     if (inputMessage.role !== 'user') {
@@ -321,12 +336,18 @@ 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({})
+
   const workstreamRecord = await waitForWorkstreamCompactionIfNeeded(workstreamRef)
+  timer.step('compaction-gate')
   if (toOptionalTrimmedString(workstreamRecord.activeRunId)) {
     throw new WorkstreamTurnError('A chat run is already active.', 409)
   }
 
-  if (params.kind === 'approvalContinuation') {
+  if (params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn') {
     const approvedAssistantMessage = [...params.approvalMessages]
       .reverse()
       .find((m) => m.role === 'assistant' && hasApprovalRespondedParts(m))
@@ -334,9 +355,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       throw new WorkstreamTurnError('No approval-responded message found.', 400)
     }
     await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [approvedAssistantMessage] })
+    timer.step('persist-approval-message')
   }
 
-  const workspacePromise = workspaceProvider ? workspaceProvider.getWorkspace(orgRef) : Promise.resolve({})
   const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
   const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
   const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
@@ -361,10 +382,13 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     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[])
@@ -381,9 +405,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           dataSchemas: dataPartsSchema,
         }).then((messages) => messages.map(hydrateMessageFileUrls)),
   ])
+  timer.step('validate+hydrate-history')
 
   if (userMessage && shouldPersistInputMessage) {
     await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [userMessage] })
+    timer.step('persist-user-message')
   }
 
   const originalMessages = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
@@ -419,8 +445,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           skills?: string[]
         })
       : null
+  const defaultLeadAgentId = getLeadAgentId()
   const visibleWorkstreamAgentId =
-    workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? 'chief')
+    workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId)
   const coreInstructionSections = coreWorkstreamProfile ? [coreWorkstreamProfile.instructions] : undefined
   const getLinearInstallationByOrgId = getPluginService([
     'linear',
@@ -442,6 +469,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     forceDeep: highImpactAssessment.classes.length > 0 || policyAssessment.classes.length > 0,
     explicitProfile: onboardingActive ? 'standard' : undefined,
   })
+  timer.step('reasoning-classification')
 
   const [linearInstallation, githubInstallation, indexedRepoContext, recentDomainEvents, promptSummary] =
     await Promise.all([
@@ -455,6 +483,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         ? 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({
@@ -473,6 +502,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           userId: userIdString,
           query: messageText,
         })
+  timer.step('rag-knowledge-retrieval')
   const buildContextResult = asRecord(
     await turnHooks.buildContext?.({
       workstream,
@@ -494,6 +524,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       retrievedKnowledgeSection,
     }),
   )
+  timer.step('hook:buildContext')
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
   if (buildContextPromptDetails) {
     promptContext = { systemWorkspaceDetails: buildContextPromptDetails }
@@ -532,6 +563,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       context: buildContextResult,
     }),
   )
+  timer.step('hook:buildExtraInstructionSections')
 
   let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
   let workstreamState = initialWorkstreamState
@@ -539,11 +571,39 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     disabled: onboardingActive,
     loadPlan: async () => await executionPlanService.getActivePlanForWorkstream(workstreamRef),
   })
+  const getExecutionPlan = async () => await executionPlanInstructionSectionCache.getPlan()
   const getExecutionPlanInstructionSections = async (): Promise<string[] | undefined> =>
     await executionPlanInstructionSectionCache.getSections()
   const invalidateExecutionPlanInstructionSections = () => {
     executionPlanInstructionSectionCache.invalidate()
   }
+  const getWorkstreamStateSection = async (): Promise<string | undefined> => {
+    const executionPlan = await getExecutionPlan()
+    return contextCompactionRuntime.formatWorkstreamStateForPrompt(
+      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, Boolean(executionPlan)),
+    )
+  }
+  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) {
+    const appliedHumanInput = await executionPlanService.applyHumanInputFromUserMessage({
+      workstreamId: workstreamRef,
+      message: userMessage,
+      respondedBy,
+    })
+    if (appliedHumanInput) {
+      invalidateExecutionPlanInstructionSections()
+    }
+  }
+  timer.step('execution-plan-input')
   const preSeededMemoriesByAgent = new Map<string, string | undefined>()
   const getPreSeededMemoriesSection = async (agentId: string): Promise<string | undefined> => {
     if (preSeededMemoriesByAgent.has(agentId)) {
@@ -594,14 +654,21 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       uploadMetadataText: buildReadableUploadMetadataText(listReadableUploads(extraMessages)),
     })
 
+  timer.step('preparation-complete')
+
   return {
     originalMessages,
     run: async (writer?: UIMessageStreamWriter<ChatMessage>) => {
       const executeRun = async () => {
+        const runTimer = lotaDebugLogger.timer('run')
         const serverRunId = Bun.randomUUIDv7()
         const runAbort = createServerRunAbortController(params.abortSignal)
-        await workstreamService.setActiveRunId(workstreamRef, serverRunId)
+        await Promise.all([
+          workstreamService.setActiveRunId(workstreamRef, serverRunId),
+          params.streamId ? workstreamService.setActiveStreamId(workstreamRef, params.streamId) : undefined,
+        ])
         chatRunRegistry.register(serverRunId, runAbort.controller)
+        runTimer.step('set-active-run+stream')
 
         try {
           const buildAgentMetadataPatch = (agentId: string, agentName: string): NonNullable<MessageMetadata> => ({
@@ -660,7 +727,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             prepareStep?: PrepareStepFunction<ToolSet>
             abortSignal?: AbortSignal
           }): Promise<ChatMessage> => {
+            const agentTimer = lotaDebugLogger.timer(`agent:${streamParams.agentId}`)
             const executionPlanInstructionSections = await getExecutionPlanInstructionSections()
+            agentTimer.step('get-execution-plan')
             const agentResolution = asRecord(
               await turnHooks.resolveAgent?.({
                 agentId: streamParams.agentId,
@@ -679,7 +748,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 context: buildContextResult,
               }),
             )
+            agentTimer.step('hook:resolveAgent')
             const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
+            const [preSeededMemoriesSection, workstreamStateSection, learnedSkillsSection] = await Promise.all([
+              getPreSeededMemoriesSection(resolvedAgentId),
+              getWorkstreamStateSection(),
+              getLearnedSkillsSection(resolvedAgentId),
+            ])
+            agentTimer.step('parallel-fetch(memories+state+skills)')
             const config = getAgentRuntimeConfig({
               agentId: resolvedAgentId,
               workstreamMode: workstream.mode,
@@ -689,11 +765,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               linearInstalled,
               reasoningProfile: reasoningProfile.name,
               systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-              preSeededMemoriesSection: await getPreSeededMemoriesSection(resolvedAgentId),
+              preSeededMemoriesSection,
               retrievedKnowledgeSection,
               workstreamMemoryBlock: memoryBlock,
-              workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
-              learnedSkillsSection: await getLearnedSkillsSection(resolvedAgentId),
+              workstreamStateSection,
+              learnedSkillsSection,
               additionalInstructionSections: mergeInstructionSections(
                 executionPlanInstructionSections,
                 streamParams.additionalInstructionSections,
@@ -703,9 +779,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               ),
               context: buildContextResult,
             }) as AgentRuntimeConfig
+            agentTimer.step('build-agent-config')
             const modelMessages = await convertToModelMessages(streamParams.messages, {
               ignoreIncompleteToolCalls: true,
             })
+            agentTimer.step('convert-model-messages')
             const agent = (createAgent as unknown as AgentFactory)[config.id as string]({
               mode: streamParams.mode,
               tools: streamParams.tools,
@@ -719,12 +797,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
             })
             const agentAbortSignal = streamParams.abortSignal ?? runAbort.signal
+            agentTimer.step('agent-construction')
 
             let result: unknown
             try {
               result = await streamParams.observer.run(() =>
                 agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
               )
+              agentTimer.step('agent.stream()-resolved')
             } catch (error) {
               if (agentAbortSignal.aborted) {
                 streamParams.observer.recordAbort(error)
@@ -758,10 +838,15 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               },
             }) as ReadableStream<ChatStreamChunk>
             const reader = uiStream.getReader()
+            let firstChunkLogged = false
             try {
               for (;;) {
                 const { done, value } = await reader.read()
                 if (done) break
+                if (!firstChunkLogged) {
+                  agentTimer.step('first-stream-chunk')
+                  firstChunkLogged = true
+                }
                 if (streamParams.writer) {
                   streamParams.writer.write(value)
                 }
@@ -769,6 +854,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             } finally {
               reader.releaseLock()
             }
+            agentTimer.step('stream-complete')
 
             const finalizedResponseMessage = await finishedStream.then(() => responseMessage)
             if (finalizedResponseMessage === null) {
@@ -790,6 +876,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             extraMessages?: ChatMessage[]
             extraTools?: ToolSet
           }): Promise<ChatMessage> => {
+            const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
             const tools: ToolSet = {
               ...((await buildAgentTools({
@@ -819,6 +906,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               ...toolProviders,
               ...runParams.extraTools,
             }
+            visibleTimer.step('build-agent-tools')
             const responseMessage = await streamAgentResponse({
               agentId: runParams.agentId,
               mode: runParams.mode,
@@ -830,6 +918,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               writer,
             })
 
+            visibleTimer.step('stream-agent-response')
             memoryBlock = runMemoryBlock
 
             return await commitAssistantResponse(
@@ -839,6 +928,12 @@ 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
+          }
+
           const consultSpecialistTool = createTool({
             description: 'Consult one specialist teammate for domain-specific guidance before replying to the user.',
             inputSchema: ConsultSpecialistArgsSchema,
@@ -871,7 +966,17 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 context: buildContextResult,
               })
 
-              const specialistExecutionPlanInstructionSections = await getExecutionPlanInstructionSections()
+              const [
+                specialistExecutionPlanInstructionSections,
+                specialistPreSeededMemories,
+                specialistWorkstreamState,
+                specialistLearnedSkills,
+              ] = await Promise.all([
+                getExecutionPlanInstructionSections(),
+                getPreSeededMemoriesSection(agentId),
+                getWorkstreamStateSection(),
+                getLearnedSkillsSection(agentId),
+              ])
               const specialistConfig = getAgentRuntimeConfig({
                 agentId,
                 workstreamMode: workstream.mode,
@@ -880,11 +985,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 linearInstalled,
                 reasoningProfile: reasoningProfile.name,
                 systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-                preSeededMemoriesSection: await getPreSeededMemoriesSection(agentId),
+                preSeededMemoriesSection: specialistPreSeededMemories,
                 retrievedKnowledgeSection,
                 workstreamMemoryBlock: specialistMemoryBlock,
-                workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
-                learnedSkillsSection: await getLearnedSkillsSection(agentId),
+                workstreamStateSection: specialistWorkstreamState,
+                learnedSkillsSection: specialistLearnedSkills,
                 additionalInstructionSections: mergeInstructionSections(
                   specialistExecutionPlanInstructionSections,
                   coreInstructionSections,
@@ -995,20 +1100,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               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',
+              agentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
               mode: 'workstreamMode',
               skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
               additionalInstructionSections: mergeInstructionSections(coreInstructionSections, hookInstructionSections),
@@ -1043,6 +1137,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               unregisterRun: (runId) => chatRunRegistry.unregister(runId),
               clearActiveRunId: (runId) => workstreamService.clearActiveRunIdIfMatches(workstreamRef, runId),
               disposeAbort: () => runAbort.dispose(),
+              activeStreamId: params.streamId,
+              clearActiveStreamId: (streamId) =>
+                workstreamService.clearActiveStreamIdIfMatches(workstreamRef, streamId),
             })
 
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
@@ -1103,17 +1200,17 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                       mergeKey: `workstream:${workstreamIdString}`,
                       title: buildRecentActivityChatSystemTitle({
                         workstream,
-                        visibleAgentId: visibleWorkstreamAgentId ?? 'chief',
+                        visibleAgentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
                       }),
-                      sourceLabel: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
+                      sourceLabel: agentDisplayNames[visibleWorkstreamAgentId ?? defaultLeadAgentId],
                       deepLink: buildRecentActivityChatDeepLink({
                         workstream,
                         workstreamId: workstreamIdString,
-                        visibleAgentId: visibleWorkstreamAgentId ?? 'chief',
+                        visibleAgentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
                       }),
                       metadata: {
-                        agentId: visibleWorkstreamAgentId ?? 'chief',
-                        agentName: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
+                        agentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
+                        agentName: agentDisplayNames[visibleWorkstreamAgentId ?? defaultLeadAgentId],
                         workstreamId: workstreamIdString,
                         workstreamTitle: latestWorkstreamRecord.title ?? workstream.title,
                         workstreamMode: workstream.mode,

package/src/services/workstream-turn.ts

@@ -1,6 +1,7 @@
-import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+import type { ChatMessage } from '@lota-sdk/shared'
 import { createUIMessageStream } from 'ai'
 
+import { lotaDebugLogger } from '../config/debug-logger'
 import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../runtime/approval-continuation'
 import { wrapResponseWithKeepalive } from '../utils/sse-keepalive'
 import { prepareWorkstreamRunCore } from './workstream-turn-preparation'
@@ -10,30 +11,54 @@ export { hasApprovalRespondedParts, isApprovalContinuationRequest }
 export { wrapResponseWithKeepalive }
 
 export async function createWorkstreamApprovalContinuationStream(params: WorkstreamApprovalContinuationParams) {
+  const timer = lotaDebugLogger.timer('turn:approval-continuation')
   const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'approvalContinuation' })
+  timer.step('prepare')
 
   return createUIMessageStream<ChatMessage>({
     originalMessages: prepared.originalMessages,
     onError: (error) => (error instanceof Error ? error.message : 'Approval continuation stream failed.'),
     execute: async ({ writer }) => {
       await prepared.run(writer)
+      timer.step('run')
+    },
+  })
+}
+
+export async function createWorkstreamNativeToolApprovalStream(params: WorkstreamApprovalContinuationParams) {
+  const timer = lotaDebugLogger.timer('turn:native-tool-approval')
+  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'nativeToolApprovalTurn' })
+  timer.step('prepare')
+
+  return createUIMessageStream<ChatMessage>({
+    originalMessages: prepared.originalMessages,
+    onError: (error) => (error instanceof Error ? error.message : 'Native tool approval stream failed.'),
+    execute: async ({ writer }) => {
+      await prepared.run(writer)
+      timer.step('run')
     },
   })
 }
 
 export async function createWorkstreamTurnStream(params: WorkstreamTurnParams) {
+  const timer = lotaDebugLogger.timer('turn:user-turn')
   const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'userTurn' })
+  timer.step('prepare')
 
   return createUIMessageStream<ChatMessage>({
     originalMessages: prepared.originalMessages,
     onError: (error) => (error instanceof Error ? error.message : 'Chat stream failed.'),
     execute: async ({ writer }) => {
       await prepared.run(writer)
+      timer.step('run')
     },
   })
 }
 
 export async function runWorkstreamTurnInBackground(params: WorkstreamTurnParams): Promise<void> {
+  const timer = lotaDebugLogger.timer('turn:background')
   const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'userTurn' })
+  timer.step('prepare')
   await prepared.run()
+  timer.step('run')
 }