@lota-sdk/core 0.1.15 → 0.1.17

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

@@ -0,0 +1,172 @@
+import type { ImpactAnalysis, PlanNodeRunRecord, ProvenanceChain, ProvenanceNode } from '@lota-sdk/shared'
+
+import { recordIdToString } from '../db/record-id'
+
+class ArtifactProvenanceService {
+  /**
+   * Backward: trace which upstream nodes/artifacts produced the inputs for this artifact's node.
+   * From nodeId, follow edges upstream. At each upstream node, collect its artifacts.
+   * Continue until maxDepth or no more upstreams.
+   */
+  async traceBackward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const artifactsByNodeId = new Map<string, typeof artifacts>()
+    for (const artifact of artifacts) {
+      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
+      list.push(artifact)
+      artifactsByNodeId.set(artifact.nodeId, list)
+    }
+
+    const maxDepth = params.maxDepth ?? 10
+    const chain: ProvenanceNode[] = []
+    const visited = new Set<string>()
+    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
+
+    while (queue.length > 0) {
+      const entry = queue.shift()
+      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
+      visited.add(entry.nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
+      if (!nodeSpec) continue
+
+      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
+        name: a.name,
+        kind: a.kind,
+        id: recordIdToString(a.id),
+      }))
+
+      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
+
+      // Walk upstream
+      for (const upstreamId of nodeSpec.upstreamNodeIds) {
+        if (!visited.has(upstreamId)) {
+          queue.push({ nodeId: upstreamId, depth: entry.depth + 1 })
+        }
+      }
+    }
+
+    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
+  }
+
+  /**
+   * Forward: trace which downstream nodes consume this artifact's node output.
+   * Same as backward but follow edges downstream.
+   */
+  async traceForward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const artifactsByNodeId = new Map<string, typeof artifacts>()
+    for (const artifact of artifacts) {
+      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
+      list.push(artifact)
+      artifactsByNodeId.set(artifact.nodeId, list)
+    }
+
+    const maxDepth = params.maxDepth ?? 10
+    const chain: ProvenanceNode[] = []
+    const visited = new Set<string>()
+    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
+
+    while (queue.length > 0) {
+      const entry = queue.shift()
+      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
+      visited.add(entry.nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
+      if (!nodeSpec) continue
+
+      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
+        name: a.name,
+        kind: a.kind,
+        id: recordIdToString(a.id),
+      }))
+
+      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
+
+      // Walk downstream
+      for (const downstreamId of nodeSpec.downstreamNodeIds) {
+        if (!visited.has(downstreamId)) {
+          queue.push({ nodeId: downstreamId, depth: entry.depth + 1 })
+        }
+      }
+    }
+
+    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
+  }
+
+  /**
+   * Impact: which downstream nodes/artifacts would be affected.
+   * Forward traversal collecting all affected nodes and their artifacts.
+   * Includes non-completed nodes.
+   */
+  async analyzeImpact(params: { runId: string; nodeId: string }): Promise<ImpactAnalysis> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const nodeRuns = await planRunService.listNodeRuns(run.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const nodeRunsByNodeId = new Map(nodeRuns.map((n: PlanNodeRunRecord) => [n.nodeId, n]))
+
+    const affectedNodes: Array<{ nodeId: string; label: string; status: PlanNodeRunRecord['status'] }> = []
+    const affectedArtifacts: Array<{ name: string; nodeId: string }> = []
+
+    const visited = new Set<string>()
+    const queue: string[] = []
+
+    // Seed: downstream neighbors of the source node
+    const sourceSpec = nodeSpecsByNodeId.get(params.nodeId)
+    if (sourceSpec) {
+      for (const downstreamId of sourceSpec.downstreamNodeIds) {
+        queue.push(downstreamId)
+      }
+    }
+
+    while (queue.length > 0) {
+      const nodeId = queue.shift()
+      if (!nodeId || visited.has(nodeId)) continue
+      visited.add(nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(nodeId)
+      if (!nodeSpec) continue
+
+      const nodeRun = nodeRunsByNodeId.get(nodeId)
+      affectedNodes.push({ nodeId, label: nodeSpec.label, status: nodeRun?.status ?? 'pending' })
+
+      // Collect artifacts for this node
+      for (const artifact of artifacts.filter((a) => a.nodeId === nodeId)) {
+        affectedArtifacts.push({ name: artifact.name, nodeId })
+      }
+
+      // Continue downstream
+      for (const downstreamId of nodeSpec.downstreamNodeIds) {
+        if (!visited.has(downstreamId)) queue.push(downstreamId)
+      }
+    }
+
+    return {
+      sourceNodeId: params.nodeId,
+      affectedNodes: affectedNodes as ImpactAnalysis['affectedNodes'],
+      affectedArtifacts,
+    }
+  }
+}
+
+export const artifactProvenanceService = new ArtifactProvenanceService()

