@lota-sdk/core 0.2.3 → 0.3.1

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

@@ -1,5 +1,5 @@
 import {
-  WORKSTREAM,
+  THREAD,
   dataPartsSchemas,
   messageMetadataSchema,
   PlanNodeResultSubmissionSchema,
@@ -11,13 +11,13 @@ import type { ChatMessage, MessageMetadata, PlanNodeSpecRecord } from '@lota-sdk
 import { convertToModelMessages, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
 import type { PrepareStepFunction, StopCondition, ToolLoopAgent, ToolSet, UIMessageStreamWriter } from 'ai'
 
-import type { CoreWorkstreamProfile } from '../config/agent-defaults'
+import type { CoreThreadProfile } from '../config/agent-defaults'
 import {
   agentRoster,
   buildAgentTools,
   createAgent,
   getLeadAgentId,
-  getCoreWorkstreamProfile,
+  getCoreThreadProfile,
   getAgentRuntimeConfig,
 } from '../config/agent-defaults'
 import { lotaDebugLogger } from '../config/debug-logger'
@@ -26,7 +26,7 @@ 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 { enqueueWorkstreamTitleGeneration } from '../queues/title-generation.queue'
+import { enqueueThreadTitleGeneration } from '../queues/title-generation.queue'
 import { readRuntimeAgentIdentityOverrides, resolveRuntimeAgentDisplayName } from '../runtime/agent-identity-overrides'
 import { OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES } from '../runtime/agent-runtime-policy'
 import { createAgentMessageMetadata, createServerRunAbortController } from '../runtime/agent-stream-helpers'
@@ -39,7 +39,6 @@ import { createExecutionPlanInstructionSectionCache } from '../runtime/execution
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import { runPostTurnSideEffects } from '../runtime/post-turn-side-effects'
 import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
-import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import {
   asRecord,
   collectToolOutputErrors,
@@ -47,17 +46,18 @@ import {
   readInstructionSections,
   readOptionalString,
   toOptionalTrimmedString,
-} from '../runtime/workstream-chat-helpers'
+} from '../runtime/thread-chat-helpers'
 import {
   buildPlanTurnInstructionSections,
   buildPlanTurnPromptMessage,
   buildPlanTurnSubmitToolDescription,
-} from '../runtime/workstream-plan-turn'
-import type { WorkstreamPlanTurnContext } from '../runtime/workstream-plan-turn'
-import { assembleWorkstreamTurnContext } from '../runtime/workstream-turn-context'
+} from '../runtime/thread-plan-turn'
+import type { ThreadPlanTurnContext } from '../runtime/thread-plan-turn'
+import { assembleThreadTurnContext } from '../runtime/thread-turn-context'
+import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import { chatRunRegistry } from '../services/chat-run-registry.service'
-import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
-import { triageWorkstreamMessage, checkForNextAgent } from '../system-agents/workstream-router.agent'
+import type { NormalizedThread, ThreadRecord } from '../services/thread.types'
+import { triageThreadMessage, checkForNextAgent } from '../system-agents/thread-router.agent'
 import { safeEnqueue } from '../utils/async'
 import { AppError } from '../utils/errors'
 import { attachmentService } from './attachment.service'
@@ -67,8 +67,8 @@ import { executionPlanService } from './execution-plan.service'
 import { learnedSkillService } from './learned-skill.service'
 import { memoryService } from './memory.service'
 import { planRunService } from './plan-run.service'
-import { workstreamMessageService } from './workstream-message.service'
-import { ActiveWorkstreamRunConflictError, workstreamService } from './workstream.service'
+import { threadMessageService } from './thread-message.service'
+import { ActiveThreadRunConflictError, threadService } from './thread.service'
 
 type ChatStreamChunk = Parameters<UIMessageStreamWriter<ChatMessage>['write']>[0]
 
@@ -86,22 +86,22 @@ function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
 
 const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
 
-async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
+async function waitForThreadCompactionIfNeeded(threadId: RecordIdRef): Promise<ThreadRecord> {
   return waitForCompactionIfNeeded({
-    entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
-    entityLabel: 'Workstream',
-    loadEntity: () => workstreamService.getById(workstreamId),
-    isCompacting: (workstream) => workstream.isCompacting === true,
+    entityId: recordIdToString(threadId, TABLES.THREAD),
+    entityLabel: 'Thread',
+    loadEntity: () => threadService.getById(threadId),
+    isCompacting: (thread) => thread.isCompacting === true,
   })
 }
 
-class WorkstreamTurnError extends AppError {
+class ThreadTurnError extends AppError {
   constructor(
     message: string,
     readonly statusCode: 400 | 409,
   ) {
     super(message, statusCode === 409 ? 'CONFLICT' : 'BAD_REQUEST', statusCode)
-    this.name = 'WorkstreamTurnError'
+    this.name = 'ThreadTurnError'
   }
 }
 
@@ -122,12 +122,13 @@ function writeMultiAgentEvent(
 ): void {
   if (!writer) return
 
-  writer.write({
+  const chunk: ChatStreamChunk = {
     type: 'data-multi-agent-event',
     id: `multi-agent-${Bun.randomUUIDv7()}`,
     data: event,
     transient: true,
-  } as unknown as ChatStreamChunk)
+  }
+  writer.write(chunk)
 }
 
 function applyPlanTurnToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpecRecord): ToolSet {
@@ -143,9 +144,9 @@ function applyPlanTurnToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpecRecord):
   )
 }
 
