@lota-sdk/core 0.2.3 → 0.3.1

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

@@ -21,7 +21,7 @@ import {
   STRUCTURAL_NODE_TYPES as STRUCTURAL_NODE_TYPE_VALUES,
   PlanValidationIssueSchema,
 } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
+import { RecordId, StringRecordId } from 'surrealdb'
 
 import { aiLogger } from '../config/logger'
 import type { RecordIdInput } from '../db/record-id'
@@ -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,
@@ -1886,7 +1865,14 @@ class PlanExecutorService {
     run: PlanRunRecord,
     checkpoint: RecordIdInput | { id: RecordIdInput },
   ) {
-    const checkpointId = checkpoint && typeof checkpoint === 'object' && 'id' in checkpoint ? checkpoint.id : checkpoint
+    const checkpointId =
+      checkpoint &&
+      typeof checkpoint === 'object' &&
+      !(checkpoint instanceof RecordId) &&
+      !(checkpoint instanceof StringRecordId) &&
+      'id' in checkpoint
+        ? (checkpoint as { id: RecordIdInput }).id
+        : checkpoint
 
     await tx
       .update(ensureRecordId(run.id, TABLES.PLAN_RUN))

package/src/services/plan-run-data.ts

@@ -1,4 +1,4 @@
-import type { ExecutionPlanToolResultData, PlanRunRecord } from '@lota-sdk/shared'
+import type { ExecutionPlanToolResultData, PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId } from '../db/record-id'
@@ -21,7 +21,7 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
   return {
     planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
     organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
+    threadId: ensureRecordId(run.threadId, TABLES.THREAD),
     leadAgentId: patch.leadAgentId ?? run.leadAgentId,
     status: patch.status ?? run.status,
     ...(patch.currentNodeId === null
@@ -71,18 +71,37 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
   }
 }
 
+function toSlimPlanSummary(plan: SerializableExecutionPlan): NonNullable<ExecutionPlanToolResultData['plan']> {
+  const completed = plan.progress.completed + plan.progress.partial
+  return {
+    runId: plan.runId,
+    title: plan.title,
+    objective: plan.objective,
+    status: plan.status,
+    progress: { completed, total: plan.progress.total },
+    nodes: plan.nodes.map((node) => ({
+      id: node.id,
+      label: node.label,
+      type: node.type,
+      status: node.status,
+      ownerRef: node.owner.ref,
+    })),
+    activeNodeIds: plan.activeNodeIds,
+    readyNodeIds: plan.readyNodeIds,
+  }
+}
+
 export function buildExecutionPlanToolResult(params: {
   action: ExecutionPlanToolResultData['action']
-  plan: ExecutionPlanToolResultData['plan'] | null
+  plan: SerializableExecutionPlan | null
   message: string
-  changedNodeId?: string
 }): ExecutionPlanToolResultData {
+  const slim = params.plan ? toSlimPlanSummary(params.plan) : null
   return {
     action: params.action,
     message: params.message,
-    ...(params.changedNodeId ? { changedNodeId: params.changedNodeId } : {}),
-    ...(params.plan ? { plan: params.plan } : {}),
-    hasPlan: params.plan !== null,
-    status: params.plan?.status,
+    ...(slim ? { plan: slim } : {}),
+    hasPlan: slim !== null,
+    status: slim?.status,
   }
 }

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

@@ -168,10 +168,10 @@ class PlanRunService {
     return spec
   }
 
-  async listPlanSpecsByWorkstream(workstreamId: RecordIdInput): Promise<PlanSpecRecord[]> {
+  async listPlanSpecsByThread(threadId: RecordIdInput): Promise<PlanSpecRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_SPEC,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanSpecSchema,
       { orderBy: 'createdAt', orderDir: 'DESC' },
     )
@@ -219,15 +219,15 @@ class PlanRunService {
     return run
   }
 
-  async getActiveRunRecord(workstreamId: RecordIdInput): Promise<PlanRunRecord | null> {
-    const runs = await this.getActiveRunRecords(workstreamId)
+  async getActiveRunRecord(threadId: RecordIdInput): Promise<PlanRunRecord | null> {
+    const runs = await this.getActiveRunRecords(threadId)
     return runs[0] ?? null
   }
 
-  async getActiveRunRecords(workstreamId: RecordIdInput): Promise<PlanRunRecord[]> {
+  async getActiveRunRecords(threadId: RecordIdInput): Promise<PlanRunRecord[]> {
     const runs = await databaseService.findMany(
       TABLES.PLAN_RUN,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanRunSchema,
       { orderBy: 'updatedAt', orderDir: 'DESC' },
     )
@@ -379,7 +379,6 @@ class PlanRunService {
           status: nodeRun.status,
           upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
           downstreamNodeIds: [...nodeSpec.downstreamNodeIds],
-          ...(nodeRun.handoffContext ? { handoffContext: nodeRun.handoffContext } : {}),
           ...(nodeRun.completedAt ? { completedAt: toOptionalIsoDateTimeString(nodeRun.completedAt) } : {}),
         } as SerializablePlanNode
       }
@@ -418,7 +417,6 @@ class PlanRunService {
         resolvedInput: nodeRun.resolvedInput,
         latestStructuredOutput: nodeRun.latestStructuredOutput,
         latestNotes: nodeRun.latestNotes,
-        handoffContext: nodeRun.handoffContext,
         blockedReason: nodeRun.blockedReason,
         failureClass: nodeRun.failureClass,
         upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
@@ -432,7 +430,7 @@ class PlanRunService {
     return {
       specId: recordIdToString(spec.id, TABLES.PLAN_SPEC),
       runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-      workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+      threadId: recordIdToString(run.threadId, TABLES.THREAD),
       organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
       title: spec.title,
       objective: spec.objective,

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

@@ -41,7 +41,7 @@ class PlanSchedulerService {
 
   async createSchedule(params: {
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     planSpecId?: RecordIdInput
     runId?: RecordIdInput
     nodeId?: string
@@ -54,7 +54,7 @@ class PlanSchedulerService {
       TABLES.PLAN_SCHEDULE,
       {
         organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
         planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
         runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
         nodeId: params.nodeId,
@@ -227,10 +227,10 @@ class PlanSchedulerService {
     }
   }
 
-  async listSchedules(workstreamId: RecordIdInput): Promise<PlanScheduleRecord[]> {
+  async listSchedules(threadId: RecordIdInput): Promise<PlanScheduleRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_SCHEDULE,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanScheduleRecordSchema,
       { orderBy: 'createdAt', orderDir: 'ASC' },
     )

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

@@ -87,7 +87,7 @@ class PlanTemplateService {
   async instantiate(params: {
     templateId: RecordIdInput
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     leadAgentId: string
     overrides?: Partial<PlanDraft>
     carryForwardArtifacts?: PlanArtifactRecord[]
@@ -106,7 +106,7 @@ class PlanTemplateService {
 
     return executionPlanService.createPlan({
       organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       leadAgentId: params.leadAgentId,
       input: draft,
     })

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

@@ -582,16 +582,6 @@ class PlanValidatorService {
       }
 
       if (deliverable.schemaRef) {
-        if (artifact.schemaRef !== deliverable.schemaRef) {
-          blocking.push(
-            createIssue({
-              code: 'artifact_schema_mismatch',
-              message: `Artifact "${deliverable.name}" must declare schemaRef "${deliverable.schemaRef}".`,
-              nodeId: params.node.id,
-            }),
-          )
-        }
-
         const artifactSchema = resolveSchemaRef(params.draft, deliverable.schemaRef)
         if (!artifact.payload) {
           blocking.push(
@@ -658,7 +648,6 @@ class PlanValidatorService {
     if (check.type === 'schema') {
       const schemaRef =
         (typeof check.config.schemaRef === 'string' ? check.config.schemaRef : undefined) ??
-        artifact?.schemaRef ??
         (artifactName ? node.deliverables.find((candidate) => candidate.name === artifactName)?.schemaRef : undefined)
       if (!schemaRef) {
         return createIssue({

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

@@ -20,7 +20,7 @@ function buildPluginExecutionParams(params: {
     inputs: params.resolvedInput,
     context: {
       organizationId: params.context.organizationId,
-      workstreamId: params.context.workstreamId,
+      threadId: params.context.threadId,
       planId: params.context.planId,
       nodeId: params.context.nodeId,
       ...(params.context.userId ? { userId: params.context.userId } : {}),

package/src/services/queue-job.service.ts

@@ -141,7 +141,7 @@ function extractJobContext(data: unknown): Record<string, unknown> | undefined {
 
   const context = compactRecord({
     organizationId: readStringField(record, 'organizationId') ?? readStringField(record, 'orgId'),
-    workstreamId: readStringField(record, 'workstreamId'),
+    threadId: readStringField(record, 'threadId'),
     userId: readStringField(record, 'userId'),
     agentId: readStringField(record, 'agentId'),
     sourceId: readStringField(record, 'sourceId'),

package/src/services/recent-activity-title.service.ts

@@ -18,7 +18,7 @@ function buildRefinementPromptInput(
     `sourceLabel=${candidate.sourceLabel}`,
     `systemTitle=${candidate.systemTitle}`,
     metadata.agentName ? `agentName=${metadata.agentName}` : null,
-    metadata.workstreamTitle ? `workstreamTitle=${metadata.workstreamTitle}` : null,
+    metadata.threadTitle ? `threadTitle=${metadata.threadTitle}` : null,
     metadata.userMessageText ? `userMessage=${metadata.userMessageText}` : null,
     metadata.assistantSummary ? `assistantSummary=${metadata.assistantSummary}` : null,
   ].filter((line): line is string => Boolean(line))

package/src/services/recent-activity.service.ts

@@ -79,9 +79,9 @@ function shouldKeepExistingAgentTitle(existing: RecentActivityRow | null): boole
 function buildRecentActivityAreaKey(
   row: Pick<RecentActivityRow, 'targetKind' | 'targetId' | 'kind' | 'mergeKey' | 'metadata'>,
 ): string {
-  const workstreamId = row.metadata?.workstreamId
-  if (workstreamId) {
-    return `workstream:${compactWhitespace(workstreamId)}`
+  const threadId = row.metadata?.threadId
+  if (threadId) {
+    return `thread:${compactWhitespace(threadId)}`
   }
 
   if (row.targetId) {
@@ -373,7 +373,7 @@ class RecentActivityService {
       'chat',
       'agent task',
       'recent activity',
-      'workstream update',
+      'thread update',
     ])
 
     return !bannedTitles.has(normalizedCandidate)

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

@@ -8,7 +8,7 @@ const BUILT_IN_SYSTEM_EXECUTORS = Object.freeze({
   'plan-runtime': {
     supportedOperations: ['echo-input'],
     async executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult> {
-      return { structuredOutput: structuredClone(params.inputs), artifacts: [] }
+      return { notes: 'System echo-input completed.', structuredOutput: structuredClone(params.inputs), artifacts: [] }
     },
   } satisfies SystemNodeExecutor,
 })
@@ -36,7 +36,7 @@ function buildSystemExecutionParams(params: {
     inputs: params.resolvedInput,
     context: {
       organizationId: params.context.organizationId,
-      workstreamId: params.context.workstreamId,
+      threadId: params.context.threadId,
       planId: params.context.planId,
       nodeId: params.context.nodeId,
       ...(params.context.userId ? { userId: params.context.userId } : {}),