@lota-sdk/core 0.2.3 → 0.3.0

package/src/create-runtime.ts

@@ -4,7 +4,7 @@ import { configureEmbeddingCache } from './ai/embedding-cache'
 import { configureAgentFactory, configureAgents } from './config/agent-defaults'
 import { configureBackgroundProcessing } from './config/background-processing'
 import { configureLotaLogger } from './config/logger'
-import { configureWorkstreams } from './config/workstream-defaults'
+import { configureThreads } from './config/thread-defaults'
 import { ensureRecordId } from './db/record-id'
 import { computeSchemaFingerprint } from './db/schema-fingerprint'
 import { LOTA_SDK_DATABASE_NAME } from './db/sdk-database'
@@ -17,7 +17,7 @@ import { createRedisConnectionManager } from './redis/connection'
 import { setRedisConnectionManager } from './redis/index'
 import { closeSharedSubscriber } from './redis/stream-context'
 import type { isApprovalContinuationRequest } from './runtime/approval-continuation'
-import { routeWorkstreamChatMessages } from './runtime/chat-request-routing'
+import { routeThreadChatMessages } from './runtime/chat-request-routing'
 import { configureGraphDesigner } from './runtime/graph-designer'
 import type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
 import { configureRuntimeConfig, LOTA_RUNTIME_ENV_KEYS, parseLotaRuntimeConfig } from './runtime/runtime-config'
@@ -57,41 +57,41 @@ import {
   socialChatHistoryService as socialChatHistoryServiceSingleton,
 } from './services/social-chat-history.service'
 import { getBuiltInSystemExecutors } from './services/system-executor.service'
-import type { userService } from './services/user.service'
-import { userService as userServiceSingleton } from './services/user.service'
-import type { workstreamMessageService } from './services/workstream-message.service'
-import { workstreamMessageService as workstreamMessageServiceSingleton } from './services/workstream-message.service'
-import type { workstreamTitleService } from './services/workstream-title.service'
-import { workstreamTitleService as workstreamTitleServiceSingleton } from './services/workstream-title.service'
+import type { threadMessageService } from './services/thread-message.service'
+import { threadMessageService as threadMessageServiceSingleton } from './services/thread-message.service'
+import type { threadTitleService } from './services/thread-title.service'
+import { threadTitleService as threadTitleServiceSingleton } from './services/thread-title.service'
 import type {
-  createWorkstreamApprovalContinuationStream,
-  createWorkstreamNativeToolApprovalStream,
-  createWorkstreamTurnStream,
-  runWorkstreamTurnInBackground,
+  createThreadApprovalContinuationStream,
+  createThreadNativeToolApprovalStream,
+  createThreadTurnStream,
+  runThreadTurnInBackground,
   triggerPlanNodeTurn,
-} from './services/workstream-turn'
+} from './services/thread-turn'
 import {
-  createWorkstreamApprovalContinuationStream as createWorkstreamApprovalContinuationStreamSingleton,
-  createWorkstreamNativeToolApprovalStream as createWorkstreamNativeToolApprovalStreamSingleton,
-  createWorkstreamTurnStream as createWorkstreamTurnStreamSingleton,
+  createThreadApprovalContinuationStream as createThreadApprovalContinuationStreamSingleton,
+  createThreadNativeToolApprovalStream as createThreadNativeToolApprovalStreamSingleton,
+  createThreadTurnStream as createThreadTurnStreamSingleton,
   isApprovalContinuationRequest as isApprovalContinuationRequestSingleton,
-  runWorkstreamTurnInBackground as runWorkstreamTurnInBackgroundSingleton,
+  runThreadTurnInBackground as runThreadTurnInBackgroundSingleton,
   triggerPlanNodeTurn as triggerPlanNodeTurnSingleton,
-} from './services/workstream-turn'
-import type { workstreamService } from './services/workstream.service'
-import { workstreamService as workstreamServiceSingleton } from './services/workstream.service'
+} from './services/thread-turn'
+import type { threadService } from './services/thread.service'
+import { threadService as threadServiceSingleton } from './services/thread.service'
+import type { userService } from './services/user.service'
+import { userService as userServiceSingleton } from './services/user.service'
 import type { generatedDocumentStorageService } from './storage/generated-document-storage.service'
 import { generatedDocumentStorageService as generatedDocumentStorageServiceSingleton } from './storage/generated-document-storage.service'
 
