@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/plan-completion-side-effects.ts

@@ -1,80 +0,0 @@
-import type { PlanNodeOwner, PlanNodeType } from '@lota-sdk/shared'
-import { PlanEventSchema } from '@lota-sdk/shared'
-
-import { aiLogger } from '../config/logger'
-import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { feedbackLoopService } from './feedback-loop.service'
-import { institutionalMemoryService } from './institutional-memory.service'
-import { planEventDeliveryService } from './plan-event-delivery.service'
-import { planRunService } from './plan-run.service'
-import type { PlanValidationIssueInput } from './plan-validator.service'
-import { qualityMetricsService } from './quality-metrics.service'
-
-export async function runPlanNodeCompletionSideEffects(params: {
-  runId: string
-  organizationId: string
-  nodeId: string
-  nodeLabel: string
-  nodeOwnerRef: string
-  nodeOwnerType: PlanNodeOwner['executorType']
-  nodeType: PlanNodeType
-  nodeStartedAt?: string | Date | null
-  nodeAttemptCount: number
-  artifactCount: number
-  validationIssues: PlanValidationIssueInput[]
-}): Promise<void> {
-  const executionTimeMs = params.nodeStartedAt ? Date.now() - new Date(params.nodeStartedAt).getTime() : 0
-  await qualityMetricsService.recordNodeMetrics({
-    organizationId: params.organizationId,
-    runId: params.runId,
-    nodeId: params.nodeId,
-    metrics: {
-      executionTimeMs: Math.max(0, executionTimeMs),
-      attemptCount: params.nodeAttemptCount,
-      artifactCount: params.artifactCount,
-      validationIssueCount: params.validationIssues.length,
-      ownerRef: params.nodeOwnerRef,
-      ownerType: params.nodeOwnerType,
-      nodeType: params.nodeType,
-    },
-  })
-}
-
-async function runPlanCompletionSideEffects(params: { runId: string; organizationId: string }): Promise<void> {
-  await qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
-
-  const recommendations = await feedbackLoopService.analyzeOutcomes({
-    runId: params.runId,
-    organizationId: params.organizationId,
-  })
-  if (recommendations.length > 0) {
-    const run = await planRunService.getRunById(params.runId)
-    const specRecord = await planRunService.getPlanSpecById(run.planSpecId)
-    const event = await databaseService.create(
-      TABLES.PLAN_EVENT,
-      {
-        planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
-        runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
-        eventType: 'feedback-analyzed',
-        message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
-        detail: { recommendations },
-        emittedBy: 'system',
-      },
-      PlanEventSchema,
-    )
-    await planEventDeliveryService.dispatchEvent(event)
-  }
-
-  await institutionalMemoryService.extractPatterns({ organizationId: params.organizationId, runId: params.runId })
-}
-
-export async function runPlanCompletionSideEffectsSafely(params: {
-  runId: string
-  organizationId: string
-}): Promise<void> {
-  await runPlanCompletionSideEffects(params).catch((error) => {
-    aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
-  })
-}

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

