@lota-sdk/core 0.2.3 → 0.3.1

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,

package/src/services/execution-plan.service.ts

@@ -1,7 +1,7 @@
 import type {
   ChatMessage,
+  ExecutionPlanQueryArgs,
   ExecutionPlanToolResultData,
-  GetActiveExecutionPlanArgs,
   ListExecutionPlansSummary,
   ListExecutionPlansToolResultData,
   PlanEventRecord,
@@ -9,7 +9,6 @@ import type {
   PlanNodeRunRecord,
   PlanNodeSpecRecord,
   PlanSpecRecord,
-  ResumeExecutionPlanRunArgs,
   SerializableExecutionPlan,
   SubmitPlanTurnResultArgs,
   SubmitExecutionNodeResultArgs,
@@ -30,7 +29,7 @@ import { databaseService } from '../db/service'
 import type { DatabaseTransaction } from '../db/service'
 import { TABLES } from '../db/tables'
 import { readApprovalContinuationResponse } from '../runtime/approval-continuation'
-import { extractMessageText } from '../runtime/workstream-chat-helpers'
+import { extractMessageText } from '../runtime/thread-chat-helpers'
 import { toDatabaseDateTime } from '../utils/date-time'
 import { ownershipDispatcherService } from './ownership-dispatcher.service'
 import { planBuilderService } from './plan-builder.service'
@@ -50,7 +49,7 @@ function aggregateBlockingIssues(issues: Array<{ code: string; message: string }
 function toSpecData(spec: PlanSpecRecord, patch: Partial<PlanSpecRecord> & { replacedSpecId?: RecordIdInput | null }) {
   return {
     organizationId: ensureRecordId(spec.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(spec.workstreamId, TABLES.WORKSTREAM),
+    threadId: ensureRecordId(spec.threadId, TABLES.THREAD),
     title: patch.title ?? spec.title,
     objective: patch.objective ?? spec.objective,
     version: patch.version ?? spec.version,
@@ -105,7 +104,7 @@ function buildApprovalResponseFromMessages(
 
 function buildCompiledSpecCreateData(params: {
   organizationId: RecordIdInput
-  workstreamId: RecordIdInput
+  threadId: RecordIdInput
   leadAgentId: string
   compiled: ReturnType<typeof planCompilerService.compile>
   version: number
@@ -114,7 +113,7 @@ function buildCompiledSpecCreateData(params: {
 }) {
   return {
     organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+    threadId: ensureRecordId(params.threadId, TABLES.THREAD),
     title: params.compiled.draft.title,
     objective: params.compiled.draft.objective,
     version: params.version,
@@ -136,21 +135,21 @@ function buildCompiledSpecCreateData(params: {
 }
 
 class ExecutionPlanService {
-  async hasActivePlan(workstreamId: RecordIdInput): Promise<boolean> {
-    return (await planRunService.getActiveRunRecord(workstreamId)) !== null
+  async hasActivePlan(threadId: RecordIdInput): Promise<boolean> {
+    return (await planRunService.getActiveRunRecord(threadId)) !== null
   }
 
-  async getActivePlanForWorkstream(
-    workstreamId: RecordIdInput,
-    options?: Partial<GetActiveExecutionPlanArgs> & { runId?: RecordIdInput },
+  async getActivePlanForThread(
+    threadId: RecordIdInput,
+    options?: Partial<ExecutionPlanQueryArgs> & { runId?: RecordIdInput },
   ): Promise<SerializableExecutionPlan | null> {
-    const plans = await this.getActivePlansForWorkstream(workstreamId, options)
+    const plans = await this.getActivePlansForThread(threadId, options)
     return plans[0] ?? null
   }
 
-  async getActivePlansForWorkstream(
-    workstreamId: RecordIdInput,
-    options?: Partial<GetActiveExecutionPlanArgs> & { runId?: RecordIdInput },
+  async getActivePlansForThread(
+    threadId: RecordIdInput,
+    options?: Partial<ExecutionPlanQueryArgs> & { runId?: RecordIdInput },
   ): Promise<SerializableExecutionPlan[]> {
     if (options?.runId) {
       const run = await planRunService.getRunById(options.runId)
@@ -165,7 +164,7 @@ class ExecutionPlanService {
       ]
     }
 
-    const runs = await planRunService.getActiveRunRecords(workstreamId)
+    const runs = await planRunService.getActiveRunRecords(threadId)
     if (runs.length === 0) return []
 
     return await Promise.all(
@@ -181,8 +180,8 @@ class ExecutionPlanService {
     )
   }
 
-  async listActivePlanSummaries(workstreamId: RecordIdInput): Promise<ListExecutionPlansToolResultData> {
-    const runs = await planRunService.getActiveRunRecords(workstreamId)
+  async listActivePlanSummaries(threadId: RecordIdInput): Promise<ListExecutionPlansToolResultData> {
+    const runs = await planRunService.getActiveRunRecords(threadId)
     const plans: ListExecutionPlansSummary[] = await Promise.all(
       runs.map(async (run) => {
         const spec = await planRunService.getPlanSpecById(run.planSpecId)
@@ -202,7 +201,7 @@ class ExecutionPlanService {
   }
 
   async getActivePlanToolResult(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     runId?: string
     includeEvents?: boolean
     includeArtifacts?: boolean
@@ -225,36 +224,26 @@ class ExecutionPlanService {
       return buildExecutionPlanToolResult({ action: 'loaded', plan, message: `Loaded execution run "${plan.title}".` })
     }
 
-    const runs = await planRunService.getActiveRunRecords(params.workstreamId)
+    const runs = await planRunService.getActiveRunRecords(params.threadId)
     if (runs.length === 0) {
       return buildExecutionPlanToolResult({ action: 'none', plan: null, message: 'No active execution run.' })
     }
 
     const plan = await planRunService.toSerializablePlan(runs[0], serializeOptions)
-    const planSummaries = await Promise.all(
-      runs.map(async (run) => {
-        const spec = await planRunService.getPlanSpecById(run.planSpecId)
-        return { runId: recordIdToString(run.id, TABLES.PLAN_RUN), title: spec.title, status: run.status }
-      }),
-    )
 
-    return {
-      ...buildExecutionPlanToolResult({
-        action: 'loaded',
-        plan,
-        message:
-          runs.length === 1
-            ? `Loaded execution run "${plan.title}".`
-            : `Loaded ${runs.length} active execution runs. Showing most recent: "${plan.title}".`,
-      }),
-      planCount: runs.length,
-      planSummaries,
-    }
+    return buildExecutionPlanToolResult({
+      action: 'loaded',
+      plan,
+      message:
+        runs.length === 1
+          ? `Loaded execution run "${plan.title}".`
+          : `Loaded ${runs.length} active execution runs. Showing most recent: "${plan.title}".`,
+    })
   }
 
   async createPlan(params: {
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     leadAgentId: string
     input: PlanDraft
   }): Promise<ExecutionPlanToolResultData> {
@@ -277,7 +266,7 @@ class ExecutionPlanService {
           .content(
             buildCompiledSpecCreateData({
               organizationId: params.organizationId,
-              workstreamId: params.workstreamId,
+              threadId: params.threadId,
               leadAgentId: params.leadAgentId,
               compiled,
               version: 1,
@@ -290,7 +279,7 @@ class ExecutionPlanService {
         runId,
         spec,
         organizationId: params.organizationId,
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         leadAgentId: params.leadAgentId,
         nodes: compiled.nodes,
         emittedEvents,
@@ -307,7 +296,7 @@ class ExecutionPlanService {
     if (compiled.draft.schedule) {
       const schedule = await planSchedulerService.createSchedule({
         organizationId: params.organizationId,
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         planSpecId: specId,
         runId,
         scheduleSpec: compiled.draft.schedule,
@@ -330,17 +319,17 @@ class ExecutionPlanService {
   }
 
   async replacePlan(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     organizationId: RecordIdInput
     leadAgentId: string
     input: PlanDraft & { runId: string; reason: string }
   }): Promise<ExecutionPlanToolResultData> {
     const activeRun = await planRunService.getRunById(params.input.runId)
-    const resolvedWorkstreamId = activeRun.workstreamId
+    const resolvedThreadId = activeRun.threadId
 
-    const activeRuns = await planRunService.getActiveRunRecords(resolvedWorkstreamId)
+    const activeRuns = await planRunService.getActiveRunRecords(resolvedThreadId)
     if (activeRuns.length === 0) {
-      throw new Error('No active execution run exists for this workstream.')
+      throw new Error('No active execution run exists for this thread.')
     }
     if (!activeRuns.some((run) => recordIdToString(run.id, TABLES.PLAN_RUN) === params.input.runId)) {
       throw new Error('Only an active execution run can be replaced.')
@@ -399,7 +388,7 @@ class ExecutionPlanService {
           .content(
             buildCompiledSpecCreateData({
               organizationId: params.organizationId,
-              workstreamId: resolvedWorkstreamId,
+              threadId: resolvedThreadId,
               leadAgentId: params.leadAgentId,
               compiled,
               version: supersededSpec.version + 1,
@@ -413,7 +402,7 @@ class ExecutionPlanService {
         runId,
         spec,
         organizationId: params.organizationId,
-        workstreamId: resolvedWorkstreamId,
+        threadId: resolvedThreadId,
         leadAgentId: params.leadAgentId,
         nodes: compiled.nodes,
         emittedEvents,
@@ -440,28 +429,29 @@ class ExecutionPlanService {
   }
 
   async submitNodeResult(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     emittedBy: string
     input: SubmitExecutionNodeResultArgs
   }): Promise<ExecutionPlanToolResultData> {
+    const { runId, nodeId, ...result } = params.input
     return await this.submitPlanTurnResult({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       emittedBy: params.emittedBy,
-      runId: params.input.runId,
-      nodeId: params.input.nodeId,
-      input: params.input.result,
+      runId,
+      nodeId,
+      input: result,
     })
   }
 
   async submitPlanTurnResult(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     runId: string
     nodeId: string
     emittedBy: string
     input: SubmitPlanTurnResultArgs
   }): Promise<ExecutionPlanToolResultData> {
     const result = await planExecutorService.submitNodeResult({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       runId: params.runId,
       nodeId: params.nodeId,
       emittedBy: params.emittedBy,
@@ -476,17 +466,16 @@ class ExecutionPlanService {
       action: result.action,
       plan,
       message: result.message ?? `Submitted result for node "${params.nodeId}".`,
-      changedNodeId: result.changedNodeId ?? undefined,
     })
   }
 
   async resumeRun(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     emittedBy: string
-    input: ResumeExecutionPlanRunArgs
+    input: { runId: string }
   }): Promise<ExecutionPlanToolResultData> {
     const result = await planExecutorService.resumeRun({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       runId: params.input.runId,
       emittedBy: params.emittedBy,
     })
@@ -499,12 +488,11 @@ class ExecutionPlanService {
       action: result.action,
       plan,
       message: result.message ?? `Resumed execution run "${params.input.runId}".`,
-      changedNodeId: result.changedNodeId ?? undefined,
     })
   }
 
   async applyApprovalResponseFromMessages(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     approvalMessages: ChatMessage[]
     respondedBy: string
   }): Promise<SerializableExecutionPlan | null> {
@@ -512,22 +500,22 @@ class ExecutionPlanService {
     if (!approvalResponse) return null
 
     return await this.respondToApproval({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       emittedBy: params.respondedBy,
       input: approvalResponse,
     })
   }
 
   async respondToApproval(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     emittedBy: string
     input: { approvalId: string; response: Record<string, unknown>; approvalMessageId?: string }
   }): Promise<SerializableExecutionPlan | null> {
-    const run = await planRunService.getActiveRunRecord(params.workstreamId)
+    const run = await planRunService.getActiveRunRecord(params.threadId)
     if (!run) return null
 
     const plan = await planExecutorService.submitHumanNodeResponse({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       approvalId: params.input.approvalId,
       respondedBy: params.emittedBy,
       response: params.input.response,
@@ -539,11 +527,11 @@ class ExecutionPlanService {
   }
 
   async applyHumanInputFromUserMessage(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     message: ChatMessage
     respondedBy: string
   }): Promise<SerializableExecutionPlan | null> {
-    const run = await planRunService.getActiveRunRecord(params.workstreamId)
+    const run = await planRunService.getActiveRunRecord(params.threadId)
     if (!run || run.status !== 'awaiting-human' || !run.waitingNodeId) return null
 
     const nodeSpec = await planRunService.getNodeSpecByNodeId(run.planSpecId, run.waitingNodeId)
@@ -565,7 +553,7 @@ class ExecutionPlanService {
     } satisfies Record<string, unknown>
 
     const plan = await planExecutorService.submitHumanNodeResponse({
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       respondedBy: params.respondedBy,
       response,
       approvalMessageId: params.message.id,
@@ -677,7 +665,7 @@ class ExecutionPlanService {
     runId: RecordIdInput
     spec: PlanSpecRecord
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     leadAgentId: string
     nodes: CompiledPlanNode[]
     emittedEvents: PlanEventRecord[]
@@ -694,7 +682,7 @@ class ExecutionPlanService {
         .content({
           planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
           organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-          workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
           leadAgentId: params.leadAgentId,
           status: 'running',
           readyNodeIds: [],