@lota-sdk/core 0.1.15 → 0.1.16

package/src/services/monitoring-window.service.ts

@@ -0,0 +1,86 @@
+import type { MonitoringWindowConfig } from '@lota-sdk/shared'
+
+import { planSchedulerService } from './plan-scheduler.service'
+
+class MonitoringWindowService {
+  computeCheckTimes(config: MonitoringWindowConfig): { offsetMs: number; intervalMs: number }[] {
+    const times: { offsetMs: number; intervalMs: number }[] = []
+    let currentInterval = config.initialIntervalMs
+    let elapsed = 0
+    while (elapsed < config.durationMs) {
+      times.push({ offsetMs: elapsed, intervalMs: currentInterval })
+      elapsed += currentInterval
+      currentInterval = Math.min(currentInterval / config.decayFactor, config.maxIntervalMs)
+    }
+    return times
+  }
+
+  async startMonitoringWindow(params: {
+    runId: string
+    nodeId: string
+    config: MonitoringWindowConfig
+    organizationId: string
+    workstreamId: string
+  }): Promise<void> {
+    await planSchedulerService.createSchedule({
+      organizationId: params.organizationId,
+      workstreamId: params.workstreamId,
+      runId: params.runId,
+      nodeId: params.nodeId,
+      scheduleSpec: {
+        type: 'monitoring',
+        intervalMs: params.config.initialIntervalMs,
+        maxFires: this.computeCheckTimes(params.config).length,
+        missedPolicy: 'skip',
+      },
+    })
+  }
+
+  evaluateTermination(params: { samples: unknown[]; config: MonitoringWindowConfig }): boolean {
+    if (!params.config.earlyTermination) return false
+    if (params.samples.length < params.config.earlyTermination.minSamples) return false
+
+    const { condition, minSamples } = params.config.earlyTermination
+    const numericSamples = params.samples
+      .map((s) =>
+        typeof s === 'number'
+          ? s
+          : typeof s === 'object' && s !== null && 'value' in s
+            ? Number((s as Record<string, unknown>).value)
+            : NaN,
+      )
+      .filter((n) => !isNaN(n))
+
+    // No numeric data to evaluate against — don't terminate
+    if (numericSamples.length === 0) return false
+
+    if (condition === 'stable') {
+      const recent = numericSamples.slice(-minSamples)
+      if (recent.length < 2) return false
+      const mean = recent.reduce((a, b) => a + b, 0) / recent.length
+      const variance = recent.reduce((a, b) => a + (b - mean) ** 2, 0) / recent.length
+      const cv = mean !== 0 ? Math.sqrt(variance) / Math.abs(mean) : 0
+      return cv < 0.1
+    }
+
+    const thresholdMatch = condition.match(/^threshold:(\d+(?:\.\d+)?)$/)
+    if (thresholdMatch?.[1]) {
+      const threshold = parseFloat(thresholdMatch[1])
+      return numericSamples.some((v) => v >= threshold)
+    }
+
+    if (condition === 'trend:declining') {
+      const recent = numericSamples.slice(-minSamples)
+      return recent.length >= 2 && recent.every((v, i) => i === 0 || v <= (recent[i - 1] ?? v))
+    }
+
+    if (condition === 'trend:increasing') {
+      const recent = numericSamples.slice(-minSamples)
+      return recent.length >= 2 && recent.every((v, i) => i === 0 || v >= (recent[i - 1] ?? v))
+    }
+
+    throw new Error(`Unknown monitoring termination condition: ${condition}`)
+  }
+}
+
+export const monitoringWindowService = new MonitoringWindowService()

package/src/services/mutating-approval.service.ts

@@ -106,5 +106,5 @@ async function verifyMutatingApprovalForWorkstream(
 }
 
 export const verifyMutatingApproval: VerifyMutatingApproval = async (params) => {
-  return await verifyMutatingApprovalForWorkstream(ensureRecordId(params.workstreamId, TABLES.WORKSTREAM), params)
+  return verifyMutatingApprovalForWorkstream(ensureRecordId(params.workstreamId, TABLES.WORKSTREAM), params)
 }

package/src/services/node-workspace.service.ts