@@ -1,157 +0,0 @@
-import type { PlanArtifactRecord, PlanDependency } from '@lota-sdk/shared'
-
-import { serverLogger } from '../config/logger'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import type { PlanValidationIssueInput } from './plan-validator.service'
-
-export interface DependencyResolutionResult {
-  resolved: Map<string, PlanArtifactRecord>
-  unresolved: PlanDependency[]
-  notifications: Array<{ dependency: PlanDependency; reason: string }>
-}
-
-class PlanCoordinationService {
-  /**
-   * Resolve cross-plan artifact dependencies.
-   * For each dependency:
-   *   1. Find the source plan by spec id 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:
-   *      'block'       -> unresolved if missing/stale
-   *      'notify'      -> proceed but record notification
-   *      'best-effort' -> proceed regardless, no notification
-   */
-  async resolveDependencies(params: {
-    dependencies: PlanDependency[]
-    threadId: string
-  }): Promise<DependencyResolutionResult> {
-    const { planRunService } = await import('./plan-run.service')
-
-    const resolved = new Map<string, PlanArtifactRecord>()
-    const unresolved: PlanDependency[] = []
-    const notifications: DependencyResolutionResult['notifications'] = []
-    const specs = await planRunService.listPlanSpecsByThread(params.threadId)
-
-    for (const dep of params.dependencies) {
-      const depKey = `${dep.sourcePlanSpecId}:${dep.sourceNodeId}:${dep.artifactName}`
-
-      const sourceSpec = specs.find((s) => recordIdToString(s.id, TABLES.PLAN_SPEC) === dep.sourcePlanSpecId)
-      if (!sourceSpec) {
-        const reason = `Source plan "${dep.sourcePlanSpecId}" not found in thread.`
-        if (dep.triggerMode === 'block') {
-          unresolved.push(dep)
-        } else if (dep.triggerMode === 'notify') {
-          notifications.push({ dependency: dep, reason })
-          serverLogger.warn`Dependency unmet (notify): ${reason}`
-        }
-        // best-effort: silently proceed
-        continue
-      }
-
-      const runs = await planRunService.listRunsBySpec(sourceSpec.id)
-      const activeRun = runs.find((r) => r.status === 'completed' || r.status === 'running')
-      if (!activeRun) {
-        const reason = `No active run found for plan "${sourceSpec.title}".`
-        if (dep.triggerMode === 'block') {
-          unresolved.push(dep)
-        } else if (dep.triggerMode === 'notify') {
-          notifications.push({ dependency: dep, reason })
-          serverLogger.warn`Dependency unmet (notify): ${reason}`
-        }
-        continue
-      }
-
-      const artifacts = await planRunService.listArtifacts(activeRun.id)
-      const artifact = artifacts.find((a) => a.nodeId === dep.sourceNodeId && a.name === dep.artifactName)
-
-      if (!artifact) {
-        const reason = `Artifact "${dep.artifactName}" not found on node "${dep.sourceNodeId}" in plan "${sourceSpec.title}".`
-        if (dep.triggerMode === 'block') {
-          unresolved.push(dep)
-        } else if (dep.triggerMode === 'notify') {
-          notifications.push({ dependency: dep, reason })
-          serverLogger.warn`Dependency unmet (notify): ${reason}`
-        }
-        continue
-      }
-
-      if (dep.maxStalenessMs && this.isStale(artifact, dep.maxStalenessMs)) {
-        const reason = `Artifact "${dep.artifactName}" from plan "${sourceSpec.title}" is stale.`
-        if (dep.triggerMode === 'block') {
-          unresolved.push(dep)
-          continue
-        }
-        if (dep.triggerMode === 'notify') {
-          notifications.push({ dependency: dep, reason })
-          serverLogger.warn`Dependency stale (notify): ${reason}`
-        }
-        // best-effort and notify: use stale artifact anyway
-      }
-
-      resolved.set(depKey, artifact)
-    }
-
-    return { resolved, unresolved, notifications }
-  }
-
-  /** Check if an artifact has exceeded the staleness window. */
-  isStale(artifact: Pick<PlanArtifactRecord, 'createdAt'>, maxStalenessMs: number): boolean {
-    if (!maxStalenessMs) return false
-    return Date.now() - artifact.createdAt.getTime() > maxStalenessMs
-  }
-
-  /**
-   * Validate no circular dependencies exist using Kahn's algorithm.
-   * Build adjacency: planSpecId -> depends on upstream planSpecIds
-   * Run topological sort; if not all visited -> cycle exists.
-   */
-  validateNoCycles(
-    specs: Array<{ id: string; title?: string; dependencies?: PlanDependency[] }>,
-  ): PlanValidationIssueInput[] {
-    const adj = new Map<string, Set<string>>()
-    const inDegree = new Map<string, number>()
-    const labels = new Map(specs.map((spec) => [spec.id, spec.title ?? spec.id]))
-
-    for (const spec of specs) {
-      if (!adj.has(spec.id)) adj.set(spec.id, new Set())
-      if (!inDegree.has(spec.id)) inDegree.set(spec.id, 0)
-
-      for (const dep of spec.dependencies ?? []) {
-        if (!adj.has(dep.sourcePlanSpecId)) adj.set(dep.sourcePlanSpecId, new Set())
-        if (!inDegree.has(dep.sourcePlanSpecId)) inDegree.set(dep.sourcePlanSpecId, 0)
-
-        adj.get(dep.sourcePlanSpecId)?.add(spec.id)
-        inDegree.set(spec.id, (inDegree.get(spec.id) ?? 0) + 1)
-      }
-    }
-
-    const queue = [...inDegree.entries()].filter(([, d]) => d === 0).map(([t]) => t)
-    const visited = new Set<string>()
-
-    while (queue.length > 0) {
-      const node = queue.shift()
-      if (!node) break
-      visited.add(node)
-      for (const dep of adj.get(node) ?? []) {
-        const d = (inDegree.get(dep) ?? 0) - 1
-        inDegree.set(dep, d)
-        if (d === 0) queue.push(dep)
-      }
-    }
-
-    const unvisited = specs.filter((s) => !visited.has(s.id))
-    if (unvisited.length === 0) return []
-
-    return [
-      {
-        severity: 'blocking',
-        code: 'circular_dependency',
-        message: `Circular plan dependencies detected involving: ${unvisited.map((s) => labels.get(s.id) ?? s.id).join(', ')}`,
-      },
-    ]
-  }
-}
-
-export const planCoordinationService = new PlanCoordinationService()

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

