@lota-sdk/core 0.2.3 → 0.3.1

package/src/runtime/social-chat.ts

@@ -48,7 +48,7 @@ import {
   extractMessageText,
   toHistoryMessages,
   toOptionalTrimmedString,
-} from './workstream-chat-helpers'
+} from './thread-chat-helpers'
 
 const DEFAULT_SOCIAL_CHAT_AGENT_ID = 'socialChat'
 const DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME = 'Lota'
@@ -362,8 +362,8 @@ export function createSocialChatRuntime(params: {
 
             return await runSocialAgentTurn({
               agentId,
-              mode: 'fixedWorkstreamMode',
-              workstreamMode: 'group',
+              mode: 'fixedThreadMode',
+              threadType: 'group',
               onboardingActive: lifecycleState?.bootstrapActive ?? false,
               linearInstalled: false,
               systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
@@ -407,8 +407,8 @@ export function createSocialChatRuntime(params: {
     aiLogger.info`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
     const leadRun = await runSocialAgentTurn({
       agentId: socialAgentId,
-      mode: 'workstreamMode',
-      workstreamMode: 'group',
+      mode: 'threadMode',
+      threadType: 'group',
       onboardingActive: lifecycleState?.bootstrapActive ?? false,
       linearInstalled: false,
       systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
@@ -453,7 +453,7 @@ export function createSocialChatRuntime(params: {
           enqueuePostChatMemory(
             {
               orgId: workspaceIdString,
-              workstreamId: `social:slack:${messageContext.threadId}`,
+              threadId: `social:slack:${messageContext.threadId}`,
               sourceId: createSocialChatCursorId({
                 workspaceId: workspaceIdString,
                 threadId: messageContext.threadId,

package/src/runtime/team-consultation-orchestrator.ts

@@ -8,7 +8,7 @@ import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataT
 import type { ReadableUploadMetadataLike } from './chat-attachments'
 import type { RepoSectionName } from './indexed-repositories-policy'
 import { buildTeamConsultationFailureMessage } from './team-consultation-prompts'
-import { extractMessageText } from './workstream-chat-helpers'
+import { extractMessageText } from './thread-chat-helpers'
 
 export type DefaultRepoSections = RepoSectionName[]
 const TEAM_CONSULTATION_TIMEOUT_MS = 90_000

package/src/runtime/{workstream-chat-helpers.ts → thread-chat-helpers.ts}

@@ -1,7 +1,7 @@
 import { agentDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
 import type { ChatMessageLike, ReadableUploadMetadataLike } from './chat-types'
 
-export interface WorkstreamHistoryMessage {
+export interface ThreadHistoryMessage {
   role: 'user' | 'agent'
   content: string
   agentName?: string
@@ -42,9 +42,9 @@ export function extractMessageText(message: ChatMessageLike): string {
     .trim()
 }
 
-export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): WorkstreamHistoryMessage[] {
+export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): ThreadHistoryMessage[] {
   return messages
-    .map((message): WorkstreamHistoryMessage | null => {
+    .map((message): ThreadHistoryMessage | null => {
       const content = extractMessageText(message)
       if (!content) return null
 
@@ -57,7 +57,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): W
       }
       return null
     })
-    .filter((message): message is WorkstreamHistoryMessage => message !== null)
+    .filter((message): message is ThreadHistoryMessage => message !== null)
     .slice(-maxItems)
 }
 
@@ -86,10 +86,10 @@ export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }
 
-export function appendPersistedWorkstreamContextToHistoryMessages(
-  historyMessages: WorkstreamHistoryMessage[],
+export function appendPersistedThreadContextToHistoryMessages(
+  historyMessages: ThreadHistoryMessage[],
   params: { compactionSummary?: string | null },
-): WorkstreamHistoryMessage[] {
+): ThreadHistoryMessage[] {
   const nextHistoryMessages = [...historyMessages]
   const compactionSummary = typeof params.compactionSummary === 'string' ? params.compactionSummary.trim() : ''
   if (compactionSummary) {

package/src/runtime/{workstream-plan-turn.ts → thread-plan-turn.ts}

@@ -1,11 +1,5 @@
 import { SUBMIT_PLAN_TURN_RESULT_TOOL_NAME, withMessageCreatedAt } from '@lota-sdk/shared'
-import type {
-  ChatMessage,
-  PlanArtifactSubmission,
-  PlanNodeHandoffContext,
-  PlanNodeRunRecord,
-  PlanNodeSpecRecord,
-} from '@lota-sdk/shared'
+import type { ChatMessage, PlanArtifactSubmission, PlanNodeRunRecord, PlanNodeSpecRecord } from '@lota-sdk/shared'
 
 import { buildCompletionCheckStructuredOutputHints } from './agent-runtime-policy'
 import { mergeInstructionSections } from './instruction-sections'
@@ -15,10 +9,10 @@ export interface PlanTurnUpstreamHandoff {
   label: string
   ownerRef: string
   ownerType: PlanNodeSpecRecord['owner']['executorType']
-  handoffContext: PlanNodeHandoffContext
+  summary?: string
 }
 
-export interface WorkstreamPlanTurnContext {
+export interface ThreadPlanTurnContext {
   runId: string
   nodeId: string
   planTitle: string
@@ -29,7 +23,7 @@ export interface WorkstreamPlanTurnContext {
   upstreamHandoffs: PlanTurnUpstreamHandoff[]
 }
 
-function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): string {
+function buildPlanTurnExecutionSection(planTurn: ThreadPlanTurnContext): string {
   const requiredDeliverables = planTurn.nodeSpec.deliverables.filter((deliverable) => deliverable.required)
   const completionCheckOutputHints = buildCompletionCheckStructuredOutputHints(planTurn.nodeSpec)
   const payload = {
@@ -55,11 +49,11 @@ function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): str
   return [
     '<plan-turn-execution>',
     `Complete node "${planTurn.nodeSpec.label}" for plan "${planTurn.planTitle}".`,
-    'Use only the node contract, resolved input, input artifacts, and upstream handoff context.',
+    'Use only the node contract, resolved input, input artifacts, and upstream summaries.',
     'Before submitting, satisfy every required deliverable, success criterion, and completion check.',
     `Call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once when done.`,
     `Required artifacts: ${requiredDeliverables.length > 0 ? requiredDeliverables.map((d) => d.name).join(', ') : 'none'}.`,
-    'Include notes with a concise completion summary. Include handoffContext with summary, key decisions, open questions, risks, and recommendations for downstream nodes.',
+    'notes is required. Include a concise summary of what was done, key decisions, and any context downstream nodes need.',
     ...(completionCheckOutputHints.length > 0
       ? ['Structured output fields required by completion checks:', ...completionCheckOutputHints]
       : []),
@@ -81,7 +75,7 @@ function buildUpstreamHandoffSection(upstreamHandoffs: PlanTurnUpstreamHandoff[]
         label: handoff.label,
         ownerRef: handoff.ownerRef,
         ownerType: handoff.ownerType,
-        handoffContext: handoff.handoffContext,
+        ...(handoff.summary ? { summary: handoff.summary } : {}),
       })),
       null,
       2,
@@ -90,7 +84,7 @@ function buildUpstreamHandoffSection(upstreamHandoffs: PlanTurnUpstreamHandoff[]
   ].join('\n')
 }
 
-export function buildPlanTurnInstructionSections(planTurn: WorkstreamPlanTurnContext): string[] {
+export function buildPlanTurnInstructionSections(planTurn: ThreadPlanTurnContext): string[] {
   const upstreamHandoffSection = buildUpstreamHandoffSection(planTurn.upstreamHandoffs)
   return (
     mergeInstructionSections(
@@ -100,7 +94,7 @@ export function buildPlanTurnInstructionSections(planTurn: WorkstreamPlanTurnCon
   )
 }
 
-export function buildPlanTurnSubmitToolDescription(planTurn: WorkstreamPlanTurnContext): string {
+export function buildPlanTurnSubmitToolDescription(planTurn: ThreadPlanTurnContext): string {
   const requiredArtifacts =
     planTurn.nodeSpec.deliverables
       .filter((deliverable) => deliverable.required)
@@ -114,11 +108,11 @@ export function buildPlanTurnSubmitToolDescription(planTurn: WorkstreamPlanTurnC
     `Structured output: ${
       planTurn.nodeSpec.outputSchemaRef ? `must satisfy ${planTurn.nodeSpec.outputSchemaRef}` : 'optional'
     }.`,
-    'Do not submit partial results. Include durable handoffContext for downstream nodes.',
+    'Do not submit partial results. notes is required — include a concise summary for downstream nodes.',
   ].join(' ')
 }
 
-export function buildPlanTurnPromptMessage(planTurn: WorkstreamPlanTurnContext): ChatMessage {
+export function buildPlanTurnPromptMessage(planTurn: ThreadPlanTurnContext): ChatMessage {
   return withMessageCreatedAt(
     {
       id: Bun.randomUUIDv7(),

package/src/runtime/{workstream-turn-context.ts → thread-turn-context.ts}

@@ -8,13 +8,13 @@ import type {
   LotaRuntimeWorkspaceProjectionState,
   LotaRuntimeWorkspaceProvider,
 } from './runtime-extensions'
-import { asRecord, readInstructionSections, readOptionalString } from './workstream-chat-helpers'
+import { asRecord, readInstructionSections, readOptionalString } from './thread-chat-helpers'
 
 function readOptionalBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined
 }
 
-interface AssembledWorkstreamTurnContext {
+interface AssembledThreadTurnContext {
   workspace: Record<string, unknown>
   workspaceLifecycleState: LotaRuntimeWorkspaceLifecycleState | undefined
   workspaceProfileState: LotaRuntimeWorkspaceProjectionState | undefined
@@ -28,9 +28,9 @@ interface AssembledWorkstreamTurnContext {
   hookInstructionSections: string[]
 }
 
-export async function assembleWorkstreamTurnContext(params: {
-  workstream: unknown
-  workstreamRef: RecordIdRef
+export async function assembleThreadTurnContext(params: {
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -41,7 +41,7 @@ export async function assembleWorkstreamTurnContext(params: {
   workspaceProvider?: LotaRuntimeWorkspaceProvider
   turnHooks: LotaRuntimeTurnHooks
   onStep?: (name: string) => void
-}): Promise<AssembledWorkstreamTurnContext> {
+}): Promise<AssembledThreadTurnContext> {
   const workspace = await params.workspacePromise
   params.onStep?.('fetch-workspace')
 
@@ -104,8 +104,8 @@ export async function assembleWorkstreamTurnContext(params: {
 
   const buildContextResult = asRecord(
     await params.turnHooks.buildContext?.({
-      workstream: params.workstream,
-      workstreamRef: params.workstreamRef,
+      thread: params.thread,
+      threadRef: params.threadRef,
       orgRef: params.orgRef,
       userRef: params.userRef,
       userName: params.userName,
@@ -144,8 +144,8 @@ export async function assembleWorkstreamTurnContext(params: {
 
   const hookInstructionSections = readInstructionSections(
     await params.turnHooks.buildExtraInstructionSections?.({
-      workstream: params.workstream,
-      workstreamRef: params.workstreamRef,
+      thread: params.thread,
+      threadRef: params.threadRef,
       orgRef: params.orgRef,
       userRef: params.userRef,
       userName: params.userName,

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) })
   }
 }