@@ -0,0 +1,155 @@
+import type {
+  NodeResultQuality,
+  PlanArtifactSubmission,
+  PlanNodeResult,
+  PlanNodeSpec,
+  PlanSchemaRegistry,
+  WriteIntent,
+  WriteIntentAction,
+} from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+
+export type WorkspaceEntryValidation = 'validated' | 'unvalidated'
+
+export interface WorkspaceEntry {
+  targetPath: string
+  action: WriteIntentAction
+  payload: unknown
+  validation: WorkspaceEntryValidation
+  stagedAt: Date
+}
+
+export interface NodeWorkspace {
+  nodeId: string
+  ctx: Readonly<{
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    schemaRegistry: PlanSchemaRegistry
+    nodeSpec: PlanNodeSpec
+  }>
+  work: Map<string, unknown>
+  sys: {
+    startedAt: Date
+    correctionCounts: Map<string, number>
+    writeLog: Array<{ targetPath: string; action: WriteIntentAction; timestamp: Date; result: 'accepted' | 'rejected' }>
+  }
+  deliverables: Map<string, WorkspaceEntry>
+}
+
+class NodeWorkspaceService {
+  initialize(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    schemaRegistry: PlanSchemaRegistry
+  }): NodeWorkspace {
+    const ctx = Object.freeze({
+      resolvedInput: params.resolvedInput,
+      inputArtifacts: params.inputArtifacts,
+      schemaRegistry: params.schemaRegistry,
+      nodeSpec: params.nodeSpec,
+    })
+
+    return {
+      nodeId: params.nodeSpec.id,
+      ctx,
+      work: new Map(),
+      sys: { startedAt: new Date(), correctionCounts: new Map(), writeLog: [] },
+      deliverables: new Map(),
+    }
+  }
+
+  stageWrite(workspace: NodeWorkspace, intent: WriteIntent, validation: WorkspaceEntryValidation): void {
+    const existing = workspace.deliverables.get(intent.targetPath)
+
+    if (intent.action === 'append' && existing && Array.isArray(existing.payload) && Array.isArray(intent.payload)) {
+      existing.payload = [...(existing.payload as unknown[]), ...intent.payload]
+      existing.action = intent.action
+      existing.validation = validation
+      existing.stagedAt = new Date()
+    } else {
+      workspace.deliverables.set(intent.targetPath, {
+        targetPath: intent.targetPath,
+        action: intent.action,
+        payload: intent.payload,
+        validation,
+        stagedAt: new Date(),
+      })
+    }
+
+    workspace.sys.writeLog.push({
+      targetPath: intent.targetPath,
+      action: intent.action,
+      timestamp: new Date(),
+      result: 'accepted',
+    })
+  }
+
+  finalize(workspace: NodeWorkspace): PlanNodeResult & { isComplete: boolean; quality: NodeResultQuality } {
+    const artifacts: PlanArtifactSubmission[] = []
+    let structuredOutput: Record<string, unknown> | undefined
+    let allValidated = true
+    const requiredNames = new Set(workspace.ctx.nodeSpec.deliverables.filter((d) => d.required).map((d) => d.name))
+    const presentRequired = new Set<string>()
+
+    for (const [targetPath, entry] of workspace.deliverables) {
+      if (entry.validation === 'unvalidated') {
+        allValidated = false
+      }
+
+      if (targetPath.startsWith('structuredOutput')) {
+        if (!structuredOutput) structuredOutput = {}
+        const subPath = targetPath.replace(/^structuredOutput\.?/, '')
+        if (subPath) {
+          structuredOutput[subPath] = entry.payload
+        } else {
+          structuredOutput =
+            typeof entry.payload === 'object' && entry.payload !== null && !Array.isArray(entry.payload)
+              ? (entry.payload as Record<string, unknown>)
+              : structuredOutput
+        }
+        continue
+      }
+
+      const spec = workspace.ctx.nodeSpec.deliverables.find((d) => d.name === targetPath)
+      if (!spec) {
+        serverLogger.warn`Write to unknown deliverable path "${targetPath}" in node ${workspace.nodeId} — skipping`
+        continue
+      }
+
+      if (requiredNames.has(targetPath)) {
+        presentRequired.add(targetPath)
+      }
+
+      artifacts.push({
+        name: spec.name,
+        kind: spec.kind,
+        pointer: `workspace://${workspace.nodeId}/${targetPath}`,
+        schemaRef: spec.schemaRef,
+        description: spec.description,
+        payload:
+          typeof entry.payload === 'string'
+            ? { content: entry.payload }
+            : typeof entry.payload === 'object' && entry.payload !== null
+              ? (entry.payload as Record<string, unknown> | unknown[])
+              : undefined,
+      })
+    }
+
+    const allRequiredPresent = requiredNames.size === presentRequired.size
+    const quality: NodeResultQuality = allRequiredPresent && allValidated ? 'full' : 'partial'
+    const isComplete = quality === 'full'
+
+    return { structuredOutput, artifacts, quality, isComplete }
+  }
+
+  cleanup(workspace: NodeWorkspace): void {
+    workspace.work.clear()
+    workspace.deliverables.clear()
+    workspace.sys.writeLog.length = 0
+    workspace.sys.correctionCounts.clear()
+  }
+}
+
+export const nodeWorkspaceService = new NodeWorkspaceService()

