@lota-sdk/core 0.2.3 → 0.3.0

package/src/services/agent-activity.service.ts

@@ -16,8 +16,8 @@ import type {
 import { agentRoster } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { executionPlanService } from './execution-plan.service'
-import { workstreamService } from './workstream.service'
-import type { NormalizedWorkstream } from './workstream.types'
+import { threadService } from './thread.service'
+import type { NormalizedThread } from './thread.types'
 
 const BOARD_COLUMN_ORDER = ['ready', 'running', 'awaiting-human', 'completed', 'blocked', 'failed'] as const
 type BoardColumnStatus = (typeof BOARD_COLUMN_ORDER)[number]
@@ -33,12 +33,12 @@ const COLUMN_LABELS: Record<BoardColumnStatus, string> = {
 
 type ActivePlanEntry = {
   plan: SerializableExecutionPlan
-  workstream: Pick<NormalizedWorkstream, 'id' | 'title' | 'isRunning' | 'updatedAt'>
+  thread: Pick<NormalizedThread, 'id' | 'title' | 'isRunning' | 'updatedAt'>
 }
 
 type AgentActivityDeps = {
-  executionPlanService: Pick<typeof executionPlanService, 'getActivePlansForWorkstream'>
-  workstreamService: Pick<typeof workstreamService, 'listWorkstreams'>
+  executionPlanService: Pick<typeof executionPlanService, 'getActivePlansForThread'>
+  threadService: Pick<typeof threadService, 'listThreads'>
 }
 
 function normalizeCardStatus(status: string): BoardColumnStatus {
@@ -97,8 +97,8 @@ function incrementCounts(counts: AgentActivityCounts, rawStatus: string): void {
 export function planNodeToCard(
   node: SerializablePlanNode,
   plan: SerializableExecutionPlan,
-  workstreamId: string,
-  workstreamTitle: string,
+  threadId: string,
+  threadTitle: string,
 ): PlanNodeCard {
   const approval = plan.approvals.find((candidate) => candidate.nodeId === node.id && candidate.status === 'pending')
 
@@ -111,8 +111,8 @@ export function planNodeToCard(
     ownerRef: node.owner.ref,
     planRunId: plan.runId,
     planTitle: plan.title,
-    workstreamId,
-    workstreamTitle,
+    threadId,
+    threadTitle,
     nodeType: node.type,
     artifactCount: plan.artifacts.filter((artifact) => artifact.nodeId === node.id).length,
     hasApproval: Boolean(approval),
@@ -129,11 +129,11 @@ export function planNodeToCard(
 function buildPlanViewNode(
   node: SerializablePlanNode,
   plan: SerializableExecutionPlan,
-  workstreamId: string,
-  workstreamTitle: string,
+  threadId: string,
+  threadTitle: string,
 ): PlanViewNode {
   return {
-    ...planNodeToCard(node, plan, workstreamId, workstreamTitle),
+    ...planNodeToCard(node, plan, threadId, threadTitle),
     deliverableNames: node.deliverables.map((deliverable) => deliverable.name),
     upstreamNodeIds: node.upstreamNodeIds,
     downstreamNodeIds: node.downstreamNodeIds,
@@ -141,12 +141,12 @@ function buildPlanViewNode(
 }
 
 export class AgentActivityService {
-  constructor(private readonly deps: AgentActivityDeps = { executionPlanService, workstreamService }) {}
+  constructor(private readonly deps: AgentActivityDeps = { executionPlanService, threadService }) {}
 
   async getBoard(userRef: string, orgRef: string): Promise<PlanBoardResponse> {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const cards = activePlans.flatMap(({ plan, workstream }) =>
-      plan.nodes.map((node) => planNodeToCard(node, plan, workstream.id, workstream.title)),
+    const cards = activePlans.flatMap(({ plan, thread }) =>
+      plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)),
     )
 
     const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
@@ -171,7 +171,7 @@ export class AgentActivityService {
     const match = activePlans.find(({ plan }) => plan.runId === planRunId)
     if (!match) return null
 
-    const { plan, workstream } = match
+    const { plan, thread } = match
     return {
       planRunId: plan.runId,
       title: plan.title,
@@ -179,7 +179,7 @@ export class AgentActivityService {
       status: plan.status,
       leadAgentId: plan.leadAgentId,
       progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
-      nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, workstream.id, workstream.title)),
+      nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
       edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
     }
   }
@@ -188,13 +188,13 @@ export class AgentActivityService {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
     const tasks: PlanNodeCard[] = []
 
-    for (const { plan, workstream } of activePlans) {
+    for (const { plan, thread } of activePlans) {
       for (const node of plan.nodes) {
         const humanOwned = node.owner.executorType === 'user'
         const awaitingHuman = node.status === 'awaiting-human'
         if (!humanOwned && !awaitingHuman) continue
 
-        tasks.push(planNodeToCard(node, plan, workstream.id, workstream.title))
+        tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
       }
     }
 
@@ -209,7 +209,7 @@ export class AgentActivityService {
       activityByAgent.set(agentId, this.createEmptyEntry(agentId))
     }
 
-    for (const { plan, workstream } of activePlans) {
+    for (const { plan, thread } of activePlans) {
       const involvedAgents = new Set<string>()
 
       for (const node of plan.nodes) {
@@ -221,7 +221,7 @@ export class AgentActivityService {
         incrementCounts(entry.counts, node.status)
 
         if (!isCompletedStatus(node.status)) {
-          entry.tasks.push(planNodeToCard(node, plan, workstream.id, workstream.title))
+          entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
         }
       }
 
@@ -234,15 +234,15 @@ export class AgentActivityService {
       for (const agentId of involvedAgents) {
         const entry = this.ensureEntry(activityByAgent, agentId)
         this.ensureProjectEntry(entry.projects, {
-          workstreamId: workstream.id,
-          workstreamTitle: workstream.title,
+          threadId: thread.id,
+          threadTitle: thread.title,
           planRunId: plan.runId,
           planTitle: plan.title,
           status: plan.status,
         })
 
-        entry.isRunning = entry.isRunning || workstream.isRunning
-        entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, workstream.updatedAt)
+        entry.isRunning = entry.isRunning || thread.isRunning
+        entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
       }
     }
 
@@ -265,7 +265,7 @@ export class AgentActivityService {
         pendingApprovalCount: userTasks.pendingApprovalCount,
         awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
         lastActiveAt: activePlans.reduce<string | null>(
-          (latest, entry) => maxIsoDate(latest, entry.workstream.updatedAt),
+          (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
           null,
         ),
       },
@@ -274,14 +274,14 @@ export class AgentActivityService {
   }
 
   async getAllActivePlans(userRef: string, orgRef: string): Promise<ActivePlanEntry[]> {
-    const workstreams = await this.listRelevantWorkstreams(userRef, orgRef)
+    const threads = await this.listRelevantThreads(userRef, orgRef)
     const planResults = await Promise.all(
-      workstreams.map(async (workstream) => {
+      threads.map(async (thread) => {
         try {
-          const plans = await this.deps.executionPlanService.getActivePlansForWorkstream(workstream.id)
-          return plans.map((plan) => ({ plan, workstream }))
+          const plans = await this.deps.executionPlanService.getActivePlansForThread(thread.id)
+          return plans.map((plan) => ({ plan, thread }))
         } catch (error) {
-          serverLogger.error`Failed to load active plans for workstream ${workstream.id}: ${error}`
+          serverLogger.error`Failed to load active plans for thread ${thread.id}: ${error}`
           return []
         }
       }),
@@ -290,26 +290,21 @@ export class AgentActivityService {
     return planResults.flat()
   }
 
-  private async listRelevantWorkstreams(userRef: string, orgRef: string): Promise<NormalizedWorkstream[]> {
+  private async listRelevantThreads(userRef: string, orgRef: string): Promise<NormalizedThread[]> {
     const [direct, core, group] = await Promise.all([
-      this.deps.workstreamService.listWorkstreams(userRef, orgRef, { mode: 'direct', includeArchived: false }),
-      this.deps.workstreamService.listWorkstreams(userRef, orgRef, {
-        mode: 'group',
-        core: true,
-        includeArchived: false,
-      }),
-      this.deps.workstreamService.listWorkstreams(userRef, orgRef, {
-        mode: 'group',
-        core: false,
+      this.deps.threadService.listThreads(userRef, orgRef, { type: 'default', includeArchived: false }),
+      this.deps.threadService.listThreads(userRef, orgRef, { type: 'thread', includeArchived: false }),
+      this.deps.threadService.listThreads(userRef, orgRef, {
+        type: 'group',
         includeArchived: false,
         take: 500,
         page: 1,
       }),
     ])
 
-    const deduped = new Map<string, NormalizedWorkstream>()
-    for (const workstream of [...direct.workstreams, ...core.workstreams, ...group.workstreams]) {
-      deduped.set(workstream.id, workstream)
+    const deduped = new Map<string, NormalizedThread>()
+    for (const thread of [...direct.threads, ...core.threads, ...group.threads]) {
+      deduped.set(thread.id, thread)
     }
 
     return [...deduped.values()]

package/src/services/agent-executor.service.ts

@@ -24,10 +24,10 @@ import {
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import { buildIndexedRepositoriesContext, getPluginService } from '../runtime/plugin-resolution'
 import { getTurnHooks } from '../runtime/runtime-extensions'
-import { asRecord, readInstructionSections, readOptionalString } from '../runtime/workstream-chat-helpers'
+import { asRecord, readInstructionSections, readOptionalString } from '../runtime/thread-chat-helpers'
 import { nodeWorkspaceService } from './node-workspace.service'
 import type { PlanValidationIssueInput } from './plan-validator.service'
-import { WorkstreamSchema } from './workstream.types'
+import { ThreadSchema } from './thread.types'
 import { writeIntentValidatorService } from './write-intent-validator.service'
 
 function applyToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpec): ToolSet {
@@ -108,20 +108,20 @@ class AgentExecutorService {
       throw new Error(`Agent executor "${agentId}" is not registered.`)
     }
 
-    const workstream = await databaseService.findOne(
-      TABLES.WORKSTREAM,
-      { id: ensureRecordId(params.context.workstreamId, TABLES.WORKSTREAM) },
-      WorkstreamSchema,
+    const thread = await databaseService.findOne(
+      TABLES.THREAD,
+      { id: ensureRecordId(params.context.threadId, TABLES.THREAD) },
+      ThreadSchema,
     )
-    if (!workstream) {
-      throw new Error(`Workstream ${params.context.workstreamId} not found for dispatched execution.`)
+    if (!thread) {
+      throw new Error(`Thread ${params.context.threadId} not found for dispatched execution.`)
     }
 
     const organizationRef = ensureRecordId(params.context.organizationId, TABLES.ORGANIZATION)
-    const workstreamRef = ensureRecordId(params.context.workstreamId, TABLES.WORKSTREAM)
-    const userRefSource = params.context.userId ?? workstream.userId
+    const threadRef = ensureRecordId(params.context.threadId, TABLES.THREAD)
+    const userRefSource = params.context.userId ?? thread.userId
     if (!userRefSource) {
-      throw new Error(`Workstream ${params.context.workstreamId} is missing a user context for dispatched execution.`)
+      throw new Error(`Thread ${params.context.threadId} is missing a user context for dispatched execution.`)
     }
     const userRef = ensureRecordId(userRefSource, TABLES.USER)
     const userName = params.context.userName ?? 'User'
@@ -147,7 +147,7 @@ class AgentExecutorService {
 
     const mode = params.executionMode ?? 'linear'
 
-    const dispatchMode = workstream.mode === 'group' ? 'fixedWorkstreamMode' : 'direct'
+    const dispatchMode = thread.type === 'group' ? 'fixedThreadMode' : 'direct'
     const dispatchInstructionSections = [
       buildOwnershipDispatchContextSection({
         node: params.nodeSpec,
@@ -161,8 +161,8 @@ class AgentExecutorService {
       await turnHooks.resolveAgent?.({
         agentId,
         mode: dispatchMode,
-        workstream,
-        workstreamRef,
+        thread,
+        threadRef,
         orgRef: organizationRef,
         userRef,
         userName,
@@ -176,7 +176,7 @@ class AgentExecutorService {
     const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
     const runtimeConfig = getAgentRuntimeConfig({
       agentId: resolvedAgentId,
-      workstreamMode: workstream.mode,
+      threadType: thread.type,
       mode: dispatchMode,
       onboardingActive: false,
       linearInstalled: Boolean(linearInstallation),
@@ -192,9 +192,9 @@ class AgentExecutorService {
       orgId: organizationRef,
       userId: userRef,
       userName,
-      workstreamId: workstreamRef,
+      threadId: threadRef,
       orgIdString: params.context.organizationId,
-      workstreamMode: workstream.mode,
+      threadType: thread.type,
       mode: dispatchMode,
       linearInstalled: Boolean(linearInstallation),
       onboardingActive: false,
@@ -302,7 +302,6 @@ class AgentExecutorService {
         structuredOutput: finalResult.structuredOutput,
         artifacts: finalResult.artifacts,
         notes: 'Execution incomplete: missing required deliverables or validation failures.',
-        quality: 'partial',
       }
       nodeWorkspaceService.cleanup(workspace)
       return result
@@ -312,7 +311,6 @@ class AgentExecutorService {
       structuredOutput: finalResult.structuredOutput,
       artifacts: finalResult.artifacts,
       notes: finalResult.notes,
-      quality: finalResult.quality,
     }
 
     nodeWorkspaceService.cleanup(workspace)

package/src/services/attachment.service.ts

@@ -2,7 +2,7 @@ import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { attachmentStorageService } from '../storage/attachment-storage.service'
-import type { UploadedWorkstreamAttachment as SdkUploadedWorkstreamAttachment } from '../storage/attachment-storage.service'
+import type { UploadedThreadAttachment as SdkUploadedThreadAttachment } from '../storage/attachment-storage.service'
 import type { MessagePartLike, ReadableUploadMetadata as SdkReadableUploadMetadata } from '../storage/attachment-types'
 
 export type ReadableUploadMetadata = SdkReadableUploadMetadata
@@ -134,7 +134,7 @@ class AttachmentService {
     return attachmentStorageService.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
   }
 
-  async uploadWorkstreamAttachment({
+  async uploadThreadAttachment({
     file,
     orgId,
     userId,
@@ -142,12 +142,8 @@ class AttachmentService {
     file: File
     orgId: RecordIdRef
     userId: RecordIdRef
-  }): Promise<SdkUploadedWorkstreamAttachment> {
-    return attachmentStorageService.uploadWorkstreamAttachment({
-      file,
-      orgId: toOrgId(orgId),
-      userId: toUserId(userId),
-    })
+  }): Promise<SdkUploadedThreadAttachment> {
+    return attachmentStorageService.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) })
   }
 }
 

package/src/services/autonomous-job.service.ts

@@ -30,15 +30,15 @@ import type { RecordIdInput } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
 import type { AutonomousJobQueuePayload } from '../queues/autonomous-job.queue'
-import { extractMessageText } from '../runtime/workstream-chat-helpers'
+import { extractMessageText } from '../runtime/thread-chat-helpers'
 import { buildAutonomousAtJobId, encodeBullmqId } from '../utils/autonomous-job-ids'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 import { compactRecord, compactWhitespace, stringifyUnknown, truncateText } from '../utils/string'
 import { executionPlanService } from './execution-plan.service'
 import { getNotificationService } from './notification.service'
 import { queueJobService } from './queue-job.service'
-import { runWorkstreamTurnInBackground } from './workstream-turn'
-import { workstreamService } from './workstream.service'
+import { runThreadTurnInBackground } from './thread-turn'
+import { threadService } from './thread.service'
 
 const AUTONOMOUS_JOB_QUEUE_NAME = 'autonomous-job'
 
@@ -51,7 +51,7 @@ const AutonomousJobRowSchema = z.object({
   organizationId: recordIdSchema,
   ownerUserId: recordIdSchema,
   ownerUserName: z.string().optional(),
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   agentId: z.string(),
   title: z.string(),
   prompt: z.string(),
@@ -72,7 +72,7 @@ const AutonomousJobRowSchema = z.object({
 const AutonomousJobRunRowSchema = z.object({
   id: recordIdSchema,
   autonomousJobId: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   queueJobId: recordIdSchema.optional(),
   status: AutonomousJobRunStatusSchema,
   inputMessageId: z.string().optional(),
@@ -111,7 +111,7 @@ class AutonomousJobService {
       organizationId: recordIdToString(row.organizationId, TABLES.ORGANIZATION),
       ownerUserId: recordIdToString(row.ownerUserId, TABLES.USER),
       ownerUserName: row.ownerUserName,
-      workstreamId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
+      threadId: recordIdToString(row.threadId, TABLES.THREAD),
       agentId: row.agentId,
       title: row.title,
       prompt: row.prompt,
@@ -134,7 +134,7 @@ class AutonomousJobService {
     return AutonomousJobRunSchema.parse({
       id: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB_RUN),
       autonomousJobId: recordIdToString(row.autonomousJobId, TABLES.AUTONOMOUS_JOB),
-      workstreamId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
+      threadId: recordIdToString(row.threadId, TABLES.THREAD),
       queueJobId: row.queueJobId ? recordIdToString(row.queueJobId, TABLES.QUEUE_JOB) : undefined,
       status: row.status,
       inputMessageId: row.inputMessageId,
@@ -175,7 +175,7 @@ class AutonomousJobService {
     kind: 'notify',
     params: {
       organizationId: string
-      workstreamId: string
+      threadId: string
       title: string
       body: string
       severity: 'info' | 'warning'
@@ -204,7 +204,7 @@ class AutonomousJobService {
 
   private async createRunRow(params: {
     autonomousJobId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     queueJobId?: RecordIdInput
     status?: AutonomousJobRunStatus
   }): Promise<AutonomousJobRunRow> {
@@ -214,7 +214,7 @@ class AutonomousJobService {
       runId,
       compactRecord({
         autonomousJobId: ensureRecordId(params.autonomousJobId, TABLES.AUTONOMOUS_JOB),
-        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
         queueJobId: params.queueJobId ? ensureRecordId(params.queueJobId, TABLES.QUEUE_JOB) : undefined,
         status: params.status ?? 'queued',
         assistantMessageIds: [],
@@ -293,8 +293,8 @@ class AutonomousJobService {
     if (row.schedule.kind === 'at') {
       const queuedRun = options.reusePendingAtRun
         ? ((await this.findRecoverableRunRow(row.id)) ??
-          (await this.createRunRow({ autonomousJobId: row.id, workstreamId: row.workstreamId })))
-        : await this.createRunRow({ autonomousJobId: row.id, workstreamId: row.workstreamId })
+          (await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })))
+        : await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })
       const { enqueueAutonomousJobRun } = await import('../queues/autonomous-job.queue')
       const enqueueResult = await enqueueAutonomousJobRun({
         payload: {
@@ -334,10 +334,11 @@ class AutonomousJobService {
     const parsed = CreateAutonomousJobInputSchema.parse(input)
     const organizationId = ensureRecordId(parsed.organizationId, TABLES.ORGANIZATION)
     const ownerUserId = ensureRecordId(parsed.ownerUserId, TABLES.USER)
-    const workstream = await workstreamService.createWorkstream(ownerUserId, organizationId, {
-      mode: 'group',
-      core: false,
-      title: parsed.workstreamTitle ?? parsed.title,
+    const thread = await threadService.createThread({
+      userId: ownerUserId,
+      organizationId,
+      type: 'group',
+      title: parsed.threadTitle ?? parsed.title,
     })
     const jobId = new RecordId(TABLES.AUTONOMOUS_JOB, Bun.randomUUIDv7())
     const nextRunAt = this.computeNextRunAt(parsed.schedule)
@@ -348,7 +349,7 @@ class AutonomousJobService {
         organizationId,
         ownerUserId,
         ownerUserName: parsed.ownerUserName,
-        workstreamId: ensureRecordId(workstream.id, TABLES.WORKSTREAM),
+        threadId: ensureRecordId(thread.id, TABLES.THREAD),
         agentId: parsed.agentId,
         title: parsed.title,
         prompt: parsed.prompt,
@@ -409,7 +410,7 @@ class AutonomousJobService {
     await this.unscheduleRow(existing)
 
     if (parsed.title && compactWhitespace(parsed.title) !== compactWhitespace(existing.title)) {
-      await workstreamService.updateTitle(existing.workstreamId, parsed.title)
+      await threadService.updateTitle(existing.threadId, parsed.title)
     }
 
     const nextRunAt = this.computeNextRunAt(parsed.schedule ?? existing.schedule)
@@ -465,7 +466,7 @@ class AutonomousJobService {
 
   async runNow(jobId: RecordIdInput): Promise<AutonomousJobRun> {
     const row = await this.getRow(jobId)
-    const queuedRun = await this.createRunRow({ autonomousJobId: row.id, workstreamId: row.workstreamId })
+    const queuedRun = await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })
     const { enqueueAutonomousJobRun } = await import('../queues/autonomous-job.queue')
     const enqueueResult = await enqueueAutonomousJobRun({
       payload: {
@@ -501,7 +502,7 @@ class AutonomousJobService {
   async delete(jobId: RecordIdInput): Promise<AutonomousJob> {
     const row = await this.getRow(jobId)
     const cancelled = await this.cancel(row.id)
-    await workstreamService.updateStatus(row.workstreamId, 'archived')
+    await threadService.updateStatus(row.threadId, 'archived')
     return cancelled
   }
 
@@ -526,7 +527,7 @@ class AutonomousJobService {
         ? await this.getRunRow(job.data.autonomousJobRunId)
         : await this.createRunRow({
             autonomousJobId: autonomousJobRow.id,
-            workstreamId: autonomousJobRow.workstreamId,
+            threadId: autonomousJobRow.threadId,
             queueJobId,
             status: 'queued',
           })
@@ -546,18 +547,18 @@ class AutonomousJobService {
       )) ?? runRow
 
     try {
-      const workstream = await workstreamService.getWorkstream(autonomousJobRow.workstreamId)
+      const thread = await threadService.getThread(autonomousJobRow.threadId)
       const inputMessage = this.buildSyntheticUserMessage(autonomousJobRow.prompt)
-      const turnResult = await runWorkstreamTurnInBackground({
-        workstream,
-        workstreamRef: ensureRecordId(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+      const turnResult = await runThreadTurnInBackground({
+        thread,
+        threadRef: ensureRecordId(autonomousJobRow.threadId, TABLES.THREAD),
         orgRef: ensureRecordId(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
         userRef: ensureRecordId(autonomousJobRow.ownerUserId, TABLES.USER),
         userName: autonomousJobRow.ownerUserName,
         agentIdOverride: autonomousJobRow.agentId,
         inputMessage,
       })
-      const activePlan = await executionPlanService.getActivePlanForWorkstream(autonomousJobRow.workstreamId)
+      const activePlan = await executionPlanService.getActivePlanForThread(autonomousJobRow.threadId)
       const runStatus: AutonomousJobRunStatus = activePlan?.status === 'awaiting-human' ? 'awaiting-human' : 'completed'
       const summary = truncateText(
         turnResult.assistantMessages
@@ -611,7 +612,7 @@ class AutonomousJobService {
 
       await this.maybeNotify('notify', {
         organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
-        workstreamId: recordIdToString(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+        threadId: recordIdToString(autonomousJobRow.threadId, TABLES.THREAD),
         severity: 'info',
         title: `${autonomousJobRow.title} completed`,
         body: summary,
@@ -664,7 +665,7 @@ class AutonomousJobService {
 
       await this.maybeNotify('notify', {
         organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
-        workstreamId: recordIdToString(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+        threadId: recordIdToString(autonomousJobRow.threadId, TABLES.THREAD),
         severity: 'warning',
         title: autoPause
           ? `${autonomousJobRow.title} paused after repeated failures`

package/src/services/context-compaction.service.ts

@@ -7,13 +7,13 @@ import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { getRedisConnection } from '../redis/connection-accessor'
 import { withRedisLeaseLock } from '../redis/redis-lease-lock'
-import { CONTEXT_WINDOW_TOKENS, WORKSTREAM_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
+import { CONTEXT_WINDOW_TOKENS, THREAD_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
 import { contextCompactionRuntime, compactMemoryBlockSummary } from './context-compaction-runtime.singleton'
-import { workstreamMessageService } from './workstream-message.service'
-import { WorkstreamSchema } from './workstream.types'
+import { threadMessageService } from './thread-message.service'
+import { ThreadSchema } from './thread.types'
 
 interface PersistedCompactionMetrics {
-  domain: 'workstream'
+  domain: 'thread'
   entityId: string
   inputChars: number
   outputChars: number
@@ -37,11 +37,8 @@ class ContextCompactionService {
     return contextCompactionRuntime.shouldCompactHistory(params)
   }
 
-  async compactWorkstreamHistory(params: {
-    workstreamId: RecordIdRef
-    contextSize?: number
-  }): Promise<{ compacted: boolean }> {
-    const entityId = recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
+  async compactThreadHistory(params: { threadId: RecordIdRef; contextSize?: number }): Promise<{ compacted: boolean }> {
+    const entityId = recordIdToString(params.threadId, TABLES.THREAD)
 
     return withRedisLeaseLock(
       {
@@ -52,24 +49,20 @@ class ContextCompactionService {
         label: 'context-compaction',
       },
       async () => {
-        const workstream = await databaseService.findOne(
-          TABLES.WORKSTREAM,
-          { id: params.workstreamId },
-          WorkstreamSchema,
-        )
-        if (!workstream) {
-          throw new Error(`Workstream not found for compaction: ${entityId}`)
+        const thread = await databaseService.findOne(TABLES.THREAD, { id: params.threadId }, ThreadSchema)
+        if (!thread) {
+          throw new Error(`Thread not found for compaction: ${entityId}`)
         }
 
-        const liveMessages = await workstreamMessageService.listMessagesAfterCursor(
-          params.workstreamId,
-          typeof workstream.lastCompactedMessageId === 'string' ? workstream.lastCompactedMessageId : undefined,
+        const liveMessages = await threadMessageService.listMessagesAfterCursor(
+          params.threadId,
+          typeof thread.lastCompactedMessageId === 'string' ? thread.lastCompactedMessageId : undefined,
         )
 
         const result = await contextCompactionRuntime.compactHistory({
-          summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
+          summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
           liveMessages,
-          tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
+          tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
           contextSize: params.contextSize,
         })
 
@@ -78,21 +71,18 @@ class ContextCompactionService {
         }
 
         if (result.compactedMessages.length > 0) {
-          await workstreamMessageService.upsertMessages({
-            workstreamId: params.workstreamId,
-            messages: result.compactedMessages,
-          })
+          await threadMessageService.upsertMessages({ threadId: params.threadId, messages: result.compactedMessages })
         }
 
         await databaseService.update(
-          TABLES.WORKSTREAM,
-          params.workstreamId,
+          TABLES.THREAD,
+          params.threadId,
           { compactionSummary: result.summaryText, lastCompactedMessageId: result.lastCompactedMessageId },
-          WorkstreamSchema,
+          ThreadSchema,
         )
 
         this.logCompactionMetrics({
-          domain: 'workstream',
+          domain: 'thread',
           entityId,
           inputChars: result.inputChars,
           outputChars: result.outputChars,