@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/feedback-loop.service.ts

@@ -1,96 +1,152 @@
 import type { Recommendation } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { toIsoDateTimeString } from '../utils/date-time'
-import { planRunService } from './plan-run.service'
+import { toIsoDateTimeString, unsafeDateFrom } from '../utils/date-time'
+import type { makePlanRunService } from './plan/plan-run.service'
+import { PlanRunServiceTag } from './plan/plan-run.service'
 
-class FeedbackLoopService {
-  async analyzeOutcomes(params: { runId: string; organizationId: string }): Promise<Recommendation[]> {
-    const run = await planRunService.getRunById(params.runId)
-    const nodeRuns = await planRunService.listNodeRuns(run.id)
-    const attempts = await planRunService.listAttempts(run.id)
-    const nodeSpecs = await planRunService.listNodeSpecs(ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC))
-    const nodeSpecsByNodeId = new Map(nodeSpecs.map((ns) => [ns.nodeId, ns]))
+class FeedbackLoopServiceError extends Schema.TaggedErrorClass<FeedbackLoopServiceError>()('FeedbackLoopServiceError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
 
-    const recommendations: Recommendation[] = []
+export function makeFeedbackLoopService(planRunService: ReturnType<typeof makePlanRunService>) {
+  return {
+    analyzeOutcomes(params: { runId: string; organizationId: string }) {
+      return Effect.gen(function* () {
+        const run = yield* planRunService
+          .getRunById(params.runId)
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new FeedbackLoopServiceError({ message: 'Failed to load plan run for feedback analysis.', cause }),
+            ),
+          )
+        const [nodeRuns, attempts, nodeSpecs] = yield* Effect.all([
+          planRunService
+            .listNodeRuns(run.id)
+            .pipe(
+              Effect.mapError(
+                (cause) =>
+                  new FeedbackLoopServiceError({ message: 'Failed to load node runs for feedback analysis.', cause }),
+              ),
+            ),
+          planRunService
+            .listAttempts(run.id)
+            .pipe(
+              Effect.mapError(
+                (cause) =>
+                  new FeedbackLoopServiceError({
+                    message: 'Failed to load node attempts for feedback analysis.',
+                    cause,
+                  }),
+              ),
+            ),
+          planRunService
+            .listNodeSpecs(ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC))
+            .pipe(
+              Effect.mapError(
+                (cause) =>
+                  new FeedbackLoopServiceError({ message: 'Failed to load node specs for feedback analysis.', cause }),
+              ),
+            ),
+        ])
 
-    for (const nodeRun of nodeRuns) {
-      const nodeSpec = nodeSpecsByNodeId.get(nodeRun.nodeId)
-      if (!nodeSpec) continue
+        const nodeSpecsByNodeId = new Map(nodeSpecs.map((ns) => [ns.nodeId, ns]))
 
-      const nodeAttempts = attempts.filter((a) => a.nodeId === nodeRun.nodeId)
-      const failedAttempts = nodeAttempts.filter((a) => a.status === 'failed')
+        const recommendations: Recommendation[] = []
 
-      if (failedAttempts.length >= 2) {
-        recommendations.push({
-          type: 'warning',
-          target: 'node',
-          targetId: nodeRun.nodeId,
-          description: `Node "${nodeSpec.label}" failed ${failedAttempts.length} times before ${nodeRun.status === 'completed' || nodeRun.status === 'partial' ? 'succeeding' : 'giving up'}. Consider adjusting retry policy or node instructions.`,
-          evidence: failedAttempts.map((a) => ({
-            sourceType: 'metric',
-            sourceId: recordIdToString(a.id, TABLES.PLAN_NODE_ATTEMPT),
-            summary: `Attempt failed with class: ${a.failureClass ?? 'unknown'}`,
-            confidence: 0.9,
-          })),
-          confidence: Math.min(0.5 + failedAttempts.length * 0.15, 0.95),
-        })
-      }
-    }
+        for (const nodeRun of nodeRuns) {
+          const nodeSpec = nodeSpecsByNodeId.get(nodeRun.nodeId)
+          if (!nodeSpec) continue
 
-    const completedNodeRuns = nodeRuns.filter(
-      (nr) => nr.startedAt && nr.completedAt && (nr.status === 'completed' || nr.status === 'partial'),
-    )
-    if (completedNodeRuns.length >= 2) {
-      const durations = completedNodeRuns.map((nr) => {
-        const start = new Date(toIsoDateTimeString(nr.startedAt)).getTime()
-        const end = new Date(toIsoDateTimeString(nr.completedAt)).getTime()
-        return { nodeId: nr.nodeId, durationMs: end - start }
-      })
+          const nodeAttempts = attempts.filter((a) => a.nodeId === nodeRun.nodeId)
+          const failedAttempts = nodeAttempts.filter((a) => a.status === 'failed')
+
+          if (failedAttempts.length >= 2) {
+            recommendations.push({
+              type: 'warning',
+              target: 'node',
+              targetId: nodeRun.nodeId,
+              description: `Node "${nodeSpec.label}" failed ${failedAttempts.length} times before ${nodeRun.status === 'completed' || nodeRun.status === 'partial' ? 'succeeding' : 'giving up'}. Consider adjusting retry policy or node instructions.`,
+              evidence: failedAttempts.map((a) => ({
+                sourceType: 'metric',
+                sourceId: recordIdToString(a.id, TABLES.PLAN_NODE_ATTEMPT),
+                summary: `Attempt failed with class: ${a.failureClass ?? 'unknown'}`,
+                confidence: 0.9,
+              })),
+              confidence: Math.min(0.5 + failedAttempts.length * 0.15, 0.95),
+            })
+          }
+        }
+
+        const completedNodeRuns = nodeRuns.filter(
+          (nr) => nr.startedAt && nr.completedAt && (nr.status === 'completed' || nr.status === 'partial'),
+        )
+        if (completedNodeRuns.length >= 2) {
+          const durations = completedNodeRuns.map((nr) => {
+            const start = unsafeDateFrom(toIsoDateTimeString(nr.startedAt)).getTime()
+            const end = unsafeDateFrom(toIsoDateTimeString(nr.completedAt)).getTime()
+            return { nodeId: nr.nodeId, durationMs: end - start }
+          })
 
-      const avgDuration = durations.reduce((sum, d) => sum + d.durationMs, 0) / durations.length
+          const avgDuration = durations.reduce((sum, d) => sum + d.durationMs, 0) / durations.length
 
-      for (const d of durations) {
-        if (d.durationMs > avgDuration * 2.5 && d.durationMs > 5000) {
-          const nodeSpec = nodeSpecsByNodeId.get(d.nodeId)
+          for (const d of durations) {
+            if (d.durationMs > avgDuration * 2.5 && d.durationMs > 5000) {
+              const nodeSpec = nodeSpecsByNodeId.get(d.nodeId)
+              recommendations.push({
+                type: 'optimization',
+                target: 'node',
+                targetId: d.nodeId,
+                description: `Node "${nodeSpec?.label ?? d.nodeId}" took ${Math.round(d.durationMs / 1000)}s, which is ${Math.round((d.durationMs / avgDuration) * 10) / 10}x the average. Consider splitting or optimizing.`,
+                evidence: [
+                  {
+                    sourceType: 'metric',
+                    sourceId: d.nodeId,
+                    summary: `Execution time: ${d.durationMs}ms vs average ${Math.round(avgDuration)}ms`,
+                    confidence: 0.85,
+                  },
+                ],
+                confidence: 0.7,
+              })
+            }
+          }
+        }
+
+        const skippedNodes = nodeRuns.filter((nr) => nr.status === 'skipped')
+        if (skippedNodes.length > 0 && skippedNodes.length >= nodeRuns.length * 0.3) {
           recommendations.push({
-            type: 'optimization',
-            target: 'node',
-            targetId: d.nodeId,
-            description: `Node "${nodeSpec?.label ?? d.nodeId}" took ${Math.round(d.durationMs / 1000)}s, which is ${Math.round((d.durationMs / avgDuration) * 10) / 10}x the average. Consider splitting or optimizing.`,
-            evidence: [
-              {
-                sourceType: 'metric',
-                sourceId: d.nodeId,
-                summary: `Execution time: ${d.durationMs}ms vs average ${Math.round(avgDuration)}ms`,
-                confidence: 0.85,
-              },
-            ],
-            confidence: 0.7,
+            type: 'pattern',
+            target: 'plan',
+            description: `${skippedNodes.length} of ${nodeRuns.length} nodes were skipped. The plan may have overly broad conditional branches.`,
+            evidence: skippedNodes.map((nr) => ({
+              sourceType: 'pattern',
+              sourceId: nr.nodeId,
+              summary: `Node "${nodeSpecsByNodeId.get(nr.nodeId)?.label ?? nr.nodeId}" was skipped`,
+              confidence: 0.8,
+            })),
+            confidence: 0.65,
           })
         }
-      }
-    }
 
-    const skippedNodes = nodeRuns.filter((nr) => nr.status === 'skipped')
-    if (skippedNodes.length > 0 && skippedNodes.length >= nodeRuns.length * 0.3) {
-      recommendations.push({
-        type: 'pattern',
-        target: 'plan',
-        description: `${skippedNodes.length} of ${nodeRuns.length} nodes were skipped. The plan may have overly broad conditional branches.`,
-        evidence: skippedNodes.map((nr) => ({
-          sourceType: 'pattern',
-          sourceId: nr.nodeId,
-          summary: `Node "${nodeSpecsByNodeId.get(nr.nodeId)?.label ?? nr.nodeId}" was skipped`,
-          confidence: 0.8,
-        })),
-        confidence: 0.65,
+        return recommendations
       })
-    }
-
-    return recommendations
+    },
   }
 }
 
-export const feedbackLoopService = new FeedbackLoopService()
+export class FeedbackLoopServiceTag extends Context.Service<
+  FeedbackLoopServiceTag,
+  ReturnType<typeof makeFeedbackLoopService>
+>()('FeedbackLoopService') {}
+
+export const FeedbackLoopServiceLive = Layer.effect(
+  FeedbackLoopServiceTag,
+  Effect.gen(function* () {
+    const planRunService = yield* PlanRunServiceTag
+    return makeFeedbackLoopService(planRunService)
+  }),
+)

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

@@ -1,180 +1,90 @@
-import type { ConvergenceState, PlanFailureClass } from '@lota-sdk/shared'
-
-import { serverLogger } from '../config/logger'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
+import type { ConvergenceState } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
+
+import { runPromise } from '../effect/runtime'
+import { getCurrentRuntime } from '../effect/runtime-ref'
+import { routeGraphFullEffect } from './graph-full-routing'
+import type { makeOwnershipDispatcherService } from './ownership-dispatcher.service'
+import { OwnershipDispatcherServiceTag } from './ownership-dispatcher.service'
+import type { makePlanExecutorService } from './plan/plan-executor.service'
+import { PlanExecutorServiceTag } from './plan/plan-executor.service'
+import type { makePlanRunService } from './plan/plan-run.service'
+import { PlanRunServiceTag } from './plan/plan-run.service'
+
+function detectConvergence(params: {
+  totalNodes: number
+  completedNodes: number
+  failedNodes: number
+  previousCompletedNodes?: number
+  previousFailedNodes?: number
+}): ConvergenceState {
+  const completionRatio = params.totalNodes > 0 ? params.completedNodes / params.totalNodes : 0
+  const failureRatio = params.totalNodes > 0 ? params.failedNodes / params.totalNodes : 0
+
+  if (params.previousCompletedNodes !== undefined) {
+    const completionVelocity = params.completedNodes - params.previousCompletedNodes
+    const failureVelocity = params.failedNodes - (params.previousFailedNodes ?? 0)
+
+    if (completionVelocity > 0 && failureVelocity === 0) return 'converging'
+    if (completionVelocity === 0 && failureVelocity === 0) return 'stalled'
+    if (failureVelocity > 0) return 'diverging'
+  }
 
-function classifyDispatchFailure(ownerType: string, error: unknown): PlanFailureClass {
-  const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase()
-  if (errorMessage.includes('timeout')) return 'timeout_exceeded'
-  if (ownerType === 'plugin' || ownerType === 'system') return 'external_system_unavailable'
-  return 'non_recoverable_logic_error'
+  if (completionRatio > 0.5 && failureRatio === 0) return 'converging'
+  if (failureRatio > 0.3) return 'diverging'
+  return 'progressing'
 }
 
-function formatDispatchError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error)
+function decideRerouteAction(params: {
+  failedNodeId: string
+  retryCount: number
+  maxRetries: number
+  convergenceState: ConvergenceState
+}): 'retry' | 'skip' | 'abort' {
+  if (params.retryCount < params.maxRetries) return 'retry'
+  if (params.convergenceState === 'converging') return 'skip'
+  if (params.convergenceState === 'diverging') return 'abort'
+  return 'skip'
 }
 
-const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
-
-class GlobalOrchestratorService {
-  detectConvergence(params: {
-    totalNodes: number
-    completedNodes: number
-    failedNodes: number
-    previousCompletedNodes?: number
-    previousFailedNodes?: number
-  }): ConvergenceState {
-    const completionRatio = params.totalNodes > 0 ? params.completedNodes / params.totalNodes : 0
-    const failureRatio = params.totalNodes > 0 ? params.failedNodes / params.totalNodes : 0
-
-    if (params.previousCompletedNodes !== undefined) {
-      const completionVelocity = params.completedNodes - params.previousCompletedNodes
-      const failureVelocity = params.failedNodes - (params.previousFailedNodes ?? 0)
-
-      if (completionVelocity > 0 && failureVelocity === 0) return 'converging'
-      if (completionVelocity === 0 && failureVelocity === 0) return 'stalled'
-      if (failureVelocity > 0) return 'diverging'
-    }
-
-    if (completionRatio > 0.5 && failureRatio === 0) return 'converging'
-    if (failureRatio > 0.3) return 'diverging'
-    return 'progressing'
-  }
+interface GlobalOrchestratorDeps {
+  ownershipDispatcherService: ReturnType<typeof makeOwnershipDispatcherService>
+  planExecutorService: ReturnType<typeof makePlanExecutorService>
+  planRunService: ReturnType<typeof makePlanRunService>
+}
 
-  decideRerouteAction(params: {
-    failedNodeId: string
-    retryCount: number
-    maxRetries: number
-    convergenceState: ConvergenceState
-  }): 'retry' | 'skip' | 'abort' {
-    if (params.retryCount < params.maxRetries) return 'retry'
-    if (params.convergenceState === 'converging') return 'skip'
-    if (params.convergenceState === 'diverging') return 'abort'
-    return 'skip'
+export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
+  return {
+    detectConvergence,
+    decideRerouteAction,
+    routeGraphFull: (params: { threadId: string; runId: string }) =>
+      routeGraphFullEffect(params, {
+        dispatchReadyNode: (dispatchParams) => deps.ownershipDispatcherService.dispatchReadyNode(dispatchParams),
+        planExecutorService: deps.planExecutorService,
+        planRunService: deps.planRunService,
+      }),
   }
+}
 
-  async routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
-    const MAX_ROUNDS = 32
-    const STRUCTURAL_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
-
-    // Dynamic imports to avoid circular dependencies
-    const { planRunService } = await import('./plan-run.service')
-    const { ownershipDispatcherService } = await import('./ownership-dispatcher.service')
-    const { planExecutorService } = await import('./plan-executor.service')
-
-    let round = 0
-    for (; round < MAX_ROUNDS; round++) {
-      const run = await planRunService.getRunById(params.runId)
-      if (STABLE_RUN_STATUSES.has(run.status)) break
-
-      const spec = await planRunService.getPlanSpecById(run.planSpecId)
-      const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-      const nodeRuns = await planRunService.listNodeRuns(run.id)
-
-      // Find ready action nodes (not structural, not human — those are handled by syncRunGraph)
-      const readyNodes = nodeRuns.filter((nr) => {
-        if (nr.status !== 'ready') return false
-        const ns = nodeSpecs.find((s) => s.nodeId === nr.nodeId)
-        return ns && ns.owner.executorType !== 'user' && !STRUCTURAL_TYPES.has(ns.type)
-      })
-      if (readyNodes.length === 0) break
-
-      // Split into silent (dispatch now) and visible (enqueue heartbeat wake)
-      const silentNodes = readyNodes.filter((nr) => {
-        const ns = nodeSpecs.find((s) => s.nodeId === nr.nodeId)
-        return ns && !shouldPlanNodeUseVisibleTurn(spec, ns)
-      })
-      const visibleNodes = readyNodes.filter((nr) => {
-        const ns = nodeSpecs.find((s) => s.nodeId === nr.nodeId)
-        return ns && shouldPlanNodeUseVisibleTurn(spec, ns)
-      })
-
-      // Transition all ready nodes to 'running' BEFORE dispatching
-      for (const nodeRun of readyNodes) {
-        await planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: nodeRun.nodeId })
-      }
-
-      // Enqueue heartbeat wakes for visible agent nodes — they need a streaming turn
-      if (visibleNodes.length > 0) {
-        const { enqueuePlanAgentHeartbeatWake } = await import('../queues/plan-agent-heartbeat.queue')
-        const updatedRunForWake = await planRunService.getRunById(params.runId)
-        for (const nodeRun of visibleNodes) {
-          const ns = nodeSpecs.find((s) => s.nodeId === nodeRun.nodeId)
-          if (!ns || ns.owner.executorType !== 'agent') continue
-          await enqueuePlanAgentHeartbeatWake({
-            organizationId: recordIdToString(updatedRunForWake.organizationId, TABLES.ORGANIZATION),
-            threadId: recordIdToString(updatedRunForWake.threadId, TABLES.THREAD),
-            runId: recordIdToString(updatedRunForWake.id, TABLES.PLAN_RUN),
-            nodeId: nodeRun.nodeId,
-            agentId: ns.owner.ref,
-            reason: 'graph-full-visible',
-          })
-        }
-      }
-
-      // If no silent nodes to dispatch, break and let heartbeat handle visible ones
-      if (silentNodes.length === 0) break
-
-      // Re-fetch run after transitions for accurate state in dispatch context
-      const updatedRun = await planRunService.getRunById(params.runId)
-
-      // Dispatch silent nodes in parallel with LINEAR mode override (prevents recursion)
-      const results = await Promise.allSettled(
-        silentNodes.map(async (nodeRun) => {
-          const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
-          if (!nodeSpecRecord) {
-            throw new Error(`Node spec not found for node "${nodeRun.nodeId}".`)
-          }
-          // Re-fetch the node run to get the updated 'running' state with resolvedInput
-          const updatedNodeRun = await planRunService.getNodeRunByNodeId(updatedRun.id, nodeRun.nodeId)
-          const result = await ownershipDispatcherService.dispatchReadyNode({
-            run: updatedRun,
-            nodeSpecRecord,
-            nodeRun: updatedNodeRun,
-            spec,
-            executionModeOverride: 'linear',
-          })
-          return { nodeId: nodeRun.nodeId, ownerRef: nodeSpecRecord.owner.ref, result }
-        }),
-      )
-
-      const threadId = recordIdToString(updatedRun.threadId, TABLES.THREAD)
-      const runId = recordIdToString(updatedRun.id, TABLES.PLAN_RUN)
-
-      // Submit results sequentially (each triggers syncRunGraph internally)
-      for (let i = 0; i < results.length; i++) {
-        const settled = results[i]
-        const nodeRun = silentNodes[i]
-        const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
-
-        if (settled.status === 'fulfilled') {
-          await planExecutorService.submitNodeResult({
-            threadId,
-            runId,
-            nodeId: settled.value.nodeId,
-            emittedBy: settled.value.ownerRef,
-            result: settled.value.result,
-          })
-        } else {
-          serverLogger.warn`routeGraphFull: dispatch failed for node "${nodeRun.nodeId}": ${settled.reason}`
-          await planExecutorService.blockNodeOnDispatchFailure({
-            threadId,
-            runId,
-            nodeId: nodeRun.nodeId,
-            emittedBy: nodeSpecRecord?.owner.ref ?? 'unknown',
-            message: formatDispatchError(settled.reason),
-            failureClass: classifyDispatchFailure(nodeSpecRecord?.owner.executorType ?? 'agent', settled.reason),
-          })
-        }
-      }
-    }
-
-    if (round === MAX_ROUNDS - 1) {
-      serverLogger.warn`graph-full execution reached max rounds (${MAX_ROUNDS}) for run ${params.runId} — possible non-converging graph`
-    }
-  }
+export class GlobalOrchestratorServiceTag extends Context.Service<
+  GlobalOrchestratorServiceTag,
+  ReturnType<typeof makeGlobalOrchestratorService>
+>()('GlobalOrchestratorService') {}
+
+export const GlobalOrchestratorServiceLive = Layer.effect(
+  GlobalOrchestratorServiceTag,
+  Effect.gen(function* () {
+    const ownershipDispatcherService = yield* OwnershipDispatcherServiceTag
+    const planExecutorService = yield* PlanExecutorServiceTag
+    const planRunService = yield* PlanRunServiceTag
+    return makeGlobalOrchestratorService({ ownershipDispatcherService, planExecutorService, planRunService })
+  }),
+)
+
+function getGlobalOrchestratorService() {
+  return getCurrentRuntime().runSync(Effect.service(GlobalOrchestratorServiceTag))
 }
 
-export const globalOrchestratorService = new GlobalOrchestratorService()
+export function routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
+  return runPromise(getGlobalOrchestratorService().routeGraphFull(params))
+}