@lota-sdk/core 0.2.2 → 0.3.0

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,

package/src/services/plan-event-delivery.service.ts

@@ -9,8 +9,8 @@ import { resolvePlanNodeExecutionVisibility } from '../runtime/execution-plan-vi
 import { getRuntimeAdapters } from '../runtime/runtime-extensions'
 import type { LotaRuntimePlanEventEnvelope } from '../runtime/runtime-extensions'
 import { planRunService } from './plan-run.service'
+import { ThreadSchema } from './thread.types'
 import { userService } from './user.service'
-import { WorkstreamSchema } from './workstream.types'
 
 const PLAN_EVENT_DELIVERED_TTL_MS = 7 * 24 * 60 * 60 * 1000
 
@@ -41,24 +41,20 @@ class PlanEventDeliveryService {
   private async deliverEvent(rawEvent: PlanEventRecord): Promise<void> {
     const event = PlanEventSchema.parse(rawEvent)
     const run = await planRunService.getRunById(event.runId)
-    const [spec, nodeSpecs, nodeRuns, workstream] = await Promise.all([
+    const [spec, nodeSpecs, nodeRuns, thread] = await Promise.all([
       planRunService.getPlanSpecById(run.planSpecId),
       planRunService.listNodeSpecs(run.planSpecId),
       planRunService.listNodeRuns(run.id),
-      databaseService.findOne(
-        TABLES.WORKSTREAM,
-        { id: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM) },
-        WorkstreamSchema,
-      ),
+      databaseService.findOne(TABLES.THREAD, { id: ensureRecordId(run.threadId, TABLES.THREAD) }, ThreadSchema),
     ])
     const nodeSpecsById = new Map(nodeSpecs.map((nodeSpec) => [nodeSpec.nodeId, nodeSpec]))
     const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
     const organizationId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
-    const workstreamId = recordIdToString(run.workstreamId, TABLES.WORKSTREAM)
+    const threadId = recordIdToString(run.threadId, TABLES.THREAD)
     const runIdString = recordIdToString(run.id, TABLES.PLAN_RUN)
     const planSpecId = recordIdToString(spec.id, TABLES.PLAN_SPEC)
-    const userId = workstream?.userId
-      ? recordIdToString(ensureRecordId(workstream.userId, TABLES.USER), TABLES.USER)
+    const userId = thread?.userId
+      ? recordIdToString(ensureRecordId(thread.userId, TABLES.USER), TABLES.USER)
       : undefined
     const userName =
       userId === undefined
@@ -75,7 +71,7 @@ class PlanEventDeliveryService {
       ...(event.nodeId ? { nodeSpec: nodeSpecsById.get(event.nodeId) } : {}),
       ...(event.nodeId ? { nodeRun: nodeRunsById.get(event.nodeId) } : {}),
       organizationId,
-      workstreamId,
+      threadId,
       runId: runIdString,
       planSpecId,
       ...(userId ? { userId } : {}),
@@ -123,7 +119,7 @@ class PlanEventDeliveryService {
     const { enqueuePlanAgentHeartbeatWake } = await import('../queues/plan-agent-heartbeat.queue')
     await enqueuePlanAgentHeartbeatWake({
       organizationId: envelope.organizationId,
-      workstreamId: envelope.workstreamId,
+      threadId: envelope.threadId,
       runId: envelope.runId,
       nodeId: wakeTarget.nodeId,
       agentId: wakeTarget.agentId,

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

@@ -92,20 +92,15 @@ function parseLiteralValue(raw: string): unknown {
   }
 }
 
-function buildArtifactContext(
-  artifacts: Array<{ name: string; kind: string; pointer: string; schemaRef?: string; payload?: unknown }>,
-) {
+function buildArtifactContext(artifacts: Array<{ name: string; kind: string; payload?: unknown }>) {
   return Object.fromEntries(
-    artifacts.map((artifact) => [
-      artifact.name,
-      { kind: artifact.kind, pointer: artifact.pointer, schemaRef: artifact.schemaRef, payload: artifact.payload },
-    ]),
+    artifacts.map((artifact) => [artifact.name, { kind: artifact.kind, payload: artifact.payload }]),
   )
 }
 
 function buildNodeContext(params: {
   nodeRun: PlanNodeRunRecord | undefined
-  artifacts: Array<{ name: string; kind: string; pointer: string; schemaRef?: string; payload?: unknown }>
+  artifacts: Array<{ name: string; kind: string; payload?: unknown }>
 }) {
   return {
     input: params.nodeRun?.resolvedInput ?? {},
@@ -159,7 +154,6 @@ type PlanNodeRunUpdate = Omit<
   | 'resolvedInput'
   | 'latestStructuredOutput'
   | 'latestNotes'
-  | 'handoffContext'
   | 'latestAttemptId'
   | 'scheduledAt'
   | 'readyAt'
@@ -171,7 +165,6 @@ type PlanNodeRunUpdate = Omit<
   resolvedInput?: Record<string, unknown> | null
   latestStructuredOutput?: Record<string, unknown> | null
   latestNotes?: string | null
-  handoffContext?: Record<string, unknown> | null
   latestAttemptId?: RecordIdInput | null
   scheduledAt?: string | Date | null
   readyAt?: string | Date | null
@@ -208,13 +201,6 @@ function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
         : nodeRun.latestNotes
           ? { latestNotes: nodeRun.latestNotes }
           : {}),
-    ...(patch.handoffContext === null
-      ? {}
-      : patch.handoffContext !== undefined
-        ? { handoffContext: patch.handoffContext }
-        : nodeRun.handoffContext
-          ? { handoffContext: nodeRun.handoffContext }
-          : {}),
     ...(patch.latestAttemptId === null
       ? {}
       : patch.latestAttemptId !== undefined
@@ -280,17 +266,15 @@ function deriveApprovalStatus(response: Record<string, unknown>): 'approved' | '
 
 class PlanExecutorService {
   async submitNodeResult(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     runId: string
     nodeId: string
     emittedBy: string
     result: PlanNodeResultSubmission
   }): Promise<ExecutionPlanToolResultData> {
     const run = await planRunService.getRunById(params.runId)
-    if (
-      recordIdToString(run.workstreamId, TABLES.WORKSTREAM) !== recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
-    ) {
-      throw new Error('Execution node result targets a different workstream.')
+    if (recordIdToString(run.threadId, TABLES.THREAD) !== recordIdToString(params.threadId, TABLES.THREAD)) {
+      throw new Error('Execution node result targets a different thread.')
     }
     if (run.status === 'completed' || run.status === 'failed' || run.status === 'aborted') {
       throw new Error('Execution run is no longer active.')
@@ -375,8 +359,7 @@ class PlanExecutorService {
               attemptCount: nodeRun.attemptCount + 1,
               latestAttemptId: finalizedAttempt.id,
               latestStructuredOutput: params.result.structuredOutput ?? null,
-              latestNotes: params.result.notes ?? null,
-              handoffContext: params.result.handoffContext ?? null,
+              latestNotes: params.result.notes,
             }),
           )
           .output('after'),
@@ -659,8 +642,7 @@ class PlanExecutorService {
               status: validation.warnings.length > 0 ? 'partial' : 'completed',
               latestAttemptId: finalizedAttempt.id,
               latestStructuredOutput: params.result.structuredOutput ?? null,
-              latestNotes: params.result.notes ?? null,
-              handoffContext: params.result.handoffContext ?? null,
+              latestNotes: params.result.notes,
               blockedReason: null,
               failureClass: null,
               completedAt: new Date(),
@@ -751,18 +733,17 @@ class PlanExecutorService {
       action: 'node-result-submitted',
       plan: snapshot,
       message: `Submitted result for node "${nodeSpec.label}".`,
-      changedNodeId: params.nodeId,
     })
   }
 
   async submitHumanNodeResponse(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     approvalId?: string
     respondedBy: 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 || run.status !== 'awaiting-human' || !run.waitingNodeId) {
       return null
     }
@@ -790,7 +771,7 @@ class PlanExecutorService {
       result: {
         structuredOutput: params.response,
         artifacts: [],
-        notes: typeof params.response.comments === 'string' ? params.response.comments : undefined,
+        notes: typeof params.response.comments === 'string' ? params.response.comments : 'Human response submitted.',
       },
     })
     const emittedEvents: PlanEventRecord[] = []
@@ -818,7 +799,7 @@ class PlanExecutorService {
         result: {
           structuredOutput: params.response,
           artifacts: [],
-          notes: typeof params.response.comments === 'string' ? params.response.comments : undefined,
+          notes: typeof params.response.comments === 'string' ? params.response.comments : 'Human response submitted.',
         },
         status: validation.blocking.length > 0 ? 'failed' : 'completed',
         failureClass: validation.failureClass,
@@ -860,7 +841,6 @@ class PlanExecutorService {
                     latestAttemptId: attempt.id,
                     latestStructuredOutput: params.response,
                     latestNotes: typeof params.response.comments === 'string' ? params.response.comments : null,
-                    handoffContext: null,
                     blockedReason: validation.blocking[0]?.message ?? null,
                     failureClass: validation.failureClass,
                   }),
@@ -877,7 +857,6 @@ class PlanExecutorService {
                     latestAttemptId: attempt.id,
                     latestStructuredOutput: params.response,
                     latestNotes: typeof params.response.comments === 'string' ? params.response.comments : null,
-                    handoffContext: null,
                     blockedReason: null,
                     failureClass: null,
                     completedAt: new Date(),
@@ -981,7 +960,7 @@ class PlanExecutorService {
   }
 
   async resumeRun(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     runId: string
     emittedBy: string
   }): Promise<ExecutionPlanToolResultData> {
@@ -1106,7 +1085,7 @@ class PlanExecutorService {
   }
 
   async blockNodeOnDispatchFailure(params: {
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     runId: string
     nodeId: string
     emittedBy: string
@@ -1297,7 +1276,7 @@ class PlanExecutorService {
     if (params.spec.dependencies && params.spec.dependencies.length > 0) {
       const { unresolved } = await planCoordinationService.resolveDependencies({
         dependencies: params.spec.dependencies,
-        workstreamId: recordIdToString(params.spec.workstreamId, TABLES.WORKSTREAM),
+        threadId: recordIdToString(params.spec.threadId, TABLES.THREAD),
       })
       if (unresolved.length > 0) {
         currentRun = await this.replaceRun(params.tx, currentRun, { status: 'blocked', readyNodeIds: [] })
@@ -1405,7 +1384,7 @@ class PlanExecutorService {
           replaceNodeRun(scheduledNodeRun)
           await planSchedulerService.createSchedule({
             organizationId: currentRun.organizationId,
-            workstreamId: currentRun.workstreamId,
+            threadId: currentRun.threadId,
             planSpecId: params.spec.id,
             runId: currentRun.id,
             nodeId: nodeSpec.nodeId,