@lota-sdk/core 0.2.2 → 0.3.0

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: [],

package/src/services/global-orchestrator.service.ts

@@ -55,7 +55,7 @@ class GlobalOrchestratorService {
     return 'skip'
   }
 
-  async routeGraphFull(params: { workstreamId: string; runId: string }): Promise<void> {
+  async routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
     const MAX_ROUNDS = 32
     const STRUCTURAL_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
 
@@ -105,7 +105,7 @@ class GlobalOrchestratorService {
           if (!ns || ns.owner.executorType !== 'agent') continue
           await enqueuePlanAgentHeartbeatWake({
             organizationId: recordIdToString(updatedRunForWake.organizationId, TABLES.ORGANIZATION),
-            workstreamId: recordIdToString(updatedRunForWake.workstreamId, TABLES.WORKSTREAM),
+            threadId: recordIdToString(updatedRunForWake.threadId, TABLES.THREAD),
             runId: recordIdToString(updatedRunForWake.id, TABLES.PLAN_RUN),
             nodeId: nodeRun.nodeId,
             agentId: ns.owner.ref,
@@ -140,7 +140,7 @@ class GlobalOrchestratorService {
         }),
       )
 
-      const workstreamId = recordIdToString(updatedRun.workstreamId, TABLES.WORKSTREAM)
+      const threadId = recordIdToString(updatedRun.threadId, TABLES.THREAD)
       const runId = recordIdToString(updatedRun.id, TABLES.PLAN_RUN)
 
       // Submit results sequentially (each triggers syncRunGraph internally)
@@ -151,7 +151,7 @@ class GlobalOrchestratorService {
 
         if (settled.status === 'fulfilled') {
           await planExecutorService.submitNodeResult({
-            workstreamId,
+            threadId,
             runId,
             nodeId: settled.value.nodeId,
             emittedBy: settled.value.ownerRef,
@@ -160,7 +160,7 @@ class GlobalOrchestratorService {
         } else {
           serverLogger.warn`routeGraphFull: dispatch failed for node "${nodeRun.nodeId}": ${settled.reason}`
           await planExecutorService.blockNodeOnDispatchFailure({
-            workstreamId,
+            threadId,
             runId,
             nodeId: nodeRun.nodeId,
             emittedBy: nodeSpecRecord?.owner.ref ?? 'unknown',

package/src/services/index.ts

@@ -35,10 +35,10 @@ export * from './skill-resolver.service'
 export * from './social-chat-history.service'
 export * from './system-executor.service'
 export * from './user.service'
-export * from './workstream-message.service'
-export * from './workstream.types'
-export * from './workstream-title.service'
-export * from './workstream-turn'
-export * from './workstream-plan-registry.service'
-export * from './workstream.service'
+export * from './thread-message.service'
+export * from './thread.types'
+export * from './thread-title.service'
+export * from './thread-turn'
+export * from './thread-plan-registry.service'
+export * from './thread.service'
 export * from './write-intent-validator.service'

package/src/services/memory.service.ts

@@ -209,7 +209,7 @@ class MemoryService {
       MAX_CONVERSATION_MEMORY_BLOCK_CHARS,
     )
     if (normalizedMemoryBlock) {
-      messages.push({ role: 'user', content: `Workstream memory block:\n${normalizedMemoryBlock}` })
+      messages.push({ role: 'user', content: `Thread memory block:\n${normalizedMemoryBlock}` })
     }
 
     const normalizedAttachmentContext = this.normalizeConversationText(

package/src/services/monitoring-window.service.ts

@@ -20,11 +20,11 @@ class MonitoringWindowService {
     nodeId: string
     config: MonitoringWindowConfig
     organizationId: string
-    workstreamId: string
+    threadId: string
   }): Promise<void> {
     await planSchedulerService.createSchedule({
       organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       runId: params.runId,
       nodeId: params.nodeId,
       scheduleSpec: {

package/src/services/mutating-approval.service.ts

@@ -1,13 +1,13 @@
 import type { RecordIdRef } from '../db/record-id'
 import { ensureRecordId } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { extractMessageText } from '../runtime/workstream-chat-helpers'
-import { workstreamMessageService } from './workstream-message.service'
+import { extractMessageText } from '../runtime/thread-chat-helpers'
+import { threadMessageService } from './thread-message.service'
 
 const APPROVAL_VERIFICATION_MESSAGE_WINDOW = 20
 
 type VerifyMutatingApproval = (params: {
-  workstreamId: string
+  threadId: string
   approvalReason: string
   approvalToken: string
   approvalMessageId?: string
@@ -58,8 +58,8 @@ function messageContainsExactApproval(messageText: string, approvalToken: string
   return extracted.token === approvalToken && extracted.reason === approvalReason
 }
 
-async function verifyMutatingApprovalForWorkstream(
-  workstreamId: RecordIdRef,
+async function verifyMutatingApprovalForThread(
+  threadId: RecordIdRef,
   params: { approvalReason: string; approvalToken: string; approvalMessageId?: string },
 ): Promise<{ ok: true } | { ok: false; reason: string }> {
   const token = extractQuotedValue(params.approvalToken)
@@ -72,10 +72,7 @@ async function verifyMutatingApprovalForWorkstream(
     return { ok: false, reason: 'approvalMessageId cannot be empty when provided.' }
   }
 
-  const recentMessages = await workstreamMessageService.listRecentMessages(
-    workstreamId,
-    APPROVAL_VERIFICATION_MESSAGE_WINDOW,
-  )
+  const recentMessages = await threadMessageService.listRecentMessages(threadId, APPROVAL_VERIFICATION_MESSAGE_WINDOW)
   const userMessages = recentMessages.filter((message) => message.role === 'user')
   if (userMessages.length === 0) {
     return { ok: false, reason: 'No user message history available to verify mutating approval.' }
@@ -106,5 +103,5 @@ async function verifyMutatingApprovalForWorkstream(
 }
 
 export const verifyMutatingApproval: VerifyMutatingApproval = async (params) => {
-  return verifyMutatingApprovalForWorkstream(ensureRecordId(params.workstreamId, TABLES.WORKSTREAM), params)
+  return verifyMutatingApprovalForThread(ensureRecordId(params.threadId, TABLES.THREAD), params)
 }

package/src/services/node-workspace.service.ts

@@ -1,5 +1,4 @@
 import type {
-  NodeResultQuality,
   PlanArtifactSubmission,
   PlanNodeResult,
   PlanNodeSpec,
@@ -86,7 +85,7 @@ class NodeWorkspaceService {
     })
   }
 
-  finalize(workspace: NodeWorkspace): PlanNodeResult & { isComplete: boolean; quality: NodeResultQuality } {
+  finalize(workspace: NodeWorkspace): PlanNodeResult & { isComplete: boolean } {
     const artifacts: PlanArtifactSubmission[] = []
     let structuredOutput: Record<string, unknown> | undefined
     let allValidated = true
@@ -125,8 +124,6 @@ class NodeWorkspaceService {
       artifacts.push({
         name: spec.name,
         kind: spec.kind,
-        pointer: `workspace://${workspace.nodeId}/${targetPath}`,
-        schemaRef: spec.schemaRef,
         description: spec.description,
         payload:
           typeof entry.payload === 'string'
@@ -138,10 +135,14 @@ class NodeWorkspaceService {
     }
 
     const allRequiredPresent = requiredNames.size === presentRequired.size
-    const quality: NodeResultQuality = allRequiredPresent && allValidated ? 'full' : 'partial'
-    const isComplete = quality === 'full'
+    const isComplete = allRequiredPresent && allValidated
 
-    return { structuredOutput, artifacts, quality, isComplete }
+    return {
+      notes: isComplete ? 'All deliverables completed.' : 'Partial deliverables completed.',
+      structuredOutput,
+      artifacts,
+      isComplete,
+    }
   }
 
   cleanup(workspace: NodeWorkspace): void {

package/src/services/notification.service.ts

@@ -2,7 +2,7 @@ import type { NotificationSeverity } from '@lota-sdk/shared'
 
 export interface NotificationPayload {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId?: string
   nodeId?: string
   severity: NotificationSeverity

package/src/services/organization.service.ts

@@ -11,8 +11,8 @@ import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-
 const organizationRecordSchema = z.object({
   id: recordIdSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.coerce.date().optional(),
-  regularChatDigestLastWorkstreamCursorId: z.string().optional(),
+  regularChatDigestLastThreadCursorCreatedAt: z.coerce.date().optional(),
+  regularChatDigestLastThreadCursorId: z.string().optional(),
   skillExtractionLastCursorId: z.string().optional(),
   skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
   createdAt: z.coerce.date(),
@@ -22,8 +22,8 @@ const organizationRecordSchema = z.object({
 const sdkOrganizationSchema = z.object({
   id: recordIdStringSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  regularChatDigestLastWorkstreamCursorId: z.string().nullable().optional(),
+  regularChatDigestLastThreadCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  regularChatDigestLastThreadCursorId: z.string().nullable().optional(),
   skillExtractionLastCursorId: z.string().nullable().optional(),
   skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
   createdAt: z.iso.datetime(),
@@ -51,10 +51,10 @@ class OrganizationService extends BaseService<typeof organizationRecordSchema> {
     return sdkOrganizationSchema.parse({
       id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
       name: record.name,
-      regularChatDigestLastWorkstreamCursorCreatedAt: toOptionalCursorTimestamp(
-        record.regularChatDigestLastWorkstreamCursorCreatedAt,
+      regularChatDigestLastThreadCursorCreatedAt: toOptionalCursorTimestamp(
+        record.regularChatDigestLastThreadCursorCreatedAt,
       ),
-      regularChatDigestLastWorkstreamCursorId: record.regularChatDigestLastWorkstreamCursorId ?? null,
+      regularChatDigestLastThreadCursorId: record.regularChatDigestLastThreadCursorId ?? null,
       skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
       skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
       createdAt: toIsoDateTimeString(record.createdAt),
@@ -101,8 +101,8 @@ class OrganizationService extends BaseService<typeof organizationRecordSchema> {
 
   async updateRegularChatDigestCursor(organizationId: RecordIdRef, cursor: BackgroundCursor): Promise<void> {
     await this.update(organizationId, {
-      regularChatDigestLastWorkstreamCursorCreatedAt: cursor.createdAt,
-      regularChatDigestLastWorkstreamCursorId: cursor.id,
+      regularChatDigestLastThreadCursorCreatedAt: cursor.createdAt,
+      regularChatDigestLastThreadCursorId: cursor.id,
     })
   }