@lota-sdk/core 0.2.3 → 0.3.1

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

package/src/services/ownership-dispatcher.service.ts

@@ -31,8 +31,8 @@ import type { PlanValidationIssueInput } from './plan-validator.service'
 import { pluginExecutorService } from './plugin-executor.service'
 import { skillResolverService } from './skill-resolver.service'
 import { systemExecutorService } from './system-executor.service'
+import { ThreadSchema } from './thread.types'
 import { userService } from './user.service'
-import { WorkstreamSchema } from './workstream.types'
 
 const STABLE_RUN_STATUSES = new Set(['awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
 const MAX_DISPATCH_ITERATIONS = 64
@@ -73,8 +73,6 @@ function toArtifactSubmission(artifact: PlanArtifactRecord): PlanArtifactSubmiss
   return {
     name: artifact.name,
     kind: artifact.kind,
-    pointer: artifact.pointer,
-    ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
     ...(artifact.description ? { description: artifact.description } : {}),
     ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
   }
@@ -157,7 +155,7 @@ class OwnershipDispatcherService {
       if (spec.executionMode === 'graph-full') {
         const { globalOrchestratorService } = await import('./global-orchestrator.service')
         await globalOrchestratorService.routeGraphFull({
-          workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+          threadId: recordIdToString(run.threadId, TABLES.THREAD),
           runId: recordIdToString(run.id, TABLES.PLAN_RUN),
         })
         return this.serializeRun(run.id)
@@ -200,7 +198,7 @@ class OwnershipDispatcherService {
         })
 
         await planExecutorService.submitNodeResult({
-          workstreamId: run.workstreamId,
+          threadId: run.threadId,
           runId: recordIdToString(run.id, TABLES.PLAN_RUN),
           nodeId: planNode.id,
           emittedBy: planNode.owner.ref,
@@ -208,7 +206,7 @@ class OwnershipDispatcherService {
         })
       } catch (error) {
         await planExecutorService.blockNodeOnDispatchFailure({
-          workstreamId: run.workstreamId,
+          threadId: run.threadId,
           runId: recordIdToString(run.id, TABLES.PLAN_RUN),
           nodeId: planNode.id,
           emittedBy: planNode.owner.ref,
@@ -283,18 +281,14 @@ class OwnershipDispatcherService {
     nodeSpecRecord: PlanNodeSpecRecord,
   ): Promise<Omit<OwnershipDispatchContext, 'nodeId'>> {
     const organizationId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
-    const workstreamId = recordIdToString(run.workstreamId, TABLES.WORKSTREAM)
+    const threadId = recordIdToString(run.threadId, TABLES.THREAD)
     const planId = recordIdToString(run.id, TABLES.PLAN_RUN)
-    const [workstream, nodeSpecs, nodeRuns] = await Promise.all([
-      databaseService.findOne(
-        TABLES.WORKSTREAM,
-        { id: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM) },
-        WorkstreamSchema,
-      ),
+    const [thread, nodeSpecs, nodeRuns] = await Promise.all([
+      databaseService.findOne(TABLES.THREAD, { id: ensureRecordId(run.threadId, TABLES.THREAD) }, ThreadSchema),
       planRunService.listNodeSpecs(spec.id),
       planRunService.listNodeRuns(run.id),
     ])
-    const userId = workstream?.userId ? recordIdToString(workstream.userId, TABLES.USER) : undefined
+    const userId = thread?.userId ? recordIdToString(thread.userId, TABLES.USER) : undefined
     const userName = userId
       ? await userService
           .getUser(userId)
@@ -304,8 +298,7 @@ class OwnershipDispatcherService {
     const nodeSpecsById = new Map(nodeSpecs.map((candidate) => [candidate.nodeId, candidate]))
     const upstreamHandoffs: UpstreamHandoff[] = nodeRuns
       .filter(
-        (candidate): candidate is typeof candidate & { handoffContext: NonNullable<typeof candidate.handoffContext> } =>
-          nodeSpecRecord.upstreamNodeIds.includes(candidate.nodeId) && candidate.handoffContext !== undefined,
+        (candidate) => nodeSpecRecord.upstreamNodeIds.includes(candidate.nodeId) && candidate.latestNotes !== undefined,
       )
       .map((candidate) => {
         const upstreamNodeSpec = nodeSpecsById.get(candidate.nodeId)
@@ -314,13 +307,13 @@ class OwnershipDispatcherService {
           label: upstreamNodeSpec?.label ?? candidate.nodeId,
           ownerRef: upstreamNodeSpec?.owner.ref ?? 'unknown',
           ownerType: upstreamNodeSpec?.owner.executorType ?? 'system',
-          handoffContext: candidate.handoffContext,
+          summary: candidate.latestNotes ?? undefined,
         }
       })
 
     return {
       organizationId,
-      workstreamId,
+      threadId,
       planId,
       leadAgentId: run.leadAgentId,
       ...(userId ? { userId } : {}),
@@ -355,9 +348,10 @@ class OwnershipDispatcherService {
         nodeId: params.nodeSpec.id,
         config: params.nodeSpec.monitoringConfig,
         organizationId: params.context.organizationId,
-        workstreamId: params.context.workstreamId,
+        threadId: params.context.threadId,
       })
       return {
+        notes: `Monitoring window started for node "${params.nodeSpec.label}".`,
         structuredOutput: { status: 'monitoring-started', config: params.nodeSpec.monitoringConfig },
         artifacts: [],
       }

package/src/services/plan-agent-heartbeat.service.ts

@@ -6,7 +6,7 @@ import { resolvePlanNodeExecutionVisibility } from '../runtime/execution-plan-vi
 import { planAgentQueryService } from './plan-agent-query.service'
 import { planExecutorService } from './plan-executor.service'
 import { planRunService } from './plan-run.service'
-import { workstreamService } from './workstream.service'
+import { threadService } from './thread.service'
 
 const PLAN_AGENT_HEARTBEAT_LOCK_TTL_MS = 300_000
 const PLAN_AGENT_HEARTBEAT_LOCK_REFRESH_MS = 20_000
@@ -17,26 +17,26 @@ function buildHeartbeatLockKey(runId: string, nodeId: string): string {
 
 function buildWakeDedupeKey(params: {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
 }) {
-  return `${params.organizationId}:${params.workstreamId}:${params.runId}:${params.nodeId}:${params.agentId}`
+  return `${params.organizationId}:${params.threadId}:${params.runId}:${params.nodeId}:${params.agentId}`
 }
 
 class PlanAgentHeartbeatService {
   async wakeNode(params: {
     organizationId: string
-    workstreamId: string
+    threadId: string
     runId: string
     nodeId: string
     agentId: string
     reason: string
   }): Promise<boolean> {
-    const workstreamRef = ensureRecordId(params.workstreamId, TABLES.WORKSTREAM)
-    await workstreamService.clearStaleActiveRunIfMissingFromRegistry(workstreamRef)
-    if (await workstreamService.getActiveRunId(workstreamRef)) {
+    const threadRef = ensureRecordId(params.threadId, TABLES.THREAD)
+    await threadService.clearStaleActiveRunIfMissingFromRegistry(threadRef)
+    if (await threadService.getActiveRunId(threadRef)) {
       return false
     }
 
@@ -51,11 +51,11 @@ class PlanAgentHeartbeatService {
         logger: serverLogger,
       },
       async () => {
-        await workstreamService.clearStaleActiveRunIfMissingFromRegistry(workstreamRef)
-        if (await workstreamService.hasActiveRunLease(workstreamRef)) {
+        await threadService.clearStaleActiveRunIfMissingFromRegistry(threadRef)
+        if (await threadService.hasActiveRunLease(threadRef)) {
           return false
         }
-        if (await workstreamService.getActiveRunId(workstreamRef)) {
+        if (await threadService.getActiveRunId(threadRef)) {
           return false
         }
 
@@ -83,7 +83,7 @@ class PlanAgentHeartbeatService {
           await planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId })
         }
 
-        const { triggerPlanNodeTurn } = await import('./workstream-turn')
+        const { triggerPlanNodeTurn } = await import('./thread-turn')
 
         await triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId })
         return true
@@ -101,7 +101,7 @@ class PlanAgentHeartbeatService {
 
     const wakeTargets = new Map<
       string,
-      { organizationId: string; workstreamId: string; runId: string; nodeId: string; agentId: string; reason: string }
+      { organizationId: string; threadId: string; runId: string; nodeId: string; agentId: string; reason: string }
     >()
 
     for (const node of actionable) {
@@ -118,7 +118,7 @@ class PlanAgentHeartbeatService {
       }
       const wakeTarget = {
         organizationId: node.organizationId,
-        workstreamId: node.workstreamId,
+        threadId: node.threadId,
         runId: node.runId,
         nodeId: node.nodeId,
         agentId: node.agentId,

package/src/services/plan-agent-query.service.ts

@@ -15,7 +15,7 @@ const DEADLINE_TRACKED_NODE_STATUSES = new Set(['ready', 'running', 'awaiting-hu
 
 export interface ActionablePlanAgentNode {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -25,7 +25,7 @@ export interface ActionablePlanAgentNode {
 
 export interface ApproachingDeadlineNode {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId?: string
@@ -37,7 +37,7 @@ export interface ApproachingDeadlineNode {
 
 export interface RecentlyUnblockedNode {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -89,7 +89,7 @@ class PlanAgentQueryService {
           if (params.agentId && params.agentId !== visibleTarget.agentId) continue
           actionable.push({
             organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-            workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+            threadId: recordIdToString(run.threadId, TABLES.THREAD),
             runId: recordIdToString(run.id, TABLES.PLAN_RUN),
             nodeId: nodeSpec.nodeId,
             agentId: visibleTarget.agentId,
@@ -124,7 +124,7 @@ class PlanAgentQueryService {
 
       actionable.push({
         organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-        workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+        threadId: recordIdToString(run.threadId, TABLES.THREAD),
         runId: recordIdToString(run.id, TABLES.PLAN_RUN),
         nodeId: nodeSpec.nodeId,
         agentId: visibleTarget.agentId,
@@ -176,7 +176,7 @@ class PlanAgentQueryService {
         const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
         matches.push({
           organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-          workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+          threadId: recordIdToString(run.threadId, TABLES.THREAD),
           runId: recordIdToString(run.id, TABLES.PLAN_RUN),
           nodeId: nodeSpec.nodeId,
           ...(visibleTarget ? { agentId: visibleTarget.agentId, visibility: visibleTarget.visibility } : {}),
@@ -232,7 +232,7 @@ class PlanAgentQueryService {
 
         matches.push({
           organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-          workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+          threadId: recordIdToString(run.threadId, TABLES.THREAD),
           runId: recordIdToString(run.id, TABLES.PLAN_RUN),
           nodeId: currentNodeId,
           agentId: visibleTarget.agentId,

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

@@ -28,8 +28,7 @@ class PlanArtifactService {
           nodeId: params.nodeId,
           name: artifact.name,
           kind: artifact.kind,
-          pointer: artifact.pointer,
-          ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
+          pointer: `artifact://${params.nodeId}/${artifact.name}`,
           ...(artifact.description ? { description: artifact.description } : {}),
           ...(artifact.payload ? { payload: artifact.payload } : {}),
         })

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

@@ -13,7 +13,7 @@ class PlanCoordinationService {
   /**
    * Resolve cross-plan artifact dependencies.
    * For each dependency:
-   *   1. Find the source plan by title in the workstream
+   *   1. Find the source plan by title in the thread
    *   2. Find the artifact by (nodeId, artifactName) in that plan's run
    *   3. Check staleness if maxStalenessMs set
    *   4. Based on triggerMode:
@@ -23,7 +23,7 @@ class PlanCoordinationService {
    */
   async resolveDependencies(params: {
     dependencies: PlanDependency[]
-    workstreamId: string
+    threadId: string
   }): Promise<DependencyResolutionResult> {
     const { planRunService } = await import('./plan-run.service')
 
@@ -34,10 +34,10 @@ class PlanCoordinationService {
     for (const dep of params.dependencies) {
       const depKey = `${dep.sourcePlanTitle}:${dep.sourceNodeId}:${dep.artifactName}`
 
-      const specs = await planRunService.listPlanSpecsByWorkstream(params.workstreamId)
+      const specs = await planRunService.listPlanSpecsByThread(params.threadId)
       const sourceSpec = specs.find((s) => s.title === dep.sourcePlanTitle)
       if (!sourceSpec) {
-        const reason = `Source plan "${dep.sourcePlanTitle}" not found in workstream.`
+        const reason = `Source plan "${dep.sourcePlanTitle}" not found in thread.`
         if (dep.triggerMode === 'block') {
           unresolved.push(dep)
         } else if (dep.triggerMode === 'notify') {

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

@@ -64,7 +64,7 @@ class PlanCycleService {
 
   async createCycle(params: {
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     templateId: RecordIdInput
     name: string
     schedule: CycleSchedule
@@ -77,7 +77,7 @@ class PlanCycleService {
       TABLES.PLAN_CYCLE,
       {
         organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
         templateId: ensureRecordId(params.templateId, TABLES.PLAN_TEMPLATE),
         name: params.name,
         schedule: params.schedule,
@@ -92,7 +92,7 @@ class PlanCycleService {
     const createResult = await planTemplateService.instantiate({
       templateId: params.templateId,
       organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       leadAgentId: params.leadAgentId,
     })
 
@@ -101,7 +101,7 @@ class PlanCycleService {
     const scheduleSpec = cycleScheduleToSpec(params.schedule)
     const scheduleRecord = await planSchedulerService.createSchedule({
       organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       ...(createdRunId ? { runId: ensureRecordId(createdRunId, TABLES.PLAN_RUN) } : {}),
       scheduleSpec,
     })
@@ -160,7 +160,7 @@ class PlanCycleService {
     const result = await planTemplateService.instantiate({
       templateId: cycle.templateId,
       organizationId: cycle.organizationId,
-      workstreamId: cycle.workstreamId,
+      threadId: cycle.threadId,
       leadAgentId: 'system',
       overrides: draft,
     })
@@ -263,10 +263,10 @@ class PlanCycleService {
     )
   }
 
-  async listCycles(workstreamId: RecordIdInput): Promise<PlanCycleRecord[]> {
+  async listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_CYCLE,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanCycleRecordSchema,
       { orderBy: 'createdAt', orderDir: 'ASC' },
     )

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

@@ -126,7 +126,7 @@ class PlanDeadlineService {
         await this.applyDeadlineMissAction({
           runId: entry.nodeRun.runId,
           nodeId: entry.nodeRun.nodeId,
-          workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+          threadId: recordIdToString(run.threadId, TABLES.THREAD),
           organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
           action: deadline.missAction,
           emittedBy: 'plan-deadline-checker',
@@ -228,7 +228,7 @@ class PlanDeadlineService {
   async applyDeadlineMissAction(params: {
     runId: RecordIdInput
     nodeId: string
-    workstreamId: string
+    threadId: string
     organizationId: string
     action: DeadlineAction
     emittedBy: string
@@ -275,7 +275,7 @@ class PlanDeadlineService {
         })
         const { planExecutorService } = await import('./plan-executor.service')
         await planExecutorService.blockNodeOnDispatchFailure({
-          workstreamId: params.workstreamId,
+          threadId: params.threadId,
           runId: runIdStr,
           nodeId: params.nodeId,
           emittedBy: params.emittedBy,
@@ -296,7 +296,7 @@ class PlanDeadlineService {
         })
         const { planExecutorService } = await import('./plan-executor.service')
         await planExecutorService.blockNodeOnDispatchFailure({
-          workstreamId: params.workstreamId,
+          threadId: params.threadId,
           runId: runIdStr,
           nodeId: params.nodeId,
           emittedBy: params.emittedBy,