-type ArchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamServiceSingleton.updateStatus>[0],
+type ArchiveSdkThread = (
+  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
   status?: 'archived',
-) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+) => ReturnType<typeof threadServiceSingleton.updateStatus>
 
-type UnarchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamServiceSingleton.updateStatus>[0],
+type UnarchiveSdkThread = (
+  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
   status?: 'regular',
-) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+) => ReturnType<typeof threadServiceSingleton.updateStatus>
 
 let activeRuntimeToken: symbol | null = null
 
@@ -131,14 +131,14 @@ export interface LotaRuntime {
     socialChatHistoryService: typeof socialChatHistoryServiceSingleton
     executionPlanService: typeof executionPlanService
     planAgentQueryService: typeof planAgentQueryService
-    workstreamMessageService: typeof workstreamMessageService
-    workstreamService: typeof workstreamService
-    workstreamTitleService: typeof workstreamTitleService
-    createWorkstreamApprovalContinuationStream: typeof createWorkstreamApprovalContinuationStream
-    createWorkstreamNativeToolApprovalStream: typeof createWorkstreamNativeToolApprovalStream
-    createWorkstreamTurnStream: typeof createWorkstreamTurnStream
+    threadMessageService: typeof threadMessageService
+    threadService: typeof threadService
+    threadTitleService: typeof threadTitleService
+    createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
+    createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
+    createThreadTurnStream: typeof createThreadTurnStream
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
-    runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
+    runThreadTurnInBackground: typeof runThreadTurnInBackground
     triggerPlanNodeTurn: typeof triggerPlanNodeTurn
   }
   lota: {
@@ -164,32 +164,32 @@ export interface LotaRuntime {
       remove: typeof organizationMemberServiceSingleton.removeMembership
       isMember: typeof organizationMemberServiceSingleton.isMember
     }
-    workstreams: {
-      create: typeof workstreamServiceSingleton.createWorkstream
-      list: typeof workstreamServiceSingleton.listWorkstreams
-      get: typeof workstreamServiceSingleton.getWorkstream
-      update: typeof workstreamServiceSingleton.updateTitle
-      archive: ArchiveSdkWorkstream
-      unarchive: UnarchiveSdkWorkstream
-      delete: typeof workstreamServiceSingleton.deleteWorkstream
-      stop: typeof workstreamServiceSingleton.stopActiveRun
-      listMessages: typeof workstreamMessageServiceSingleton.listMessageHistoryPage
-      getMessage: (params: { workstreamId: string; messageId: string }) => Promise<ChatMessage>
+    threads: {
+      create: typeof threadServiceSingleton.createThread
+      list: typeof threadServiceSingleton.listThreads
+      get: typeof threadServiceSingleton.getThread
+      update: typeof threadServiceSingleton.updateTitle
+      archive: ArchiveSdkThread
+      unarchive: UnarchiveSdkThread
+      delete: typeof threadServiceSingleton.deleteThread
+      stop: typeof threadServiceSingleton.stopActiveRun
+      listMessages: typeof threadMessageServiceSingleton.listMessageHistoryPage
+      getMessage: (params: { threadId: string; messageId: string }) => Promise<ChatMessage>
       sendMessage: (params: {
-        workstreamId: string
+        threadId: string
         organizationId: string
         userId: string
         userName: string
-        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
-      }) => Promise<Awaited<ReturnType<typeof createWorkstreamTurnStream>>>
+        messages: Parameters<typeof routeThreadChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createThreadTurnStream>>>
       continueApproval: (params: {
-        workstreamId: string
+        threadId: string
         organizationId: string
         userId: string
         userName: string
-        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
-      }) => Promise<Awaited<ReturnType<typeof createWorkstreamApprovalContinuationStream>>>
-      uploadAttachment: typeof attachmentServiceSingleton.uploadWorkstreamAttachment
+        messages: Parameters<typeof routeThreadChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createThreadApprovalContinuationStream>>>
+      uploadAttachment: typeof attachmentServiceSingleton.uploadThreadAttachment
     }
   }
   redis: {
@@ -253,7 +253,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       descriptions: runtimeConfig.agents.descriptions,
       routerModelId: runtimeConfig.agents.routerModelId,
       teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
-      getCoreWorkstreamProfile: runtimeConfig.agents.getCoreWorkstreamProfile,
+      getCoreThreadProfile: runtimeConfig.agents.getCoreThreadProfile,
     })
     configureAgentFactory({
       createAgent: runtimeConfig.agents.createAgent,
@@ -261,7 +261,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       getAgentRuntimeConfig: runtimeConfig.agents.getAgentRuntimeConfig,
       pluginRuntime: runtimeConfig.pluginRuntime,
     })
