@lota-sdk/core 0.2.2 → 0.3.0

package/src/services/thread.types.ts

@@ -0,0 +1,17 @@
+import { sdkPublicThreadSchema, sdkThreadRecordSchema, sdkThreadSchema } from '@lota-sdk/shared'
+import type { SdkPublicThread, SdkThreadRecord } from '@lota-sdk/shared'
+import { z } from 'zod'
+
+export const ThreadSchema = sdkThreadRecordSchema
+export type ThreadRecord = SdkThreadRecord
+
+export const NormalizedThreadSchema = sdkThreadSchema.extend({
+  agentId: z.string().optional(),
+  threadType: z.string().optional(),
+  memoryBlock: z.string(),
+})
+
+export type NormalizedThread = z.infer<typeof NormalizedThreadSchema>
+export type PublicThread = SdkPublicThread
+
+export { sdkPublicThreadSchema as PublicThreadSchema }

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

@@ -26,7 +26,7 @@ import {
 
 const READ_FILE_PARTS_PAGES_PER_PART = 25
 
-export type UploadedWorkstreamAttachment = {
+export type UploadedThreadAttachment = {
   filename: string
   mediaType: string
   sizeBytes: number
@@ -86,7 +86,7 @@ export class AttachmentStorageService {
     orgId: string
     namespace: string
     relativePath: string
-  }): Promise<UploadedWorkstreamAttachment> {
+  }): Promise<UploadedThreadAttachment> {
     const filename = file.name || 'document'
     const mediaType = file.type || inferContentType(filename)
     const storageKey = buildOrganizationDocumentStorageKey({
@@ -107,7 +107,7 @@ export class AttachmentStorageService {
     }
   }
 
-  async uploadWorkstreamAttachment({
+  async uploadThreadAttachment({
     file,
     orgId,
     userId,
@@ -115,7 +115,7 @@ export class AttachmentStorageService {
     file: File
     orgId: string
     userId: string
-  }): Promise<UploadedWorkstreamAttachment> {
+  }): Promise<UploadedThreadAttachment> {
     const filename = file.name || 'attachment'
     const mediaType = file.type || inferContentType(filename)
     const sizeBytes = file.size

package/src/system-agents/index.ts

@@ -10,4 +10,4 @@ export * from './researcher.agent'
 export * from './skill-extractor.agent'
 export * from './skill-manager.agent'
 export * from './title-generator.agent'
-export * from './workstream-router.agent'
+export * from './thread-router.agent'

package/src/system-agents/memory.agent.ts

@@ -40,7 +40,7 @@ Extract organization-relevant facts from the conversation.
 - User personal preferences
 - Transient requests
 - General knowledge questions
-- Temporary discussion workstreams
+- Temporary discussion threads
 </ignore>
 
 <format>

package/src/system-agents/recent-activity-title-refiner.agent.ts

@@ -27,7 +27,7 @@ Turn recent activity context into a short label that helps the user quickly reco
 - Prefer concrete task language over generic labels.
 - Mention the agent only when it adds useful context.
 - Focus on what the user was trying to accomplish.
-- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Workstream update".
+- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Thread update".
 - Avoid punctuation at the end.
 - Do not invent details that are not present in the input.
 - If the input is too weak for improvement, return the current system title.
@@ -58,7 +58,7 @@ Turn recent activity context into a short label that helps the user quickly reco
 - Prefer concrete task language over generic labels.
 - Mention the agent only when it adds useful context.
 - Focus on what the user was trying to accomplish.
-- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Workstream update".
+- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Thread update".
 - Avoid punctuation at the end.
 - Do not invent details that are not present in the input.
 - If the input is too weak for improvement, return the current system title.

package/src/system-agents/regular-chat-memory-digest.agent.ts

@@ -16,7 +16,7 @@ Synthesize an updated workspace profile summary and durable memory facts from co
 
 <rules>
 - Evidence-grounded only. Do not invent details. Exclude routing/tool chatter.
-- Treat [workstream:...] prefixes as thread context only.
+- Treat [thread:...] prefixes as thread context only.
 - Preserve existing profile format. Merge corrections; remove stale claims only when contradicted.
 - Facts must be standalone, one concrete claim each, understandable without transcript context.
 - If no durable updates exist, return current summary unchanged and empty facts.

package/src/system-agents/researcher.agent.ts

@@ -2,12 +2,12 @@ export const RESEARCHER_PROMPT = `<agent-instructions>
 You are a **Research Agent** that gathers accurate, up-to-date information from the web and synthesizes it into a clear markdown report.
 
 <workflow>
-1. Break the research task into 2-5 independent search queries.
+1. Break the research task into 2-3 focused search queries.
 2. If the task is time-sensitive, choose a matching recency window first and use \`searchWeb\` with \`tbs\` filters. Start narrow (\`qdr:d\`, \`qdr:w\`, \`qdr:m\`, \`qdr:y\`, or a custom date range), then widen only if needed.
 3. Run all searchWeb calls in parallel.
-4. Review results and identify the 3-5 most authoritative/relevant URLs.
+4. Review results and identify the 2-3 most authoritative/relevant URLs.
 5. Fetch those pages in parallel using fetchWebpage.
-6. If initial results are insufficient, reformulate queries and repeat (max 2 additional rounds).
+6. If initial results are insufficient, reformulate 1-2 queries and retry once.
 7. Synthesize findings into a structured markdown report.
 </workflow>
 

package/src/system-agents/{workstream-router.agent.ts → thread-router.agent.ts}

@@ -170,14 +170,14 @@ function extractResultText(result: { text?: string; reasoning?: unknown }): stri
 function logRouterRaw(label: 'triage' | 'check', text: string): void {
   const preview = text.trim().slice(0, ROUTER_OUTPUT_PREVIEW_CHARS)
   if (!preview) return
-  console.log(`[workstream-router] ${label} raw:`, preview)
+  console.log(`[thread-router] ${label} raw:`, preview)
 }
 
 // ---------------------------------------------------------------------------
 // Prompts
 // ---------------------------------------------------------------------------
 
-const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Decide which team member should respond FIRST to the user message.
+const TRIAGE_SYSTEM_PROMPT = `You are a thread message router. Decide which team member should respond FIRST to the user message.
 
 Rules:
 - Pick the single best-fit agent from the members list based on domain expertise.
@@ -211,17 +211,17 @@ Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sen
 function createRouterAgent(systemPrompt: string) {
   const modelId = routerModelId ?? 'openai/gpt-5.4-nano'
   return new ToolLoopAgent({
-    id: 'workstream-router',
+    id: 'thread-router',
     model: aiGatewayChatModel(modelId),
-    headers: buildAiGatewayDirectCacheHeaders('workstream-router'),
+    headers: buildAiGatewayDirectCacheHeaders('thread-router'),
     providerOptions: { openai: { reasoningEffort: 'low' } },
     instructions: systemPrompt,
     maxOutputTokens: 256,
   })
 }
 
-export async function triageWorkstreamMessage(params: {
-  workstreamTitle: string
+export async function triageThreadMessage(params: {
+  threadTitle: string
   members: readonly string[]
   messageText: string
   recentContext?: string
@@ -245,7 +245,7 @@ export async function triageWorkstreamMessage(params: {
 
   const membersDesc = buildMembersDescription(params.members, displayOptions)
   const prompt = [
-    `Workstream: "${params.workstreamTitle}"`,
+    `Thread: "${params.threadTitle}"`,
     `Members:\n${membersDesc}`,
     params.recentContext ? `Recent context:\n${params.recentContext}` : '',
     `User message: "${params.messageText}"`,
@@ -258,7 +258,7 @@ export async function triageWorkstreamMessage(params: {
   try {
     result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
   } catch (error) {
-    console.error('[workstream-router] triage failed:', error instanceof Error ? error.message : error)
+    console.error('[thread-router] triage failed:', error instanceof Error ? error.message : error)
     return null
   }
 
@@ -267,30 +267,30 @@ export async function triageWorkstreamMessage(params: {
   const json = extractJson(effectiveText)
   if (json === null) {
     if (effectiveText.trim()) {
-      console.log('[workstream-router] triage ignored non-json output')
+      console.log('[thread-router] triage ignored non-json output')
     }
     return null
   }
   const parsed = TriageResultSchema.safeParse(json)
   if (!parsed.success) {
-    console.log('[workstream-router] triage parse failed:', JSON.stringify(parsed.error.issues))
+    console.log('[thread-router] triage parse failed:', JSON.stringify(parsed.error.issues))
     return null
   }
   if (!parsed.data.agentId) {
-    console.log('[workstream-router] triage returned empty agentId — fallback to owner')
+    console.log('[thread-router] triage returned empty agentId — fallback to owner')
     return null
   }
   if (!params.members.includes(parsed.data.agentId)) {
-    console.log('[workstream-router] triage returned unknown agent:', parsed.data.agentId)
+    console.log('[thread-router] triage returned unknown agent:', parsed.data.agentId)
     return null
   }
 
-  console.log('[workstream-router] triage routed to:', parsed.data.agentId)
+  console.log('[thread-router] triage routed to:', parsed.data.agentId)
   return parsed.data
 }
 
 export async function checkForNextAgent(params: {
-  workstreamTitle: string
+  threadTitle: string
   members: readonly string[]
   messageText: string
   respondedAgents: string[]
@@ -321,7 +321,7 @@ export async function checkForNextAgent(params: {
   const respondedList = params.respondedAgents.map((id) => readDisplayName(id, displayOptions)).join(', ')
 
   const prompt = [
-    `Workstream: "${params.workstreamTitle}"`,
+    `Thread: "${params.threadTitle}"`,
     `Remaining members:\n${membersDesc}`,
     `Already responded: ${respondedList}`,
     `User message: "${params.messageText}"`,
@@ -333,7 +333,7 @@ export async function checkForNextAgent(params: {
   try {
     result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
   } catch (error) {
-    console.error('[workstream-router] check failed:', error instanceof Error ? error.message : error)
+    console.error('[thread-router] check failed:', error instanceof Error ? error.message : error)
     return { done: true }
   }
 
@@ -342,24 +342,24 @@ export async function checkForNextAgent(params: {
   const json = extractJson(effectiveText)
   if (json === null) {
     if (effectiveText.trim()) {
-      console.log('[workstream-router] check ignored non-json output')
+      console.log('[thread-router] check ignored non-json output')
     }
     return { done: true }
   }
   const parsed = CheckResultSchema.safeParse(json)
   if (!parsed.success) {
-    console.log('[workstream-router] check parse failed:', JSON.stringify(parsed.error.issues))
+    console.log('[thread-router] check parse failed:', JSON.stringify(parsed.error.issues))
     return { done: true }
   }
   if (parsed.data.done) {
-    console.log('[workstream-router] check: done, no more agents needed')
+    console.log('[thread-router] check: done, no more agents needed')
     return { done: true }
   }
   if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) {
-    console.log('[workstream-router] check: invalid agentId:', parsed.data.agentId)
+    console.log('[thread-router] check: invalid agentId:', parsed.data.agentId)
     return { done: true }
   }
 
-  console.log('[workstream-router] check: next agent:', parsed.data.agentId)
+  console.log('[thread-router] check: next agent:', parsed.data.agentId)
   return parsed.data
 }

package/src/system-agents/title-generator.agent.ts

@@ -9,9 +9,9 @@ import {
 import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
-const WORKSTREAM_TITLE_MAX_TOKENS = 512
+const THREAD_TITLE_MAX_TOKENS = 512
 
-export const WORKSTREAM_TITLE_GENERATOR_PROMPT = `<agent-instructions>
+export const THREAD_TITLE_GENERATOR_PROMPT = `<agent-instructions>
 You are a **Title Generator** that creates concise chat titles.
 
 <task>
@@ -20,7 +20,7 @@ Generate a chat title based only on the user's message.
 
 <constraints>
 - Maximum 3-4 words
-- Capture the core workstream or intent
+- Capture the core thread or intent
 - Use natural, readable language
 - No punctuation at the end
 </constraints>
@@ -30,15 +30,15 @@ Return only the title text. No quotes, no labels, no explanation.
 </output-format>
 </agent-instructions>`
 
-export function createWorkstreamTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
+export function createThreadTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
-    id: 'workstream-title-generator',
+    id: 'thread-title-generator',
     model: aiGatewayModel(OPENROUTER_FAST_REASONING_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('workstream-title-generator'),
+    headers: buildAiGatewayDirectCacheHeaders('thread-title-generator'),
     providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
-      instructions: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-      maxOutputTokens: WORKSTREAM_TITLE_MAX_TOKENS,
+      instructions: THREAD_TITLE_GENERATOR_PROMPT,
+      maxOutputTokens: THREAD_TITLE_MAX_TOKENS,
     }),
   })
 }

package/src/tools/execution-plan.tool.ts

@@ -5,19 +5,16 @@ import {
   expandAgentPlanDraft,
   getLatestExecutionPlanResult,
 } from '@lota-sdk/shared'
-import type { ExecutionPlanAction, ExecutionPlanArgs, CreateProjectWithPlanResultData } from '@lota-sdk/shared'
+import type { CreateProjectWithPlanResultData, ExecutionPlanAction, ExecutionPlanArgs } from '@lota-sdk/shared'
 import { tool } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { executionPlanService } from '../services/execution-plan.service'
-import { workstreamService } from '../services/workstream.service'
+import { threadService } from '../services/thread.service'
 
-type ExecutionPlanWorkstreamService = Pick<
-  typeof workstreamService,
-  'createWorkstream' | 'deleteWorkstream' | 'getWorkstream'
->
+type ExecutionPlanThreadService = Pick<typeof threadService, 'createThread' | 'deleteThread' | 'getThread'>
 
 type ExecutionPlanExecutionPlanService = Pick<
   typeof executionPlanService,
@@ -26,90 +23,92 @@ type ExecutionPlanExecutionPlanService = Pick<
   | 'resumeRun'
   | 'listActivePlanSummaries'
   | 'getActivePlanToolResult'
-  | 'getActivePlansForWorkstream'
+  | 'getActivePlansForThread'
 >
 
 function extractDraft(input: ExecutionPlanArgs) {
-  const { action, projectTitle, targetWorkstreamId, runId, reason, ...draftInput } = input
-  return { action, projectTitle, targetWorkstreamId, runId, reason, draft: expandAgentPlanDraft(draftInput) }
+  const { action, projectTitle, targetThreadId, runId, reason, ...draftInput } = input
+  return { action, projectTitle, targetThreadId, runId, reason, draft: expandAgentPlanDraft(draftInput) }
 }
 
 export function createExecutionPlanTool(params: {
   orgId: RecordIdRef
   userId: RecordIdRef
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   agentId: string
   executionPlanService?: ExecutionPlanExecutionPlanService
-  workstreamService?: ExecutionPlanWorkstreamService
+  threadService?: ExecutionPlanThreadService
   onPlanChanged?: () => void
   validateInlinePlan?: (draft: ReturnType<typeof expandAgentPlanDraft>) => void
 }) {
   const resolvedEpService = params.executionPlanService ?? executionPlanService
-  const resolvedWsService = params.workstreamService ?? workstreamService
+  const resolvedWsService = params.threadService ?? threadService
 
   return tool({
     description:
-      'Manage execution plans. Actions: create (inline, 1-2 nodes), create-project (dedicated project workstream, 3+ nodes), replace (swap active plan), resume (resume interrupted plan).',
+      'Manage execution plans. Actions: create (inline, 1-2 nodes), create-project (dedicated project thread, 3+ nodes), replace (swap active plan), resume (resume interrupted plan).',
     inputSchema: ExecutionPlanArgsSchema,
     execute: async (input) => {
-      const { action, projectTitle, targetWorkstreamId, runId, reason, draft } = extractDraft(input)
+      const { action, projectTitle, targetThreadId, runId, reason, draft } = extractDraft(input)
 
       const handler: Record<ExecutionPlanAction, () => Promise<unknown>> = {
         create: async () => {
           params.validateInlinePlan?.(draft)
           return await resolvedEpService.createPlan({
             organizationId: params.orgId,
-            workstreamId: targetWorkstreamId ?? params.workstreamId,
+            threadId: targetThreadId ?? params.threadId,
             leadAgentId: params.agentId,
             input: draft,
           })
         },
 
         'create-project': async () => {
-          const targetWorkstream = targetWorkstreamId
-            ? await resolvedWsService.getWorkstream(targetWorkstreamId)
+          const targetThread = targetThreadId
+            ? await resolvedWsService.getThread(targetThreadId)
             : await (() => {
                 if (!projectTitle) {
                   throw new Error('projectTitle is required when action is "create-project".')
                 }
 
-                return resolvedWsService.createWorkstream(params.userId, params.orgId, {
+                return resolvedWsService.createThread({
+                  userId: params.userId,
+                  organizationId: params.orgId,
                   title: projectTitle,
-                  mode: 'group',
+                  type: 'group',
                 })
               })()
 
-          if (targetWorkstream.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
-            throw new Error('Target workstream belongs to a different organization.')
+          if (targetThread.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
+            throw new Error('Target thread belongs to a different organization.')
           }
-          if (targetWorkstream.userId !== recordIdToString(params.userId, TABLES.USER)) {
-            throw new Error('Target workstream belongs to a different user.')
+          if (targetThread.userId !== recordIdToString(params.userId, TABLES.USER)) {
+            throw new Error('Target thread belongs to a different user.')
           }
 
-          const existingPlans = await resolvedEpService.getActivePlansForWorkstream(targetWorkstream.id)
-          if (!targetWorkstream.core && existingPlans.length > 0) {
+          const existingPlans = await resolvedEpService.getActivePlansForThread(targetThread.id)
+          if (targetThread.type !== 'thread' && existingPlans.length > 0) {
             throw new Error(
-              'This workstream already has an active execution plan. Use action "replace" or target a core workstream.',
+              'This thread already has an active execution plan. Use action "replace" or target a core thread.',
             )
           }
 
-          const createdWorkstream = !targetWorkstreamId
+          const createdThread = !targetThreadId
           try {
             const result = await resolvedEpService.createPlan({
               organizationId: params.orgId,
-              workstreamId: targetWorkstream.id,
+              threadId: targetThread.id,
               leadAgentId: params.agentId,
               input: draft,
             })
             return {
               ...result,
-              workstreamId: targetWorkstream.id,
-              workstreamTitle: targetWorkstream.title,
-              createdWorkstream,
+              threadId: targetThread.id,
+              threadTitle: targetThread.title,
+              createdThread,
             } satisfies CreateProjectWithPlanResultData
           } catch (error) {
-            if (createdWorkstream) {
-              await resolvedWsService.deleteWorkstream(targetWorkstream.id).catch(() => {})
+            if (createdThread) {
+              await resolvedWsService.deleteThread(targetThread.id).catch(() => {})
             }
             throw error
           }
@@ -122,7 +121,7 @@ export function createExecutionPlanTool(params: {
 
           return await resolvedEpService.replacePlan({
             organizationId: params.orgId,
-            workstreamId: params.workstreamId,
+            threadId: params.threadId,
             leadAgentId: params.agentId,
             input: { runId, reason, ...draft },
           })
@@ -134,7 +133,7 @@ export function createExecutionPlanTool(params: {
           }
 
           return await resolvedEpService.resumeRun({
-            workstreamId: params.workstreamId,
+            threadId: params.threadId,
             emittedBy: params.agentId,
             input: { runId },
           })
@@ -148,17 +147,17 @@ export function createExecutionPlanTool(params: {
   })
 }
 
-export function createExecutionPlanQueryTool(params: { workstreamId: RecordIdRef }) {
+export function createExecutionPlanQueryTool(params: { threadId: RecordIdRef }) {
   return tool({
     description:
       'Query execution plans. Omit runId to list all active plans. Provide runId to load a specific plan run.',
     inputSchema: ExecutionPlanQueryArgsSchema,
     execute: async (input) => {
       if (!input.runId) {
-        return await executionPlanService.listActivePlanSummaries(params.workstreamId)
+        return await executionPlanService.listActivePlanSummaries(params.threadId)
       }
       return await executionPlanService.getActivePlanToolResult({
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         runId: input.runId,
         includeEvents: input.includeEvents,
         includeArtifacts: input.includeArtifacts,
@@ -171,7 +170,7 @@ export function createExecutionPlanQueryTool(params: { workstreamId: RecordIdRef
 }
 
 export function createSubmitExecutionNodeResultTool(params: {
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   agentId: string
   onPlanChanged?: () => void
 }) {
@@ -181,7 +180,7 @@ export function createSubmitExecutionNodeResultTool(params: {
     inputSchema: SubmitExecutionNodeResultArgsSchema,
     execute: async (input) => {
       const result = await executionPlanService.submitNodeResult({
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         emittedBy: params.agentId,
         input,
       })

package/src/tools/memory-block.tool.ts

@@ -8,16 +8,16 @@ import {
   prepareMemoryBlockAppend,
   validateMemoryBlockEntry,
 } from '../runtime/memory-block'
-import { workstreamService } from '../services/workstream.service'
+import { threadService } from '../services/thread.service'
 import { safeEnqueue } from '../utils/async'
 
 export function createMemoryBlockTool({
-  workstreamId,
+  threadId,
   agentLabel,
   getCurrentBlock,
   onAppend,
 }: {
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   agentLabel: string
   getCurrentBlock?: () => string
   onAppend?: (value: string) => void
@@ -43,7 +43,7 @@ export function createMemoryBlockTool({
 
       void safeEnqueue(
         async () => {
-          const updated = await workstreamService.appendMemoryBlock(workstreamId, prepared.formatted)
+          const updated = await threadService.appendMemoryBlock(threadId, prepared.formatted)
           onAppend?.(updated)
         },
         { operationName: 'append memory block entry', logPrefix: 'Background memoryBlockAppend task failed' },

package/src/tools/research-topic.tool.ts

@@ -18,4 +18,5 @@ export const researchTopicTool = createDelegatedAgentTool({
   headers: buildAiGatewayStrictSemanticCacheHeaders('researchTopic'),
   instructions: RESEARCHER_PROMPT,
   tools: { searchWeb: searchWebTool.create(), fetchWebpage: fetchWebpageTool.create() },
+  maxSteps: 6,
 })

package/src/tools/search-web.tool.ts

@@ -139,7 +139,7 @@ export const searchWebTool = {
       inputSchema: z
         .object({
           query: z.string().min(1, 'Query is required'),
-          limit: z.number().int().min(1).max(10).optional(),
+          limit: z.number().int().min(1).max(10).default(3),
           sources: z.array(SourceSchema).optional(),
           location: z.string().optional(),
           tbs: z.string().optional(),

package/src/tools/search.tool.ts

@@ -4,7 +4,7 @@ import { z } from 'zod'
 import { isAgentName } from '../config/agent-defaults'
 import type { RecordIdRef } from '../db/record-id'
 import { memoryService } from '../services/memory.service'
-import { workstreamMessageService } from '../services/workstream-message.service'
+import { threadMessageService } from '../services/thread-message.service'
 
 const CONVERSATION_SEARCH_RESULT_LIMIT = 20
 const MemorySearchInputSchema = z.object({ query: z.string().min(1) }).strict()
@@ -36,14 +36,14 @@ export function createMemorySearchTool(
   })
 }
 
-export function createConversationSearchTool(workstreamId: RecordIdRef) {
+export function createConversationSearchTool(threadId: RecordIdRef) {
   return tool({
     description: 'Search prior chat messages by role and query text.',
     inputSchema: ConversationSearchInputSchema,
     execute: async ({ query, type }: z.infer<typeof ConversationSearchInputSchema>) => {
       const normalizedQuery = query.trim()
-      const results = await workstreamMessageService.searchMessages({
-        workstreamId,
+      const results = await threadMessageService.searchMessages({
+        threadId,
         role: type === 'user' ? 'user' : 'assistant',
         query: normalizedQuery,
         limit: CONVERSATION_SEARCH_RESULT_LIMIT,

package/src/tools/team-think.tool.ts

@@ -14,7 +14,7 @@ import type { LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensi
 import { createConsultTeamTool as createConsultTeamToolSdk } from '../runtime/team-consultation-orchestrator'
 import type { DefaultRepoSections, TeamConsultationParticipantRunner } from '../runtime/team-consultation-orchestrator'
 import { buildTeamConsultationResponseGuard } from '../runtime/team-consultation-prompts'
-import { asRecord, readInstructionSections, readOptionalString } from '../runtime/workstream-chat-helpers'
+import { asRecord, readInstructionSections, readOptionalString } from '../runtime/thread-chat-helpers'
 import type { ReadableUploadMetadata } from '../services/attachment.service'
 
 async function buildTeamThinkAgentTools(
@@ -37,7 +37,7 @@ export function createTeamThinkTool(params: {
   latestUserMessageId: string
   orgId: RecordIdRef
   userId: RecordIdRef
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   githubInstalled: boolean
   availableUploads: ReadableUploadMetadata[]
   provideRepoTool: boolean
@@ -60,9 +60,9 @@ export function createTeamThinkTool(params: {
       const agentResolution = asRecord(
         await getTurnHooks().resolveAgent?.({
           agentId,
-          mode: 'fixedWorkstreamMode',
-          workstream: null,
-          workstreamRef: params.workstreamId,
+          mode: 'fixedThreadMode',
+          thread: null,
+          threadRef: params.threadId,
           orgRef: params.orgId,
           userRef: params.userId,
           onboardingActive: false,
@@ -78,8 +78,8 @@ export function createTeamThinkTool(params: {
       const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
       const config = getAgentRuntimeConfig({
         agentId: resolvedAgentId,
-        workstreamMode: 'group' as const,
-        mode: 'fixedWorkstreamMode',
+        threadType: 'group' as const,
+        mode: 'fixedThreadMode',
         onboardingActive: false,
         linearInstalled: false,
         systemWorkspaceDetails: runParams.systemWorkspaceDetails,
@@ -97,7 +97,7 @@ export function createTeamThinkTool(params: {
         workspaceId: params.orgId,
         userId: params.userId,
         workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         githubInstalled: params.githubInstalled,
         provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
         availableUploads: params.availableUploads,
@@ -110,7 +110,7 @@ export function createTeamThinkTool(params: {
       const configuredMaxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
       const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
       const agent = createAgent[agentId_]({
-        mode: 'fixedWorkstreamMode',
+        mode: 'fixedThreadMode',
         tools,
         extraInstructions: agentConfig.extraInstructions,
         maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,

package/src/workers/regular-chat-memory-digest.helpers.ts

@@ -2,7 +2,7 @@ import { isAgentName } from '../config/agent-defaults'
 import { compactWhitespace } from '../utils/string'
 
 interface DigestMessageForTranscript {
-  source: 'workstream' | 'social'
+  source: 'thread' | 'social'
   sourceId: string
   role: 'system' | 'user' | 'assistant'
   parts: Array<Record<string, unknown>>