@lota-sdk/core 0.1.11 → 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,11 @@ 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 function stripExecutionPlanFieldsFromWorkstreamState(
+function stripExecutionPlanFieldsFromWorkstreamState(
   state: WorkstreamState | null | undefined,
   hasExecutionPlan: boolean,
 ): WorkstreamState | null | undefined {
@@ -149,7 +153,7 @@ export function stripExecutionPlanFieldsFromWorkstreamState(
   return { ...state, currentPlan: null, tasks: [], artifacts: [] }
 }
 
-export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
+async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
   return await waitForCompactionIfNeeded({
     entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
     entityLabel: 'Workstream',
@@ -158,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
 
@@ -182,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,
@@ -192,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 []
   }
@@ -215,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
 }
@@ -243,7 +247,7 @@ export interface WorkstreamApprovalContinuationParams {
   streamId?: string
 }
 
-export type WorkstreamRunCoreParams = {
+type WorkstreamRunCoreParams = {
   workstream: NormalizedWorkstream
   workstreamRef: RecordIdRef
   orgRef: RecordIdRef
@@ -257,12 +261,12 @@ export type WorkstreamRunCoreParams = {
   | { 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]
@@ -273,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 {
@@ -335,7 +336,13 @@ 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)
   }
@@ -348,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(
@@ -375,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[])
@@ -395,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
@@ -433,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',
@@ -456,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([
@@ -469,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({
@@ -487,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,
@@ -508,6 +524,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       retrievedKnowledgeSection,
     }),
   )
+  timer.step('hook:buildContext')
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
   if (buildContextPromptDetails) {
     promptContext = { systemWorkspaceDetails: buildContextPromptDetails }
@@ -546,6 +563,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       context: buildContextResult,
     }),
   )
+  timer.step('hook:buildExtraInstructionSections')
 
   let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
   let workstreamState = initialWorkstreamState
@@ -585,6 +603,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       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)) {
@@ -635,17 +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)
-        if (params.streamId) {
-          await workstreamService.setActiveStreamId(workstreamRef, params.streamId)
-        }
+        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> => ({
@@ -704,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,
@@ -723,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,
@@ -733,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: await getWorkstreamStateSection(),
-              learnedSkillsSection: await getLearnedSkillsSection(resolvedAgentId),
+              workstreamStateSection,
+              learnedSkillsSection,
               additionalInstructionSections: mergeInstructionSections(
                 executionPlanInstructionSections,
                 streamParams.additionalInstructionSections,
@@ -747,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,
@@ -763,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)
@@ -802,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)
                 }
@@ -813,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) {
@@ -834,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({
@@ -863,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,
@@ -874,6 +918,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               writer,
             })
 
+            visibleTimer.step('stream-agent-response')
             memoryBlock = runMemoryBlock
 
             return await commitAssistantResponse(
@@ -921,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,
@@ -930,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: await getWorkstreamStateSection(),
-                learnedSkillsSection: await getLearnedSkillsSection(agentId),
+                workstreamStateSection: specialistWorkstreamState,
+                learnedSkillsSection: specialistLearnedSkills,
                 additionalInstructionSections: mergeInstructionSections(
                   specialistExecutionPlanInstructionSections,
                   coreInstructionSections,
@@ -1047,7 +1102,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             await runVisibleAgent({ agentId: workstream.agentId, mode: 'direct' })
           } else {
             await runVisibleAgent({
-              agentId: visibleWorkstreamAgentId ?? 'chief',
+              agentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
               mode: 'workstreamMode',
               skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
               additionalInstructionSections: mergeInstructionSections(coreInstructionSections, hookInstructionSections),
@@ -1145,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,42 +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')
 }

package/src/services/workstream.service.ts

@@ -1,4 +1,4 @@
-import { WORKSTREAM } from '@lota-sdk/shared/constants/workstream'
+import { WORKSTREAM } from '@lota-sdk/shared'
 import { BoundQuery, RecordId, StringRecordId, surql } from 'surrealdb'
 
 import { agentDisplayNames, getCoreWorkstreamProfile, isAgentName } from '../config/agent-defaults'
@@ -345,19 +345,19 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
 
     const onboardingWelcome = bootstrapConfig.onboardingWelcome
     if (!onboardingCompleted && onboardingWelcome) {
-      const createdChiefWorkstream = createdWorkstreams.find(
+      const createdOnboardingOwnerWorkstream = createdWorkstreams.find(
         (workstream) => workstream.mode === 'direct' && workstream.agentId === onboardingWelcome.directAgentId,
       )
-      const existingChiefWorkstream = directWorkstreamsByAgent.get(onboardingWelcome.directAgentId)
+      const existingOnboardingOwnerWorkstream = directWorkstreamsByAgent.get(onboardingWelcome.directAgentId)
 
-      const chiefWorkstreamId =
-        createdChiefWorkstream?.id ??
-        (existingChiefWorkstream ? this.normalizeWorkstreamId(existingChiefWorkstream.id) : null)
+      const onboardingOwnerWorkstreamId =
+        createdOnboardingOwnerWorkstream?.id ??
+        (existingOnboardingOwnerWorkstream ? this.normalizeWorkstreamId(existingOnboardingOwnerWorkstream.id) : null)
 
-      if (chiefWorkstreamId) {
-        const chiefWorkstreamRef = ensureRecordId(chiefWorkstreamId, TABLES.WORKSTREAM)
+      if (onboardingOwnerWorkstreamId) {
+        const onboardingOwnerWorkstreamRef = ensureRecordId(onboardingOwnerWorkstreamId, TABLES.WORKSTREAM)
         await workstreamMessageService.ensureBootstrapWelcomeMessage({
-          workstreamId: chiefWorkstreamRef,
+          workstreamId: onboardingOwnerWorkstreamRef,
           agentId: onboardingWelcome.directAgentId,
           text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
         })

package/src/storage/attachment-parser.ts

@@ -1,4 +1,4 @@
-import { SUPPORTED_ATTACHMENT_MIME_TYPES, getAttachmentExtension } from '@lota-sdk/shared/constants/attachments'
+import { SUPPORTED_ATTACHMENT_MIME_TYPES, getAttachmentExtension } from '@lota-sdk/shared'
 import mammoth from 'mammoth'
 import { PDFParse } from 'pdf-parse'
 

package/src/storage/attachment-storage.service.ts

@@ -1,8 +1,8 @@
-import { inferContentType } from '@lota-sdk/shared/constants/attachments'
+import { inferContentType } from '@lota-sdk/shared'
 import { S3Client } from 'bun'
 
-import { env } from '../config/env-shapes'
 import { serverLogger } from '../config/logger'
+import { getRuntimeConfig } from '../runtime/runtime-config'
 import { readString } from '../utils/string'
 import {
   extractAttachmentText,
@@ -41,17 +41,18 @@ export class AttachmentStorageService {
   private readonly client: S3Client
 
   constructor() {
+    const config = getRuntimeConfig()
     this.client = new S3Client({
-      accessKeyId: env.S3_ACCESS_KEY_ID,
-      secretAccessKey: env.S3_SECRET_ACCESS_KEY,
-      bucket: env.S3_BUCKET,
-      endpoint: env.S3_ENDPOINT,
-      region: env.S3_REGION,
+      accessKeyId: config.s3.accessKeyId,
+      secretAccessKey: config.s3.secretAccessKey,
+      bucket: config.s3.bucket,
+      endpoint: config.s3.endpoint,
+      region: config.s3.region,
     })
   }
 
   getAttachmentUrl(storageKey: string): string {
-    return this.client.file(storageKey).presign({ expiresIn: env.ATTACHMENT_URL_EXPIRES_IN })
+    return this.client.file(storageKey).presign({ expiresIn: getRuntimeConfig().s3.attachmentUrlExpiresIn })
   }
 
   async writeOrganizationDocument({
@@ -102,7 +103,7 @@ export class AttachmentStorageService {
       sizeBytes: file.size,
       storageKey,
       url: this.getAttachmentUrl(storageKey),
-      expiresInSeconds: env.ATTACHMENT_URL_EXPIRES_IN,
+      expiresInSeconds: getRuntimeConfig().s3.attachmentUrlExpiresIn,
     }
   }
 
@@ -128,7 +129,7 @@ export class AttachmentStorageService {
       sizeBytes,
       storageKey,
       url: this.getAttachmentUrl(storageKey),
-      expiresInSeconds: env.ATTACHMENT_URL_EXPIRES_IN,
+      expiresInSeconds: getRuntimeConfig().s3.attachmentUrlExpiresIn,
     }
   }