-export interface WorkstreamTurnParams {
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+export interface ThreadTurnParams {
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -156,9 +157,9 @@ export interface WorkstreamTurnParams {
   streamId?: string
 }
 
-export interface WorkstreamApprovalContinuationParams {
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+export interface ThreadApprovalContinuationParams {
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -167,20 +168,20 @@ export interface WorkstreamApprovalContinuationParams {
   streamId?: string
 }
 
-export interface WorkstreamPlanTurnParams {
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+export interface ThreadPlanTurnParams {
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
-  planTurn: WorkstreamPlanTurnContext
+  planTurn: ThreadPlanTurnContext
   abortSignal?: AbortSignal
   streamId?: string
 }
 
-type WorkstreamRunCoreParams = {
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+type ThreadRunCoreParams = {
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -191,15 +192,15 @@ type WorkstreamRunCoreParams = {
   | { kind: 'userTurn'; inputMessage: ChatMessage; skipInputMessagePersistence?: boolean }
   | { kind: 'approvalContinuation'; approvalMessages: ChatMessage[] }
   | { kind: 'nativeToolApprovalTurn'; approvalMessages: ChatMessage[] }
-  | { kind: 'planTurn'; planTurn: WorkstreamPlanTurnContext }
+  | { kind: 'planTurn'; planTurn: ThreadPlanTurnContext }
 )
 
-interface PreparedWorkstreamTurn {
+interface PreparedThreadTurn {
   originalMessages: ChatMessage[]
-  run: (writer?: UIMessageStreamWriter<ChatMessage>) => Promise<PreparedWorkstreamTurnResult>
+  run: (writer?: UIMessageStreamWriter<ChatMessage>) => Promise<PreparedThreadTurnResult>
 }
 
-export interface PreparedWorkstreamTurnResult {
+export interface PreparedThreadTurnResult {
   inputMessageId?: string
   assistantMessages: ChatMessage[]
 }
@@ -217,8 +218,8 @@ function upsertChatHistoryMessage(messages: ChatMessage[], nextMessage: ChatMess
 
 interface StreamAgentResponseContext {
   turnHooks: ReturnType<typeof getTurnHooks>
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -238,7 +239,7 @@ interface StreamAgentResponseContext {
 
 interface StreamAgentResponseParams {
   agentId: string
-  mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+  mode: 'direct' | 'fixedThreadMode' | 'threadMode'
   messages: ChatMessage[]
   tools: ToolSet
   observer: {
@@ -269,8 +270,8 @@ async function streamAgentResponse(
     await ctx.turnHooks.resolveAgent?.({
       agentId: streamParams.agentId,
       mode: streamParams.mode,
-      workstream: ctx.workstream,
-      workstreamRef: ctx.workstreamRef,
+      thread: ctx.thread,
+      threadRef: ctx.threadRef,
       orgRef: ctx.orgRef,
       userRef: ctx.userRef,
       userName: ctx.userName,
@@ -306,7 +307,7 @@ async function streamAgentResponse(
     resolvedAgentId === 'mentor'
   const config = getAgentRuntimeConfig({
     agentId: resolvedAgentId,
-    workstreamMode: ctx.workstream.mode,
+    threadType: ctx.thread.type,
     mode: streamParams.mode,
     skills: streamParams.skills,
     onboardingActive: ctx.onboardingActive,
@@ -314,7 +315,7 @@ async function streamAgentResponse(
     systemWorkspaceDetails: ctx.promptContext.systemWorkspaceDetails,
     preSeededMemoriesSection,
     retrievedKnowledgeSection: ctx.retrievedKnowledgeSection,
-    workstreamMemoryBlock: ctx.memoryBlock,
+    threadMemoryBlock: ctx.memoryBlock,
     learnedSkillsSection,
     userMessageText: latestUserMessageText,
     ruleOptions: { includeMemr3Rule: hasRetrievalTools, includeDomainReasoningFallbackRule: hasDomainRoutingSkills },
@@ -342,32 +343,20 @@ async function streamAgentResponse(
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
   agentTimer.step('agent-construction')
 
-  const MAX_STREAM_RETRIES = 3
   let result: unknown
-  for (let attempt = 0; ; attempt++) {
-    try {
-      result = await streamParams.observer.run(() =>
-        agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
-      )
-      agentTimer.step('agent.stream()-resolved')
-      break
-    } catch (error) {
-      if (agentAbortSignal.aborted) {
-        streamParams.observer.recordAbort(error)
-        throw error
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      const isTransient =
-        errorMessage.includes('client disconnected') ||
-        errorMessage.includes('ECONNRESET') ||
-        errorMessage.includes('socket hang up') ||
-        errorMessage.includes('fetch failed')
-      if (!isTransient || attempt >= MAX_STREAM_RETRIES - 1) {
-        streamParams.observer.recordError(error)
-        throw error
-      }
-      aiLogger.warn`Transient stream error (attempt ${attempt + 1}/${MAX_STREAM_RETRIES}): ${errorMessage} — retrying`
+  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)
+      throw error
     }
+
+    streamParams.observer.recordError(error)
+    throw error
   }
   if (!hasUIMessageStream(result)) {
     throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)
@@ -426,15 +415,15 @@ async function streamAgentResponse(
   return responseMessage
 }
 
-export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams): Promise<PreparedWorkstreamTurn> {
-  const { workstream, workstreamRef, orgRef, userRef, userName } = params
+export async function prepareThreadRunCore(params: ThreadRunCoreParams): Promise<PreparedThreadTurn> {
+  const { thread, threadRef, orgRef, userRef, userName } = params
   const runtimeAdapters = getRuntimeAdapters()
   const turnHooks = getTurnHooks()
   const toolProviders = getToolProviders()
   const workspaceProvider = runtimeAdapters.workspaceProvider
   const orgIdString = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const userIdString = recordIdToString(userRef, TABLES.USER)
-  const workstreamIdString = recordIdToString(workstreamRef, TABLES.WORKSTREAM)
+  const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
 
   const hydrateMessageFileUrls = (message: ChatMessage): ChatMessage => ({
     ...message,
@@ -453,13 +442,13 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   if (params.kind === 'userTurn') {
     inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage, Date.now()))
     if (inputMessage.role !== 'user') {
-      throw new WorkstreamTurnError('Only user messages can be submitted to the workstream runtime.', 400)
+      throw new ThreadTurnError('Only user messages can be submitted to the thread runtime.', 400)
     }
     if (!hasMessageContent(inputMessage.parts)) {
-      throw new WorkstreamTurnError('Workstream messages must include text or attachments.', 400)
+      throw new ThreadTurnError('Thread messages must include text or attachments.', 400)
     }
-    if (workstream.mode === 'direct' && !workstream.agentId) {
-      throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
+    if (thread.type === 'default' && !thread.agentId) {
+      throw new ThreadTurnError('Default threads require an assigned agent.', 400)
     }
   }
 
@@ -471,17 +460,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       ? workspaceProvider.getWorkspace(orgRef)
       : Promise.resolve({})
 
-  const workstreamRecord = await waitForWorkstreamCompactionIfNeeded(workstreamRef)
+  const threadRecord = await waitForThreadCompactionIfNeeded(threadRef)
   timer.step('compaction-gate')
   // Plan turns run without the chat lease — they must not block or be blocked by user messages.
   if (params.kind !== 'planTurn') {
-    if (
-      (await workstreamService.hasActiveRunLease(workstreamRef)) ||
-      toOptionalTrimmedString(workstreamRecord.activeRunId)
-    ) {
-      const clearedStaleRun = await workstreamService.clearStaleActiveRunIfMissingFromRegistry(workstreamRef)
+    if ((await threadService.hasActiveRunLease(threadRef)) || toOptionalTrimmedString(threadRecord.activeRunId)) {
+      const clearedStaleRun = await threadService.clearStaleActiveRunIfMissingFromRegistry(threadRef)
       if (!clearedStaleRun) {
-        throw new WorkstreamTurnError('A chat run is already active.', 409)
+        throw new ThreadTurnError('A chat run is already active.', 409)
       }
     }
   }
@@ -491,22 +477,19 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       .reverse()
       .find((m) => m.role === 'assistant' && hasApprovalRespondedParts(m))
     if (!approvedAssistantMessage) {
-      throw new WorkstreamTurnError('No approval-responded message found.', 400)
+      throw new ThreadTurnError('No approval-responded message found.', 400)
     }
-    await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [approvedAssistantMessage] })
+    await threadMessageService.upsertMessages({ threadId: threadRef, messages: [approvedAssistantMessage] })
     timer.step('persist-approval-message')
   }
 
-  const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
-  const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
-    workstreamRef,
-    persistedCompactionCursor,
-  )
+  const persistedCompactionCursor = toOptionalTrimmedString(threadRecord.lastCompactedMessageId) ?? undefined
+  const persistedLiveHistoryPromise = threadMessageService.listMessagesAfterCursor(threadRef, persistedCompactionCursor)
   let recentHistoryPromise: Promise<ChatMessage[]> | null = null
   const loadRecentHistory = async (): Promise<ChatMessage[]> => {
     if (!recentHistoryPromise) {
-      recentHistoryPromise = workstreamMessageService
-        .listRecentMessages(workstreamRef, 64)
+      recentHistoryPromise = threadMessageService
+        .listRecentMessages(threadRef, 64)
         .then(async (persistedRecentHistory) => {
           if (persistedRecentHistory.length === 0) {
             return [] as ChatMessage[]
@@ -547,7 +530,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   timer.step('validate+hydrate-history')
 
   if (userMessage && shouldPersistInputMessage) {
-    await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [userMessage] })
+    await threadMessageService.upsertMessages({ threadId: threadRef, messages: [userMessage] })
     timer.step('persist-user-message')
   }
 
@@ -569,7 +552,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   const respondedBy = recordIdToString(userRef, TABLES.USER)
   if (params.kind === 'approvalContinuation') {
     await executionPlanService.applyApprovalResponseFromMessages({
-      workstreamId: workstreamRef,
+      threadId: threadRef,
       approvalMessages: params.approvalMessages,
       respondedBy,
     })
@@ -580,31 +563,29 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   if (
     params.kind === 'userTurn' &&
-    workstream.mode === 'group' &&
-    !workstream.core &&
-    workstreamRecord.nameGenerated !== true &&
-    workstreamRecord.title === WORKSTREAM.DEFAULT_TITLE &&
+    thread.type === 'group' &&
+    threadRecord.nameGenerated !== true &&
+    threadRecord.title === THREAD.DEFAULT_TITLE &&
     messageText.length > 0
   ) {
-    void safeEnqueue(
-      () => enqueueWorkstreamTitleGeneration({ workstreamId: workstreamIdString, sourceText: messageText }),
-      { operationName: 'workstream-title-generation' },
-    )
+    void safeEnqueue(() => enqueueThreadTitleGeneration({ threadId: threadIdString, sourceText: messageText }), {
+      operationName: 'thread-title-generation',
+    })
   }
 
-  if (workstream.core && !workstream.coreType) {
-    throw new WorkstreamTurnError('Core workstreams require a core type.', 400)
+  if (thread.type === 'thread' && !thread.threadType) {
+    throw new ThreadTurnError('Core threads require a thread type.', 400)
   }
-  const coreWorkstreamProfile: CoreWorkstreamProfile | null =
-    workstream.core && workstream.coreType ? getCoreWorkstreamProfile(workstream.coreType) : null
+  const coreThreadProfile: CoreThreadProfile | null =
+    thread.type === 'thread' && thread.threadType ? getCoreThreadProfile(thread.threadType) : null
   const defaultLeadAgentId = getLeadAgentId()
-  const visibleWorkstreamAgentId =
+  const visibleThreadAgentId =
     params.agentIdOverride ??
-    (workstream.mode === 'direct' ? workstream.agentId : (coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId))
-  const coreInstructionSections = coreWorkstreamProfile ? [coreWorkstreamProfile.instructions] : undefined
-  const assembledContext = await assembleWorkstreamTurnContext({
-    workstream,
-    workstreamRef,
+    (thread.type === 'default' ? thread.agentId : (coreThreadProfile?.config.agentId ?? defaultLeadAgentId))
+  const coreInstructionSections = coreThreadProfile ? [coreThreadProfile.instructions] : undefined
+  const assembledContext = await assembleThreadTurnContext({
+    thread,
+    threadRef,
     orgRef,
     userRef,
     userName,
@@ -628,11 +609,11 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     hookInstructionSections,
   } = assembledContext
 
-  let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
+  let memoryBlock = threadService.formatMemoryBlockForPrompt(threadRecord)
   const executionPlanInstructionSectionCache = createExecutionPlanInstructionSectionCache({
     disabled: false,
     loadPlans: async () => {
-      const runs = await planRunService.getActiveRunRecords(workstreamRef)
+      const runs = await planRunService.getActiveRunRecords(threadRef)
       return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run, { slim: true })))
     },
   })
@@ -643,7 +624,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   }
   if (userMessage) {
     const appliedHumanInput = await executionPlanService.applyHumanInputFromUserMessage({
-      workstreamId: workstreamRef,
+      threadId: threadRef,
       message: userMessage,
       respondedBy,
     })
@@ -684,8 +665,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   }
 
   const persistedCompactionSummary =
-    persistedCompactionCursor && typeof workstreamRecord.compactionSummary === 'string'
-      ? workstreamRecord.compactionSummary
+    persistedCompactionCursor && typeof threadRecord.compactionSummary === 'string'
+      ? threadRecord.compactionSummary
       : ''
   const messagesForContext = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
   let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedCompactionSummary, messagesForContext)
@@ -704,7 +685,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     })
   const buildTurnToolParams = (toolParams: {
     agentId: string
-    mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+    mode: 'direct' | 'fixedThreadMode' | 'threadMode'
     memoryBlock: string
     onAppendMemoryBlock: (value: string) => void
     extraMessages?: ChatMessage[]
@@ -715,9 +696,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     orgId: orgRef,
     userId: userRef,
     userName: userName ?? 'there',
-    workstreamId: workstreamRef,
+    threadId: threadRef,
     orgIdString,
-    workstreamMode: workstream.mode,
+    threadType: thread.type,
     mode: toolParams.mode,
     linearInstalled,
     onboardingActive,
@@ -738,7 +719,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   return {
     originalMessages,
     run: async (writer?: UIMessageStreamWriter<ChatMessage>) => {
-      const executeRun = async (leaseAbortSignal?: AbortSignal): Promise<PreparedWorkstreamTurnResult | void> => {
+      const executeRun = async (leaseAbortSignal?: AbortSignal): Promise<PreparedThreadTurnResult | void> => {
         const agentIdentityOverrides = readRuntimeAgentIdentityOverrides(buildContextResult)
         const runTimer = lotaDebugLogger.timer('run')
         const serverRunId = Bun.randomUUIDv7()
@@ -751,7 +732,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         }
         // Plan turns run without the chat lease — don't claim the active run slot.
         if (params.kind !== 'planTurn') {
-          await workstreamService.setActiveTurn(workstreamRef, serverRunId, params.streamId ?? null)
+          await threadService.setActiveTurn(threadRef, serverRunId, params.streamId ?? null)
           chatRunRegistry.register(serverRunId, runAbort.controller)
         }
         runTimer.step('set-active-run+stream')
@@ -794,7 +775,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               Date.now(),
             )
 
-            await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [committed] })
+            await threadMessageService.upsertMessages({ threadId: threadRef, messages: [committed] })
             currentMessages = upsertChatHistoryMessage(currentMessages, committed)
             allAssistantMessages = upsertChatHistoryMessage(allAssistantMessages, committed)
             throwIfRunAborted()
@@ -804,8 +785,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
           const streamCtx: StreamAgentResponseContext = {
             turnHooks,
-            workstream,
-            workstreamRef,
+            thread,
+            threadRef,
             orgRef,
             userRef,
             userName,
@@ -825,7 +806,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
           const runVisibleAgent = async (runParams: {
             agentId: string
-            mode: 'direct' | 'fixedWorkstreamMode' | 'workstreamMode'
+            mode: 'direct' | 'fixedThreadMode' | 'threadMode'
             skills?: string[]
             additionalInstructionSections?: string[]
             extraMessages?: ChatMessage[]
@@ -837,7 +818,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
             const includeExecutionPlanTools =
-              runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedWorkstreamMode'
+              runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedThreadMode'
             const rawTools: ToolSet = {
               ...((await buildAgentTools(
                 buildTurnToolParams({
@@ -889,7 +870,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               inputSchema: PlanNodeResultSubmissionSchema,
               execute: async (result) =>
                 await executionPlanService.submitPlanTurnResult({
-                  workstreamId: workstreamRef,
+                  threadId: threadRef,
                   runId: planTurn.runId,
                   nodeId: planTurn.nodeId,
                   emittedBy: planTurn.nodeSpec.owner.ref,
@@ -899,7 +880,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
             await runVisibleAgent({
               agentId: planTurn.nodeSpec.owner.ref,
-              mode: workstream.mode === 'direct' ? 'direct' : 'workstreamMode',
+              mode: thread.type === 'default' ? 'direct' : 'threadMode',
               additionalInstructionSections: buildPlanTurnInstructionSections(planTurn),
               extraMessages: [buildPlanTurnPromptMessage(planTurn)],
               includeExecutionPlanTools: false,
@@ -908,16 +889,16 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               metadataPatch: { trigger: 'plan-turn', planRunId: planTurn.runId, planNodeId: planTurn.nodeId },
             })
           } else {
-            if (workstream.mode === 'direct') {
-              if (!workstream.agentId) {
-                throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
+            if (thread.type === 'default') {
+              if (!thread.agentId) {
+                throw new ThreadTurnError('Direct threads require an assigned agent.', 400)
               }
-              await runVisibleAgent({ agentId: workstream.agentId, mode: 'direct' })
+              await runVisibleAgent({ agentId: thread.agentId, mode: 'direct' })
             } else {
-              // Multi-agent orchestration for group workstreams
-              const wsMembers = (workstream as { members?: string[] }).members ?? []
+              // Multi-agent orchestration for group threads
+              const wsMembers = (thread as { members?: string[] }).members ?? []
               const members = wsMembers.length > 0 ? wsMembers : [...agentRoster]
-              const fallbackAgentId = coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId
+              const fallbackAgentId = coreThreadProfile?.config.agentId ?? defaultLeadAgentId
               throwIfRunAborted()
               writeMultiAgentEvent(writer, { phase: 'routing', note: 'Routing this turn to the right agent.' })
 
@@ -926,8 +907,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 .map((m) => `${m.role}: ${extractMessageText(m).slice(0, 200)}`)
                 .join('\n')
 
-              const triageResult = await triageWorkstreamMessage({
-                workstreamTitle: workstream.title,
+              const triageResult = await triageThreadMessage({
+                threadTitle: thread.title,
                 members,
                 messageText,
                 recentContext,
@@ -944,13 +925,13 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 }
                 // Multi-agent member protocol: be direct, focus on domain
                 additionalSections.push(
-                  '<multi-agent-protocol>\nYou are responding as part of a multi-agent workstream. Focus on your domain expertise. Be direct and concise — another agent may follow up on different aspects.\n</multi-agent-protocol>',
+                  '<multi-agent-protocol>\nYou are responding as part of a multi-agent thread. Focus on your domain expertise. Be direct and concise — another agent may follow up on different aspects.\n</multi-agent-protocol>',
                 )
 
                 return await runVisibleAgent({
                   agentId,
-                  mode: 'workstreamMode',
-                  skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
+                  mode: 'threadMode',
+                  skills: coreThreadProfile?.skills ? [...coreThreadProfile.skills] : undefined,
                   additionalInstructionSections: additionalSections,
                 })
               }
@@ -973,7 +954,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 while (respondedAgents.length < 3) {
                   const lastResponseText = extractMessageText(lastResponse).slice(0, 500)
                   const checkResult = await checkForNextAgent({
-                    workstreamTitle: workstream.title,
+                    threadTitle: thread.title,
                     members,
                     messageText,
                     respondedAgents,
@@ -990,7 +971,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                     phase: 'waiting-for-agent',
                     agentId: checkResult.agentId,
                     agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, checkResult.agentId),
-                    note: checkResult.routingContext,
+                    note: checkResult.routingContext ?? undefined,
                   })
 
                   // Insert hidden bridge message between agent turns
@@ -1006,15 +987,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                     metadata: { hidden: true, createdAt: Date.now() } as MessageMetadata,
                   }
                   throwIfRunAborted()
-                  await workstreamMessageService.upsertMessages({
-                    workstreamId: workstreamRef,
-                    messages: [bridgeMessage],
-                  })
+                  await threadMessageService.upsertMessages({ threadId: threadRef, messages: [bridgeMessage] })
                   currentMessages = upsertChatHistoryMessage(currentMessages, bridgeMessage)
                   throwIfRunAborted()
 
                   lastResponse = await runGroupAgent(checkResult.agentId, {
-                    routingContext: checkResult.routingContext,
+                    routingContext: checkResult.routingContext ?? undefined,
                   })
                   respondedAgents.push(checkResult.agentId)
                   throwIfRunAborted()
@@ -1033,13 +1011,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           }
         } finally {
           try {
-            const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
+            const latestThreadRecord = await threadService.getById(threadRef)
 
             await finalizeTurnRun({
               serverRunId,
-              getEntity: async () => latestWorkstreamRecord,
-              getUncompactedMessages: (cursor) =>
-                workstreamMessageService.listMessagesAfterCursor(workstreamRef, cursor),
+              getEntity: async () => latestThreadRecord,
+              getUncompactedMessages: (cursor) => threadMessageService.listMessagesAfterCursor(threadRef, cursor),
               assessCompaction: (summaryText, messages) =>
                 contextCompactionRuntime.shouldCompactHistory({
                   summaryText,
@@ -1048,34 +1025,34 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 }),
               enqueueCompaction: async () => {
                 await enqueueContextCompaction({
-                  domain: 'workstream',
-                  entityId: workstreamIdString,
+                  domain: 'thread',
+                  entityId: threadIdString,
                   contextSize: CONTEXT_WINDOW_TOKENS,
                 })
               },
               unregisterRun: (runId) => chatRunRegistry.unregister(runId),
               clearActiveRunId: async (runId) => {
-                const activeStreamId = await workstreamService.getActiveStreamId(workstreamRef)
-                await workstreamService.clearActiveTurn(workstreamRef, { runId, streamId: activeStreamId })
+                const activeStreamId = await threadService.getActiveStreamId(threadRef)
+                await threadService.clearActiveTurn(threadRef, { runId, streamId: activeStreamId })
               },
               disposeAbort: () => runAbort.dispose(),
               activeStreamId: params.streamId,
               clearActiveStreamId: async (streamId) => {
-                const activeRunId = await workstreamService.getActiveRunId(workstreamRef)
+                const activeRunId = await threadService.getActiveRunId(threadRef)
                 if (!activeRunId) return
-                await workstreamService.clearActiveTurn(workstreamRef, { runId: activeRunId, streamId })
+                await threadService.clearActiveTurn(threadRef, { runId: activeRunId, streamId })
               },
             })
 
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
               await runPostTurnSideEffects({
-                workstream,
-                workstreamRef,
+                thread,
+                threadRef,
                 orgRef,
                 userRef,
                 userName,
                 orgIdString,
-                workstreamIdString,
+                threadIdString,
                 onboardingActive,
                 workspace,
                 allAssistantMessages,
@@ -1084,9 +1061,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 loadRecentHistory,
                 listReadableUploads: () => listReadableUploads(),
                 memoryBlock,
-                visibleWorkstreamAgentId,
+                visibleThreadAgentId,
                 defaultLeadAgentId,
-                latestWorkstreamRecord,
+                latestThreadRecord,
                 isUserTurn: params.kind === 'userTurn',
                 agentDisplayNamesById: agentIdentityOverrides.displayNamesById,
               })
@@ -1094,20 +1071,20 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
             if (allAssistantMessages.length > 0 && params.kind !== 'planTurn') {
               await turnHooks.afterTurn?.({
-                workstream,
-                workstreamRef,
+                thread,
+                threadRef,
                 orgRef,
                 userRef,
                 userName,
                 onboardingActive,
                 referenceUserMessage,
                 assistantMessages: allAssistantMessages,
-                latestWorkstreamRecord,
+                latestThreadRecord,
                 context: buildContextResult,
               })
             }
           } catch (postRunError) {
-            aiLogger.error`Workstream post-run cleanup failed: ${postRunError}`
+            aiLogger.error`Thread post-run cleanup failed: ${postRunError}`
           }
         }
       }
@@ -1123,7 +1100,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       }
 
       try {
-        return await workstreamService.withActiveRunLease(workstreamRef, async (leaseAbortSignal) => {
+        return await threadService.withActiveRunLease(threadRef, async (leaseAbortSignal) => {
           const runResult = await executeRun(leaseAbortSignal)
           if (runResult) {
             return runResult
@@ -1132,8 +1109,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           return { inputMessageId: referenceUserMessage?.id, assistantMessages: [...allAssistantMessages] }
         })
       } catch (error) {
-        if (error instanceof ActiveWorkstreamRunConflictError) {
-          throw new WorkstreamTurnError(error.message, 409)
+        if (error instanceof ActiveThreadRunConflictError) {
+          throw new ThreadTurnError(error.message, 409)
         }
         throw error
       }