@@ -1,284 +0,0 @@
-import { PlanArtifactSchema, PlanCycleRecordSchema, PlanRunSchema } from '@lota-sdk/shared'
-import type {
-  CarryForwardPolicy,
-  CycleSchedule,
-  PlanArtifactRecord,
-  PlanCycleRecord,
-  PlanDraft,
-  PlanRunStatus,
-  PlanScheduleSpec,
-  PlanTemplateRecord,
-} from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { planSchedulerService } from './plan-scheduler.service'
-import { planTemplateService } from './plan-template.service'
-
-const TERMINAL_RUN_STATUSES: ReadonlySet<PlanRunStatus> = new Set(['completed', 'failed', 'aborted'])
-
-function cycleScheduleToSpec(schedule: CycleSchedule): PlanScheduleSpec {
-  const startAt = schedule.startAt ? new Date(schedule.startAt) : undefined
-  const isFutureStart = startAt && startAt.getTime() > Date.now()
-
-  if (isFutureStart) {
-    return { type: 'absolute', at: startAt.toISOString(), missedPolicy: 'run-immediately' }
-  }
-
-  const cron = frequencyToCron(schedule.frequency, schedule.customIntervalMs)
-  if (cron) {
-    return { type: 'cron', cron, missedPolicy: 'run-immediately' }
-  }
-
-  if (schedule.frequency === 'biweekly') {
-    return { type: 'monitoring', intervalMs: 14 * 24 * 60 * 60 * 1000, missedPolicy: 'run-immediately' }
-  }
-
-  if (schedule.frequency === 'custom' && schedule.customIntervalMs) {
-    return { type: 'monitoring', intervalMs: schedule.customIntervalMs, missedPolicy: 'run-immediately' }
-  }
-
-  return { type: 'cron', cron: '0 0 * * *', missedPolicy: 'run-immediately' }
-}
-
-function frequencyToCron(frequency: CycleSchedule['frequency'], _customIntervalMs?: number): string | null {
-  switch (frequency) {
-    case 'daily':
-      return '0 0 * * *'
-    case 'weekly':
-      return '0 0 * * 1'
-    case 'monthly':
-      return '0 0 1 * *'
-    case 'quarterly':
-      return '0 0 1 */3 *'
-    case 'biweekly':
-    case 'custom':
-      return null
-  }
-}
-
-class PlanCycleService {
-  cycleScheduleToSpec = cycleScheduleToSpec
-
-  async createCycle(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    templateId: RecordIdInput
-    name: string
-    schedule: CycleSchedule
-    carryForwardPolicy?: CarryForwardPolicy
-    leadAgentId: string
-  }): Promise<PlanCycleRecord> {
-    const now = new Date()
-
-    const cycle = await databaseService.create(
-      TABLES.PLAN_CYCLE,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-        templateId: ensureRecordId(params.templateId, TABLES.PLAN_TEMPLATE),
-        name: params.name,
-        schedule: params.schedule,
-        carryForwardPolicy: params.carryForwardPolicy ?? 'incomplete-only',
-        status: 'active',
-        currentIteration: 0,
-        createdAt: now,
-      },
-      PlanCycleRecordSchema,
-    )
-
-    const createResult = await planTemplateService.instantiate({
-      templateId: params.templateId,
-      organizationId: params.organizationId,
-      threadId: params.threadId,
-      leadAgentId: params.leadAgentId,
-    })
-
-    const createdRunId = createResult.plan?.runId
-
-    const scheduleSpec = cycleScheduleToSpec(params.schedule)
-    const scheduleRecord = await planSchedulerService.createSchedule({
-      organizationId: params.organizationId,
-      threadId: params.threadId,
-      ...(createdRunId ? { runId: ensureRecordId(createdRunId, TABLES.PLAN_RUN) } : {}),
-      scheduleSpec,
-    })
-
-    const updated = await databaseService.update(
-      TABLES.PLAN_CYCLE,
-      ensureRecordId(cycle.id, TABLES.PLAN_CYCLE),
-      {
-        scheduleId: ensureRecordId(scheduleRecord.id, TABLES.PLAN_SCHEDULE),
-        ...(createdRunId ? { currentRunId: ensureRecordId(createdRunId, TABLES.PLAN_RUN) } : {}),
-        currentIteration: 1,
-      },
-      PlanCycleRecordSchema,
-    )
-
-    return updated ?? cycle
-  }
-
-  async advanceCycle(cycleId: RecordIdInput): Promise<void> {
-    const cycle = await this.getCycle(cycleId)
-    if (!cycle) {
-      throw new Error(`Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`)
-    }
-
-    if (cycle.status !== 'active') {
-      return
-    }
-
-    if (cycle.currentRunId) {
-      const runRecord = await databaseService.findOne(
-        TABLES.PLAN_RUN,
-        { id: ensureRecordId(cycle.currentRunId, TABLES.PLAN_RUN) },
-        PlanRunSchema,
-      )
-      if (runRecord && !TERMINAL_RUN_STATUSES.has(runRecord.status)) {
-        return
-      }
-    }
-
-    const template = await planTemplateService.getTemplate(cycle.templateId)
-    if (!template) {
-      throw new Error(`Template not found for cycle: ${recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE)}`)
-    }
-
-    const previousRunArtifacts = cycle.currentRunId
-      ? await databaseService.findMany(
-          TABLES.PLAN_ARTIFACT,
-          { runId: ensureRecordId(cycle.currentRunId, TABLES.PLAN_RUN) },
-          PlanArtifactSchema,
-          { orderBy: 'createdAt', orderDir: 'ASC' },
-        )
-      : []
-
-    const draft = this.buildCarryForwardDraft({ template, previousRunArtifacts, policy: cycle.carryForwardPolicy })
-
-    const result = await planTemplateService.instantiate({
-      templateId: cycle.templateId,
-      organizationId: cycle.organizationId,
-      threadId: cycle.threadId,
-      leadAgentId: 'system',
-      overrides: draft,
-    })
-
-    const newRunId = result.plan?.runId
-
-    await databaseService.update(
-      TABLES.PLAN_CYCLE,
-      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-      {
-        ...(newRunId ? { currentRunId: ensureRecordId(newRunId, TABLES.PLAN_RUN) } : {}),
-        currentIteration: cycle.currentIteration + 1,
-      },
-      PlanCycleRecordSchema,
-    )
-
-    // TODO: re-enable when playbook records exist and IDs align
-    // The previous implementation passed a PLAN_TEMPLATE record ID as a PLAYBOOK ID,
-    // causing refineFromCycle to always fail silently.
-  }
-
-  buildCarryForwardDraft(params: {
-    template: PlanTemplateRecord
-    previousRunArtifacts: PlanArtifactRecord[]
-    policy: CarryForwardPolicy
-  }): PlanDraft {
-    const draft = { ...params.template.draft }
-
-    if (params.policy === 'none' || params.previousRunArtifacts.length === 0) {
-      return draft
-    }
-
-    let artifacts: PlanArtifactRecord[]
-    if (params.policy === 'incomplete-only') {
-      artifacts = params.previousRunArtifacts.filter((a) => a.kind === 'markdown' || a.kind === 'json')
-    } else {
-      // 'all-pending'
-      artifacts = [...params.previousRunArtifacts]
-    }
-
-    if (artifacts.length > 0) {
-      const carryContext = artifacts.map((a) => `[carry-forward] ${a.name}: ${a.pointer}`)
-      draft.objective = `${draft.objective}\n\nCarry-forward context:\n${carryContext.join('\n')}`
-    }
-
-    return draft
-  }
-
-  async cancelCycle(cycleId: RecordIdInput): Promise<void> {
-    const cycle = await this.getCycle(cycleId)
-    if (!cycle) {
-      throw new Error(`Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`)
-    }
-
-    if (cycle.scheduleId) {
-      await planSchedulerService.cancelSchedule(cycle.scheduleId)
-    }
-
-    await databaseService.update(
-      TABLES.PLAN_CYCLE,
-      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-      { status: 'cancelled' },
-      PlanCycleRecordSchema,
-    )
-  }
-
-  async pauseCycle(cycleId: RecordIdInput): Promise<void> {
-    const cycle = await this.getCycle(cycleId)
-    if (!cycle) {
-      throw new Error(`Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`)
-    }
-
-    if (cycle.scheduleId) {
-      await planSchedulerService.pauseSchedule(cycle.scheduleId)
-    }
-
-    await databaseService.update(
-      TABLES.PLAN_CYCLE,
-      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-      { status: 'paused' },
-      PlanCycleRecordSchema,
-    )
-  }
-
-  async resumeCycle(cycleId: RecordIdInput): Promise<void> {
-    const cycle = await this.getCycle(cycleId)
-    if (!cycle) {
-      throw new Error(`Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`)
-    }
-
-    if (cycle.scheduleId) {
-      await planSchedulerService.resumeSchedule(cycle.scheduleId)
-    }
-
-    await databaseService.update(
-      TABLES.PLAN_CYCLE,
-      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-      { status: 'active' },
-      PlanCycleRecordSchema,
-    )
-  }
-
-  async listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_CYCLE,
-      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
-      PlanCycleRecordSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-  }
-
-  async getCycle(cycleId: RecordIdInput): Promise<PlanCycleRecord | null> {
-    return databaseService.findOne(
-      TABLES.PLAN_CYCLE,
-      { id: ensureRecordId(cycleId, TABLES.PLAN_CYCLE) },
-      PlanCycleRecordSchema,
-    )
-  }
-}
-
-export const planCycleService = new PlanCycleService()