-    configureWorkstreams({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.workstreams })
+    configureThreads({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.threads })
     configureNotificationService(runtimeConfig.notificationService ?? null)
     configureRuntimeExtensions({
       adapters: runtimeConfig.runtimeAdapters,
@@ -311,65 +311,61 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         remove: organizationMemberServiceSingleton.removeMembership.bind(organizationMemberServiceSingleton),
         isMember: organizationMemberServiceSingleton.isMember.bind(organizationMemberServiceSingleton),
       },
-      workstreams: {
-        create: workstreamServiceSingleton.createWorkstream.bind(workstreamServiceSingleton),
-        list: workstreamServiceSingleton.listWorkstreams.bind(workstreamServiceSingleton),
-        get: workstreamServiceSingleton.getWorkstream.bind(workstreamServiceSingleton),
-        update: workstreamServiceSingleton.updateTitle.bind(workstreamServiceSingleton),
-        archive: async (workstreamId, status = 'archived') =>
-          await workstreamServiceSingleton.updateStatus(workstreamId, status),
-        unarchive: async (workstreamId, status = 'regular') =>
-          await workstreamServiceSingleton.updateStatus(workstreamId, status),
-        delete: workstreamServiceSingleton.deleteWorkstream.bind(workstreamServiceSingleton),
-        stop: workstreamServiceSingleton.stopActiveRun.bind(workstreamServiceSingleton),
-        listMessages: workstreamMessageServiceSingleton.listMessageHistoryPage.bind(workstreamMessageServiceSingleton),
-        getMessage: async ({ workstreamId, messageId }) => {
-          const messages = await workstreamMessageServiceSingleton.listMessages(
-            ensureRecordId(workstreamId, TABLES.WORKSTREAM),
-          )
+      threads: {
+        create: threadServiceSingleton.createThread.bind(threadServiceSingleton),
+        list: threadServiceSingleton.listThreads.bind(threadServiceSingleton),
+        get: threadServiceSingleton.getThread.bind(threadServiceSingleton),
+        update: threadServiceSingleton.updateTitle.bind(threadServiceSingleton),
+        archive: async (threadId, status = 'archived') => await threadServiceSingleton.updateStatus(threadId, status),
+        unarchive: async (threadId, status = 'regular') => await threadServiceSingleton.updateStatus(threadId, status),
+        delete: threadServiceSingleton.deleteThread.bind(threadServiceSingleton),
+        stop: threadServiceSingleton.stopActiveRun.bind(threadServiceSingleton),
+        listMessages: threadMessageServiceSingleton.listMessageHistoryPage.bind(threadMessageServiceSingleton),
+        getMessage: async ({ threadId, messageId }) => {
+          const messages = await threadMessageServiceSingleton.listMessages(ensureRecordId(threadId, TABLES.THREAD))
           const message = messages.find((candidate) => candidate.id === messageId)
           if (!message) {
-            throw new Error(`Workstream message not found: ${messageId}`)
+            throw new Error(`Thread message not found: ${messageId}`)
           }
           return message
         },
-        sendMessage: async ({ workstreamId, organizationId, userId, userName, messages }) => {
-          const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-          const workstream = await workstreamServiceSingleton.getWorkstream(workstreamRef)
-          const routed = routeWorkstreamChatMessages(messages)
+        sendMessage: async ({ threadId, organizationId, userId, userName, messages }) => {
+          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+          const thread = await threadServiceSingleton.getThread(threadRef)
+          const routed = routeThreadChatMessages(messages)
           if (routed.kind !== 'turn') {
             throw new Error(routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.')
           }
 
-          return createWorkstreamTurnStreamSingleton({
-            workstream,
-            workstreamRef,
+          return createThreadTurnStreamSingleton({
+            thread,
+            threadRef,
             orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
             userRef: ensureRecordId(userId, TABLES.USER),
             userName,
             inputMessage: routed.inputMessage,
           })
         },
-        continueApproval: async ({ workstreamId, organizationId, userId, userName, messages }) => {
-          const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-          const workstream = await workstreamServiceSingleton.getWorkstream(workstreamRef)
-          const routed = routeWorkstreamChatMessages(messages)
+        continueApproval: async ({ threadId, organizationId, userId, userName, messages }) => {
+          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+          const thread = await threadServiceSingleton.getThread(threadRef)
+          const routed = routeThreadChatMessages(messages)
           if (routed.kind !== 'approval-continuation') {
             throw new Error(
               routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
             )
           }
 
-          return createWorkstreamApprovalContinuationStreamSingleton({
-            workstream,
-            workstreamRef,
+          return createThreadApprovalContinuationStreamSingleton({
+            thread,
+            threadRef,
             orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
             userRef: ensureRecordId(userId, TABLES.USER),
             userName,
             approvalMessages: routed.approvalMessages,
           })
         },
-        uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
+        uploadAttachment: attachmentServiceSingleton.uploadThreadAttachment.bind(attachmentServiceSingleton),
       },
     } satisfies LotaRuntime['lota']
 
@@ -395,14 +391,14 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         socialChatHistoryService: socialChatHistoryServiceSingleton,
         executionPlanService: executionPlanServiceSingleton,
         planAgentQueryService: planAgentQueryServiceSingleton,
-        workstreamMessageService: workstreamMessageServiceSingleton,
-        workstreamService: workstreamServiceSingleton,
-        workstreamTitleService: workstreamTitleServiceSingleton,
-        createWorkstreamApprovalContinuationStream: createWorkstreamApprovalContinuationStreamSingleton,
-        createWorkstreamNativeToolApprovalStream: createWorkstreamNativeToolApprovalStreamSingleton,
-        createWorkstreamTurnStream: createWorkstreamTurnStreamSingleton,
+        threadMessageService: threadMessageServiceSingleton,
+        threadService: threadServiceSingleton,
+        threadTitleService: threadTitleServiceSingleton,
+        createThreadApprovalContinuationStream: createThreadApprovalContinuationStreamSingleton,
+        createThreadNativeToolApprovalStream: createThreadNativeToolApprovalStreamSingleton,
+        createThreadTurnStream: createThreadTurnStreamSingleton,
         isApprovalContinuationRequest: isApprovalContinuationRequestSingleton,
-        runWorkstreamTurnInBackground: runWorkstreamTurnInBackgroundSingleton,
+        runThreadTurnInBackground: runThreadTurnInBackgroundSingleton,
         triggerPlanNodeTurn: triggerPlanNodeTurnSingleton,
       },
       lota,
@@ -456,7 +452,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
 function getBuiltInSchemaFiles(): URL[] {
   return [
     new URL('../infrastructure/schema/00_identity.surql', import.meta.url),
-    new URL('../infrastructure/schema/00_workstream.surql', import.meta.url),
+    new URL('../infrastructure/schema/00_thread.surql', import.meta.url),
     new URL('../infrastructure/schema/01_memory.surql', import.meta.url),
     new URL('../infrastructure/schema/02_execution_plan.surql', import.meta.url),
     new URL('../infrastructure/schema/03_learned_skill.surql', import.meta.url),

package/src/db/tables.ts

@@ -1,8 +1,8 @@
 export const TABLES = {
-  WORKSTREAM_MESSAGE: 'workstreamMessage',
-  WORKSTREAM: 'workstream',
+  THREAD: 'thread',
+  THREAD_MESSAGE: 'threadMessage',
+  THREAD_ATTACHMENT: 'threadAttachment',
   RUNTIME_BOOTSTRAP: 'runtimeBootstrap',
-  WORKSTREAM_ATTACHMENT: 'workstreamAttachment',
   MEMORY: 'memory',
   MEMORY_RELATION: 'memoryRelation',
   MEMORY_HISTORY: 'memoryHistory',

package/src/db/{workstream-message-row.ts → thread-message-row.ts}

@@ -1,9 +1,9 @@
 import { recordIdSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
-export const WorkstreamMessageRowSchema = z.object({
+export const ThreadMessageRowSchema = z.object({
   id: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   messageId: z.string(),
   role: z.enum(['system', 'user', 'assistant']),
   parts: z.array(z.record(z.string(), z.unknown())).optional(),
@@ -12,4 +12,4 @@ export const WorkstreamMessageRowSchema = z.object({
   updatedAt: z.coerce.date().optional(),
 })
 
-export type WorkstreamMessageRow = z.infer<typeof WorkstreamMessageRowSchema>
+export type ThreadMessageRow = z.infer<typeof ThreadMessageRowSchema>

package/src/queues/context-compaction.queue.ts

@@ -4,11 +4,11 @@ import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { contextCompactionService } from '../services/context-compaction.service'
-import { workstreamService } from '../services/workstream.service'
+import { threadService } from '../services/thread.service'
 import { createQueueFactory } from './queue-factory'
 
 interface ContextCompactionJob {
-  domain: 'workstream'
+  domain: 'thread'
   entityId: string
   contextSize?: number
 }
@@ -17,12 +17,12 @@ async function processContextCompactionJob(job: Job<ContextCompactionJob>): Prom
   await databaseService.connect()
 
   const { entityId, contextSize } = job.data
-  const workstreamRef = ensureRecordId(entityId, TABLES.WORKSTREAM)
-  await workstreamService.setCompacting(workstreamRef, true)
+  const threadRef = ensureRecordId(entityId, TABLES.THREAD)
+  await threadService.setCompacting(threadRef, true)
   try {
-    await contextCompactionService.compactWorkstreamHistory({ workstreamId: workstreamRef, contextSize })
+    await contextCompactionService.compactThreadHistory({ threadId: threadRef, contextSize })
   } finally {
-    await workstreamService.setCompacting(workstreamRef, false)
+    await threadService.setCompacting(threadRef, false)
   }
 }
 

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -10,7 +10,7 @@ import { createQueueFactory } from './queue-factory'
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -58,7 +58,7 @@ const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
 
 function buildWakeJobId(params: {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -70,7 +70,7 @@ function buildWakeJobId(params: {
 
 export async function enqueuePlanAgentHeartbeatWake(params: {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string

package/src/queues/post-chat-memory.queue.ts

@@ -13,7 +13,7 @@ interface PostChatMemoryMessage {
 
 interface PostChatMemoryExtractionJob {
   orgId: string
-  workstreamId: string
+  threadId: string
   sourceId: string
   source?: string
   sourceMetadata?: Record<string, unknown>

package/src/queues/title-generation.queue.ts

@@ -3,18 +3,18 @@ import type { Job } from 'bullmq'
 import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { recentActivityTitleService } from '../services/recent-activity-title.service'
-import { workstreamTitleService } from '../services/workstream-title.service'
+import { threadTitleService } from '../services/thread-title.service'
 import { createQueueFactory } from './queue-factory'
 
 export const TITLE_GENERATION_QUEUE = 'title-generation'
 
-// This queue merges workstream title generation and recent-activity title
+// This queue merges thread title generation and recent-activity title
 // refinement because both are short-lived title synthesis jobs with the same
 // operational shape.
 
-interface WorkstreamTitleGenerationJob {
-  kind: 'workstream-title'
-  workstreamId: string
+interface ThreadTitleGenerationJob {
+  kind: 'thread-title'
+  threadId: string
   sourceText: string
 }
 
@@ -23,12 +23,12 @@ interface RecentActivityTitleRefinementJob {
   activityId: string
 }
 
-type TitleGenerationJob = WorkstreamTitleGenerationJob | RecentActivityTitleRefinementJob
+type TitleGenerationJob = ThreadTitleGenerationJob | RecentActivityTitleRefinementJob
 
 async function processTitleGenerationJob(job: Job<TitleGenerationJob>): Promise<void> {
   await databaseService.connect()
-  if (job.data.kind === 'workstream-title') {
-    await workstreamTitleService.generateAndPersistTitle(ensureRecordId(job.data.workstreamId), job.data.sourceText)
+  if (job.data.kind === 'thread-title') {
+    await threadTitleService.generateAndPersistTitle(ensureRecordId(job.data.threadId), job.data.sourceText)
     return
   }
 
@@ -45,11 +45,8 @@ const titleGeneration = createQueueFactory<TitleGenerationJob>({
   processor: processTitleGenerationJob,
 })
 
-export function enqueueWorkstreamTitleGeneration(job: Omit<WorkstreamTitleGenerationJob, 'kind'>) {
-  return titleGeneration.enqueue(
-    { kind: 'workstream-title', ...job },
-    { jobId: `workstream-title:${job.workstreamId}` },
-  )
+export function enqueueThreadTitleGeneration(job: Omit<ThreadTitleGenerationJob, 'kind'>) {
+  return titleGeneration.enqueue({ kind: 'thread-title', ...job }, { jobId: `thread-title:${job.threadId}` })
 }
 
 export function enqueueRecentActivityTitleRefinement(job: Omit<RecentActivityTitleRefinementJob, 'kind'>) {

package/src/redis/index.ts

@@ -9,7 +9,7 @@ export {
 } from './connection-accessor'
 export { withOrgMemoryLock } from './org-memory-lock'
 export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
-export { closeSharedSubscriber, createWorkstreamResumableContext } from './stream-context'
+export { closeSharedSubscriber, createThreadResumableContext } from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }

package/src/redis/stream-context.ts

@@ -55,7 +55,7 @@ export async function closeSharedSubscriber(): Promise<void> {
   }
 }
 
-export function createWorkstreamResumableContext() {
+export function createThreadResumableContext() {
   const redis = getRedisConnection()
   return createResumableStreamContext({
     waitUntil: null,

package/src/runtime/agent-identity-overrides.ts

@@ -1,5 +1,5 @@
 import { agentDisplayNames } from '../config/agent-defaults'
-import { asRecord, readOptionalString } from './workstream-chat-helpers'
+import { asRecord, readOptionalString } from './thread-chat-helpers'
 
 interface RuntimeAgentIdentityOverrides {
   displayNamesById: Partial<Record<string, string>>

package/src/runtime/agent-runtime-policy.ts

@@ -7,7 +7,7 @@ import type {
 } from '@lota-sdk/shared'
 
 import { getLeadAgentId } from '../config/agent-defaults'
-import { resolveOnboardingOwnerAgentId } from '../config/workstream-defaults'
+import { resolveOnboardingOwnerAgentId } from '../config/thread-defaults'
 import type { ChatMode } from './agent-types'
 export interface AgentRuntimeConfig<TAgent extends string> {
   id: TAgent
@@ -73,15 +73,13 @@ function buildOwnershipDispatchArtifactPayload(artifacts: PlanArtifactSubmission
   return artifacts.map((artifact) => ({
     name: artifact.name,
     kind: artifact.kind,
-    pointer: artifact.pointer,
-    ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
     ...(artifact.description ? { description: artifact.description } : {}),
     ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
   }))
 }
 
-export function toChatMode(workstreamMode: 'direct' | 'group'): ChatMode {
-  return workstreamMode === 'direct' ? 'fixedWorkstreamMode' : 'workstreamMode'
+export function toChatMode(threadType: string): ChatMode {
+  return threadType === 'default' ? 'fixedThreadMode' : 'threadMode'
 }
 
 function toMemoryBlockSection(memoryBlock: string | undefined): string | undefined {
@@ -92,13 +90,13 @@ function toMemoryBlockSection(memoryBlock: string | undefined): string | undefin
 
 export function resolveActiveAgentSkills<TAgent extends string, TSkill extends PropertyKey>(params: {
   agentId: TAgent
-  workstreamMode: 'direct' | 'group'
+  threadType: string
   mode?: ChatMode
   onboardingActive: boolean
   linearInstalled: boolean
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): TSkill[] {
-  const mode = params.mode ?? toChatMode(params.workstreamMode)
+  const mode = params.mode ?? toChatMode(params.threadType)
   return params
     .getAgentSkills(params.agentId, mode)
     .filter((skill) => (params.linearInstalled ? true : skill !== ('linear' as TSkill)))
@@ -107,7 +105,7 @@ export function resolveActiveAgentSkills<TAgent extends string, TSkill extends P
 export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends PropertyKey>(params: {
   agentId: TAgent
   displayNameByAgent: Record<TAgent, string>
-  workstreamMode: 'direct' | 'group'
+  threadType: string
   mode?: ChatMode
   skills?: TSkill[]
   onboardingActive: boolean
@@ -115,7 +113,7 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   systemWorkspaceDetails?: string
   preSeededMemoriesSection?: string
   retrievedKnowledgeSection?: string
-  workstreamMemoryBlock?: string
+  threadMemoryBlock?: string
   responseGuardSection?: string
   learnedSkillsSection?: string
   additionalInstructionSections?: string[]
@@ -125,7 +123,7 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   buildSkillInstructionSection: (skills: TSkill[]) => string
   buildOnboardingPromptSection: () => string
 }): AgentRuntimeConfig<TAgent> {
-  const mode = params.mode ?? toChatMode(params.workstreamMode)
+  const mode = params.mode ?? toChatMode(params.threadType)
   const rulesSection = params.buildGlobalRuleInstructionSection(params.ruleOptions)
   const skillsSection =
     params.skills && params.skills.length > 0 ? params.buildSkillInstructionSection(params.skills) : ''
@@ -138,7 +136,7 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
     params.systemWorkspaceDetails?.trim(),
     params.preSeededMemoriesSection?.trim(),
     params.retrievedKnowledgeSection?.trim(),
-    toMemoryBlockSection(params.workstreamMemoryBlock),
+    toMemoryBlockSection(params.threadMemoryBlock),
     ...(params.additionalInstructionSections?.map((section) => section.trim()) ?? []),
     params.responseGuardSection?.trim(),
     params.onboardingActive ? 'Onboarding is active. Keep responses onboarding-focused and concise.' : undefined,
@@ -154,9 +152,9 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   }
 }
 
-export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
+export function buildThreadAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
   agentId: TAgent
-  workstreamMode: 'direct' | 'group'
+  threadType: string
   mode?: ChatMode
   onboardingActive: boolean
   linearInstalled: boolean
@@ -164,11 +162,11 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
   provideRepoTool: boolean
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): AgentToolPolicy<TSkill> {
-  const resolvedMode = params.mode ?? toChatMode(params.workstreamMode)
+  const resolvedMode = params.mode ?? toChatMode(params.threadType)
   const onboardingOwnerAgentId = resolveOnboardingOwnerAgentId(getLeadAgentId()) as TAgent
   const skills = resolveActiveAgentSkills({
     agentId: params.agentId,
-    workstreamMode: params.workstreamMode,
+    threadType: params.threadType,
     mode: resolvedMode,
     onboardingActive: params.onboardingActive,
     linearInstalled: params.linearInstalled,
@@ -203,7 +201,7 @@ export function buildTeamConsultationAgentToolPolicy({
   provideRepoTool: boolean
 }): AgentToolPolicy<string> & { blockedToolNames: Set<string> } {
   return {
-    resolvedMode: 'fixedWorkstreamMode',
+    resolvedMode: 'fixedThreadMode',
     skills: [],
     includeMemorySearch: false,
     includeConversationSearch: false,
@@ -249,9 +247,9 @@ export function buildOwnershipDispatchContextSection(params: {
   return [
     '<ownership-dispatch-execution>',
     'You are executing a single isolated execution-plan node.',
-    'Do not ask the user questions. Do not reference any hidden or prior workstream chat history.',
-    'Use only the provided node context, resolved input, input artifacts, and upstream handoff context.',
-    'Return only the final structured node result that satisfies the required output contract, including durable handoffContext for downstream nodes.',
+    'Do not ask the user questions. Do not reference any hidden or prior thread chat history.',
+    'Use only the provided node context, resolved input, input artifacts, and upstream summaries.',
+    'Return only the final structured node result that satisfies the required output contract.',
     JSON.stringify(payload, null, 2),
     '</ownership-dispatch-execution>',
   ].join('\n')
@@ -268,14 +266,14 @@ export function buildOwnershipDispatchResponseGuard(params: {
     return [
       '<ownership-dispatch-result-contract>',
       'Return a single JSON object with this exact shape:',
-      '{"structuredOutput"?: object, "artifacts": Array<{ "name": string, "kind": "json"|"markdown"|"file"|"external-ref"|"record", "pointer": string, "schemaRef"?: string, "description"?: string, "payload"?: object|array }>, "notes"?: string, "handoffContext"?: { "summary": string, "keyDecisions"?: string[], "openQuestions"?: string[], "risks"?: string[], "recommendations"?: string[], "references"?: string[] }}',
+      '{"notes": string, "structuredOutput"?: object, "artifacts": Array<{ "name": string, "kind": "json"|"markdown"|"file"|"external-ref"|"record", "description"?: string, "payload"?: object|array }>}',
       'Do not wrap the JSON in markdown or code fences.',
       `Node label: ${params.node.label}`,
       `Required deliverables: ${params.node.deliverables.length > 0 ? params.node.deliverables.map((item) => item.name).join(', ') : 'none'}`,
       ...(completionCheckHints.length > 0
         ? ['Structured output fields required by completion checks:', ...completionCheckHints]
         : []),
-      'If downstream nodes depend on this work, include handoffContext.',
+      'notes is required. Include a concise summary of what was done, key decisions, and any context downstream nodes need.',
       '</ownership-dispatch-result-contract>',
     ].join('\n')
   }

package/src/runtime/chat-request-routing.ts

@@ -8,7 +8,7 @@ export type RoutedChatRequest =
   | { kind: 'turn'; inputMessage: ChatMessage }
   | { kind: 'invalid'; message: string }
 
-export function routeWorkstreamChatMessages(messages: ChatMessage[]): RoutedChatRequest {
+export function routeThreadChatMessages(messages: ChatMessage[]): RoutedChatRequest {
   if (isApprovalContinuationRequest(messages)) {
     if (isNativeToolApprovalRequest(messages)) {
       return { kind: 'native-tool-approval', messages }