package/src/services/attachment.service.ts

@@ -57,7 +57,7 @@ class AttachmentService {
     name: string
     contentType: string
   }): Promise<string> {
-    return await attachmentStorageService.extractStoredAttachmentText({ storageKey, name, contentType })
+    return attachmentStorageService.extractStoredAttachmentText({ storageKey, name, contentType })
   }
 
   async extractStoredAttachmentPages({
@@ -69,7 +69,7 @@ class AttachmentService {
     name: string
     contentType: string
   }): Promise<{ pageMode: 'logical' | 'pdf'; pages: string[] }> {
-    return await attachmentStorageService.extractStoredAttachmentPages({ storageKey, name, contentType })
+    return attachmentStorageService.extractStoredAttachmentPages({ storageKey, name, contentType })
   }
 
   async readFilePartsFromUpload({
@@ -85,7 +85,7 @@ class AttachmentService {
     part?: number
     pagesPerPart?: number
   }) {
-    return await attachmentStorageService.readFilePartsFromUpload({
+    return attachmentStorageService.readFilePartsFromUpload({
       upload,
       orgId: toOrgId(orgId),
       userId: toUserId(userId),
@@ -111,7 +111,7 @@ class AttachmentService {
     content: string
     contentType: string
   }): Promise<{ storageKey: string; sizeBytes: number }> {
-    return await attachmentStorageService.writeOrganizationDocument({
+    return attachmentStorageService.writeOrganizationDocument({
       orgId: toOrgId(orgId),
       namespace,
       relativePath,
@@ -131,12 +131,7 @@ class AttachmentService {
     namespace: string
     relativePath: string
   }) {
-    return await attachmentStorageService.uploadOrganizationDocument({
-      file,
-      orgId: toOrgId(orgId),
-      namespace,
-      relativePath,
-    })
+    return attachmentStorageService.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
   }
 
   async uploadWorkstreamAttachment({
@@ -148,7 +143,7 @@ class AttachmentService {
     orgId: RecordIdRef
     userId: RecordIdRef
   }): Promise<SdkUploadedWorkstreamAttachment> {
-    return await attachmentStorageService.uploadWorkstreamAttachment({
+    return attachmentStorageService.uploadWorkstreamAttachment({
       file,
       orgId: toOrgId(orgId),
       userId: toUserId(userId),

package/src/services/context-compaction.service.ts

@@ -5,6 +5,8 @@ import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { getRedisConnection } from '../redis/connection-accessor'
+import { withRedisLeaseLock } from '../redis/redis-lease-lock'
 import { parseWorkstreamState, toStateFieldsUpdated } from '../runtime/context-compaction'
 import { CONTEXT_WINDOW_TOKENS, WORKSTREAM_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
 import type { WorkstreamState } from '../runtime/workstream-state'
@@ -47,68 +49,83 @@ class ContextCompactionService {
     workstreamId: RecordIdRef
     contextSize?: number
   }): Promise<{ compacted: boolean; state: WorkstreamState | null }> {
-    const workstream = await databaseService.findOne(TABLES.WORKSTREAM, { id: params.workstreamId }, WorkstreamSchema)
-    if (!workstream) {
-      throw new Error(
-        `Workstream not found for compaction: ${recordIdToString(params.workstreamId, TABLES.WORKSTREAM)}`,
-      )
-    }
-
-    const currentState = parseWorkstreamState(workstream.state)
-    const liveMessages = await workstreamMessageService.listMessagesAfterCursor(
-      params.workstreamId,
-      typeof workstream.lastCompactedMessageId === 'string' ? workstream.lastCompactedMessageId : undefined,
-    )
+    const entityId = recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
 
-    const result = await contextCompactionRuntime.compactHistory({
-      summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
-      liveMessages,
-      tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
-      contextSize: params.contextSize,
-      existingState: currentState,
-    })
-
-    if (!result.compacted || !result.lastCompactedMessageId) {
-      return { compacted: false, state: currentState }
-    }
-
-    if (result.compactedMessages.length > 0) {
-      await workstreamMessageService.upsertMessages({
-        workstreamId: params.workstreamId,
-        messages: result.compactedMessages,
-      })
-    }
-
-    await databaseService.update(
-      TABLES.WORKSTREAM,
-      params.workstreamId,
+    return withRedisLeaseLock(
       {
-        compactionSummary: result.summaryText,
-        lastCompactedMessageId: result.lastCompactedMessageId,
-        state: result.state,
+        redis: getRedisConnection(),
+        lockKey: `compaction:lock:${entityId}`,
+        lockTtlMs: 120_000,
+        maxWaitMs: 30_000,
+        label: 'context-compaction',
+      },
+      async () => {
+        const workstream = await databaseService.findOne(
+          TABLES.WORKSTREAM,
+          { id: params.workstreamId },
+          WorkstreamSchema,
+        )
+        if (!workstream) {
+          throw new Error(`Workstream not found for compaction: ${entityId}`)
+        }
+
+        const currentState = parseWorkstreamState(workstream.state)
+        const liveMessages = await workstreamMessageService.listMessagesAfterCursor(
+          params.workstreamId,
+          typeof workstream.lastCompactedMessageId === 'string' ? workstream.lastCompactedMessageId : undefined,
+        )
+
+        const result = await contextCompactionRuntime.compactHistory({
+          summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
+          liveMessages,
+          tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
+          contextSize: params.contextSize,
+          existingState: currentState,
+        })
+
+        if (!result.compacted || !result.lastCompactedMessageId) {
+          return { compacted: false, state: currentState }
+        }
+
+        if (result.compactedMessages.length > 0) {
+          await workstreamMessageService.upsertMessages({
+            workstreamId: params.workstreamId,
+            messages: result.compactedMessages,
+          })
+        }
+
+        await databaseService.update(
+          TABLES.WORKSTREAM,
+          params.workstreamId,
+          {
+            compactionSummary: result.summaryText,
+            lastCompactedMessageId: result.lastCompactedMessageId,
+            state: result.state,
+          },
+          WorkstreamSchema,
+        )
+
+        this.logCompactionMetrics({
+          domain: 'workstream',
+          entityId,
+          inputChars: result.inputChars,
+          outputChars: result.outputChars,
+          savedChars: Math.max(0, result.inputChars - result.outputChars),
+          summaryLength: result.summaryText.length,
+          compactedMessageCount: result.compactedMessageCount,
+          remainingMessageCount: result.remainingMessageCount,
+          estimatedTokens: result.estimatedTokens,
+          stateFieldsUpdated: toStateFieldsUpdated(result.stateDelta),
+          conflictsDetected: result.stateDelta.conflicts?.length ?? 0,
+        })
+
+        return { compacted: true, state: result.state }
       },
-      WorkstreamSchema,
     )
-
-    this.logCompactionMetrics({
-      domain: 'workstream',
-      entityId: recordIdToString(params.workstreamId, TABLES.WORKSTREAM),
-      inputChars: result.inputChars,
-      outputChars: result.outputChars,
-      savedChars: Math.max(0, result.inputChars - result.outputChars),
-      summaryLength: result.summaryText.length,
-      compactedMessageCount: result.compactedMessageCount,
-      remainingMessageCount: result.remainingMessageCount,
-      estimatedTokens: result.estimatedTokens,
-      stateFieldsUpdated: toStateFieldsUpdated(result.stateDelta),
-      conflictsDetected: result.stateDelta.conflicts?.length ?? 0,
-    })
-
-    return { compacted: true, state: result.state }
   }
 
   async compactMemoryBlock(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
-    return await compactMemoryBlockSummary(params)
+    return compactMemoryBlockSummary(params)
   }
 
   private logCompactionMetrics(metrics: PersistedCompactionMetrics): void {

package/src/services/context-enrichment.service.ts

@@ -0,0 +1,33 @@
+import type { ContextEnrichment } from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+
+class ContextEnrichmentService {
+  async enrichForPlanCreation(params: { objective: string; organizationId: string }): Promise<ContextEnrichment[]> {
+    const pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
+    const enrichers = Object.values(pluginRuntime).flatMap((plugin) => plugin.contextEnrichers ?? [])
+
+    if (enrichers.length === 0) return []
+
+    const results = await Promise.allSettled(
+      enrichers.map((enricher) =>
+        enricher.enrich({ objective: params.objective, organizationId: params.organizationId }),
+      ),
+    )
+
+    const enrichments: ContextEnrichment[] = []
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]
+      if (result.status === 'fulfilled') {
+        enrichments.push({ domain: enrichers[i].domain, data: result.value.data, confidence: result.value.confidence })
+      } else {
+        serverLogger.warn`Context enricher "${enrichers[i].domain}" failed: ${result.reason}`
+      }
+    }
+
+    return enrichments.sort((a, b) => b.confidence - a.confidence)
+  }
+}
+
+export const contextEnrichmentService = new ContextEnrichmentService()

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

@@ -0,0 +1,117 @@
+import type { SignalDeclaration } from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+import type { LotaPlugin } from '../runtime/plugin-types'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+
+export interface EmittedSignal {
+  signal: string
+  payload: unknown
+  sourcePlugin: string
+  consumers: string[]
+  emittedAt: Date
+}
+
+const MAX_EMITTED_SIGNALS = 1000
+
+class CoordinationRegistryService {
+  private producers = new Map<string, string[]>()
+  private consumers = new Map<string, string[]>()
+  private _emittedSignals: EmittedSignal[] = []
+
+  register(pluginRef: string, signals: SignalDeclaration[]): void {
+    for (const signal of signals) {
+      if (signal.direction === 'produces') {
+        const existing = this.producers.get(signal.signalName) ?? []
+        existing.push(pluginRef)
+        this.producers.set(signal.signalName, existing)
+      } else {
+        const existing = this.consumers.get(signal.signalName) ?? []
+        existing.push(pluginRef)
+        this.consumers.set(signal.signalName, existing)
+      }
+    }
+  }
+
+  async emit(signal: string, payload: unknown, sourcePlugin: string): Promise<void> {
+    const consumers = this.consumers.get(signal) ?? []
+
+    this._emittedSignals.push({ signal, payload, sourcePlugin, consumers: [...consumers], emittedAt: new Date() })
+    if (this._emittedSignals.length > MAX_EMITTED_SIGNALS) {
+      this._emittedSignals.shift()
+    }
+
+    serverLogger.debug(
+      `Signal "${signal}" emitted by "${sourcePlugin}" — ${consumers.length} consumer(s): ${consumers.join(', ') || 'none'}`,
+    )
+
+    if (consumers.length === 0) return
+
+    let pluginRuntime: Record<string, unknown> = {}
+    try {
+      pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
+    } catch {
+      // Runtime not yet configured — skip plugin dispatch
+    }
+
+    for (const consumerRef of consumers) {
+      const plugin = pluginRuntime[consumerRef] as LotaPlugin | undefined
+      if (plugin?.onSignal) {
+        try {
+          await plugin.onSignal(signal, payload, sourcePlugin)
+        } catch (error) {
+          serverLogger.warn`Signal handler for "${consumerRef}" failed on signal "${signal}": ${error}`
+        }
+      }
+    }
+  }
+
+  getEmittedSignals(signalName?: string): EmittedSignal[] {
+    if (!signalName) return [...this._emittedSignals]
+    return this._emittedSignals.filter((entry) => entry.signal === signalName)
+  }
+
+  getProducers(signalName: string): string[] {
+    return this.producers.get(signalName) ?? []
+  }
+
+  getConsumers(signalName: string): string[] {
+    return this.consumers.get(signalName) ?? []
+  }
+
+  validate(): PlanValidationIssueInput[] {
+    const issues: PlanValidationIssueInput[] = []
+
+    for (const [signalName] of this.producers) {
+      if ((this.consumers.get(signalName) ?? []).length === 0) {
+        issues.push({
+          severity: 'warning',
+          code: 'signal_no_consumer',
+          message: `Signal "${signalName}" is produced but has no consumers.`,
+        })
+      }
+    }
+
+    for (const [signalName] of this.consumers) {
+      if ((this.producers.get(signalName) ?? []).length === 0) {
+        issues.push({
+          severity: 'warning',
+          code: 'signal_no_producer',
+          message: `Signal "${signalName}" is consumed but has no producers.`,
+        })
+      }
+    }
+
+    return issues
+  }
+
+  /** Reset internal state. Intended for testing. */
+  _reset(): void {
+    this.producers.clear()
+    this.consumers.clear()
+    this._emittedSignals = []
+  }
+}
+
+export const coordinationRegistryService = new CoordinationRegistryService()

package/src/services/document-chunk.service.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto'
-
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
 import { getDefaultEmbeddings } from '../embeddings/provider'
@@ -56,7 +54,7 @@ export class DocumentChunkService {
   }
 
   hashContent(content: string): string {
-    return createHash('sha256').update(content).digest('hex')
+    return new Bun.CryptoHasher('sha256').update(content).digest('hex')
   }
 
   // Uses 4 chars/token (conservative estimate for document content which tends
@@ -66,7 +64,7 @@ export class DocumentChunkService {
   }
 
   async embedQuery(query: string): Promise<number[]> {
-    return await this.embeddings.embedQuery(query)
+    return this.embeddings.embedQuery(query)
   }
 
   async syncVersionedChunks<TRecord, TPayload>(params: {

package/src/services/domain-agent-executor.service.ts

@@ -0,0 +1,71 @@
+import type { OwnershipDispatchContext, PlanArtifactSubmission, PlanNodeResult, PlanNodeSpec } from '@lota-sdk/shared'
+
+import type { LotaPlugin, PluginDomainAgentDefinition } from '../runtime/plugin-types'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+
+class DomainAgentExecutorService {
+  private registry = new Map<string, { pluginRef: string; definition: PluginDomainAgentDefinition }>()
+
+  configure(pluginRuntime: Record<string, LotaPlugin>): void {
+    this.registry.clear()
+    for (const [pluginRef, plugin] of Object.entries(pluginRuntime)) {
+      if (plugin.domainAgents) {
+        for (const def of plugin.domainAgents) {
+          this.registry.set(def.agentId, { pluginRef, definition: def })
+        }
+      }
+    }
+  }
+
+  hasAgent(agentId: string): boolean {
+    return this.registry.has(agentId)
+  }
+
+  validateOwner(agentId: string, nodeId: string): PlanValidationIssueInput[] {
+    if (!this.registry.has(agentId)) {
+      return [
+        {
+          severity: 'blocking',
+          code: 'domain_agent_missing',
+          message: `Node "${nodeId}" references unknown domain agent "${agentId}".`,
+          nodeId,
+        },
+      ]
+    }
+    return []
+  }
+
+  async executeNode(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    context: OwnershipDispatchContext
+  }): Promise<PlanNodeResult> {
+    const entry = this.registry.get(params.nodeSpec.owner.ref)
+    if (!entry) {
+      throw new Error(`Domain agent "${params.nodeSpec.owner.ref}" not registered.`)
+    }
+
+    const plugin = (getRuntimeConfig().pluginRuntime as Record<string, LotaPlugin | undefined> | undefined)?.[
+      entry.pluginRef
+    ]
+    if (!plugin?.nodeExecutor) {
+      throw new Error(`Plugin "${entry.pluginRef}" does not have a nodeExecutor.`)
+    }
+
+    return plugin.nodeExecutor.executeNode({
+      operation: `domain-agent:${entry.definition.agentId}`,
+      nodeSpec: params.nodeSpec,
+      inputs: params.resolvedInput,
+      context: {
+        organizationId: params.context.organizationId,
+        workstreamId: params.context.workstreamId,
+        planId: params.context.planId,
+        nodeId: params.context.nodeId,
+      },
+    })
+  }
+}
+
+export const domainAgentExecutorService = new DomainAgentExecutorService()