package/src/services/notification.service.ts

@@ -0,0 +1,39 @@
+import type { NotificationSeverity } from '@lota-sdk/shared'
+
+export interface NotificationPayload {
+  organizationId: string
+  workstreamId: string
+  runId?: string
+  nodeId?: string
+  severity: NotificationSeverity
+  title: string
+  body: string
+  dedupeKey?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface NotificationService {
+  notify(payload: NotificationPayload): Promise<void>
+  remind(payload: NotificationPayload): Promise<void>
+  escalate(payload: NotificationPayload): Promise<void>
+}
+
+export class NoOpNotificationService implements NotificationService {
+  async notify(_payload: NotificationPayload): Promise<void> {}
+  async remind(_payload: NotificationPayload): Promise<void> {}
+  async escalate(_payload: NotificationPayload): Promise<void> {}
+}
+
+let _notificationService: NotificationService | null = null
+
+export function configureNotificationService(service: NotificationService | null): void {
+  _notificationService = service
+}
+
+export function getNotificationService(): NotificationService {
+  if (_notificationService === null) {
+    throw new Error('Notification service is not configured.')
+  }
+
+  return _notificationService
+}

package/src/services/organization-member.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared'
+import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'
@@ -8,9 +8,9 @@ import { TABLES } from '../db/tables'
 import { toIsoDateTimeString } from '../utils/date-time'
 
 const organizationMemberRecordSchema = z.object({
-  id: z.unknown(),
-  in: z.unknown(),
-  out: z.unknown(),
+  id: recordIdSchema,
+  in: recordIdSchema,
+  out: recordIdSchema,
   role: z.string(),
   createdAt: z.coerce.date(),
 })
@@ -91,6 +91,13 @@ class OrganizationMemberService extends BaseService<typeof organizationMemberRec
     )
   }
 
+  async getMembership(userId: RecordIdInput, organizationId: RecordIdInput): Promise<SdkOrganizationMember | null> {
+    const userRef = ensureRecordId(userId, TABLES.USER)
+    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
+    const record = (await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })).at(0)
+    return record ? this.toPublic(record) : null
+  }
+
   async isMember(userId: RecordIdInput, organizationId: RecordIdInput): Promise<boolean> {
     const userRef = ensureRecordId(userId, TABLES.USER)
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)

package/src/services/organization.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared'
+import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'
@@ -9,12 +9,12 @@ import { TABLES } from '../db/tables'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 
 const organizationRecordSchema = z.object({
-  id: z.unknown(),
+  id: recordIdSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.coerce.date().optional(),
   regularChatDigestLastWorkstreamCursorId: z.string().optional(),
   skillExtractionLastCursorId: z.string().optional(),
-  skillExtractionLastCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
 })
@@ -86,7 +86,7 @@ class OrganizationService extends BaseService<typeof organizationRecordSchema> {
   }
 
   async getOrganizationRecord(organizationId: RecordIdRef): Promise<SdkOrganizationRecord> {
-    return await this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
+    return this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
   }
 
   async updateOrganization(organizationId: RecordIdInput, params: { name: string }): Promise<SdkOrganization> {