@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/plan-agent-heartbeat.service.ts

@@ -1,136 +0,0 @@
-import { serverLogger } from '../config/logger'
-import { ensureRecordId } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import { getRedisConnection, withRedisLeaseLock } from '../redis'
-import { resolvePlanNodeExecutionVisibility } from '../runtime/execution-plan-visibility'
-import { planAgentQueryService } from './plan-agent-query.service'
-import { planExecutorService } from './plan-executor.service'
-import { planRunService } from './plan-run.service'
-import { threadService } from './thread.service'
-
-const PLAN_AGENT_HEARTBEAT_LOCK_TTL_MS = 300_000
-const PLAN_AGENT_HEARTBEAT_LOCK_REFRESH_MS = 20_000
-
-function buildHeartbeatLockKey(runId: string, nodeId: string): string {
-  return `plan-agent-heartbeat:${runId}:${nodeId}`
-}
-
-function buildWakeDedupeKey(params: {
-  organizationId: string
-  threadId: string
-  runId: string
-  nodeId: string
-  agentId: string
-}) {
-  return `${params.organizationId}:${params.threadId}:${params.runId}:${params.nodeId}:${params.agentId}`
-}
-
-class PlanAgentHeartbeatService {
-  async wakeNode(params: {
-    organizationId: string
-    threadId: string
-    runId: string
-    nodeId: string
-    agentId: string
-    reason: string
-  }): Promise<boolean> {
-    const threadRef = ensureRecordId(params.threadId, TABLES.THREAD)
-    await threadService.clearStaleActiveRunIfMissingFromRegistry(threadRef)
-    if (await threadService.getActiveRunId(threadRef)) {
-      return false
-    }
-
-    return withRedisLeaseLock(
-      {
-        redis: getRedisConnection(),
-        lockKey: buildHeartbeatLockKey(params.runId, params.nodeId),
-        lockTtlMs: PLAN_AGENT_HEARTBEAT_LOCK_TTL_MS,
-        refreshIntervalMs: PLAN_AGENT_HEARTBEAT_LOCK_REFRESH_MS,
-        label: 'plan agent heartbeat',
-        maxWaitMs: 5_000,
-        logger: serverLogger,
-      },
-      async () => {
-        await threadService.clearStaleActiveRunIfMissingFromRegistry(threadRef)
-        if (await threadService.hasActiveRunLease(threadRef)) {
-          return false
-        }
-        if (await threadService.getActiveRunId(threadRef)) {
-          return false
-        }
-
-        const run = await planRunService.getRunById(params.runId)
-        const spec = await planRunService.getPlanSpecById(run.planSpecId)
-        const [nodeSpec, nodeRun] = await Promise.all([
-          planRunService.getNodeSpecByNodeId(spec.id, params.nodeId),
-          planRunService.getNodeRunByNodeId(run.id, params.nodeId),
-        ])
-
-        if (nodeSpec.owner.executorType !== 'agent' || nodeSpec.owner.ref !== params.agentId) {
-          return false
-        }
-
-        const visibility = resolvePlanNodeExecutionVisibility(spec, nodeSpec)
-        if (visibility !== 'visible') {
-          return false
-        }
-
-        if (nodeRun.status !== 'running' && nodeRun.status !== 'ready') {
-          return false
-        }
-
-        if (nodeRun.status === 'ready' && run.currentNodeId === params.nodeId) {
-          await planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId })
-        }
-
-        const { triggerPlanNodeTurn } = await import('./thread-turn')
-
-        await triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId })
-        return true
-      },
-    )
-  }
-
-  async sweep(params?: { organizationId?: string }): Promise<void> {
-    const { enqueuePlanAgentHeartbeatWake } = await import('../queues/plan-agent-heartbeat.queue')
-    const [actionable, recentlyUnblocked, approachingDeadlines] = await Promise.all([
-      planAgentQueryService.getActionableNodesForAgent({ organizationId: params?.organizationId }),
-      planAgentQueryService.getRecentlyUnblockedNodes({ organizationId: params?.organizationId }),
-      planAgentQueryService.getApproachingDeadlines({ organizationId: params?.organizationId, withinMinutes: 60 }),
-    ])
-
-    const wakeTargets = new Map<
-      string,
-      { organizationId: string; threadId: string; runId: string; nodeId: string; agentId: string; reason: string }
-    >()
-
-    for (const node of actionable) {
-      wakeTargets.set(buildWakeDedupeKey(node), { ...node, reason: 'heartbeat-actionable' })
-    }
-
-    for (const node of recentlyUnblocked) {
-      wakeTargets.set(buildWakeDedupeKey(node), { ...node, reason: node.sourceEventType })
-    }
-
-    for (const node of approachingDeadlines) {
-      if (!node.agentId || node.visibility !== 'visible') {
-        continue
-      }
-      const wakeTarget = {
-        organizationId: node.organizationId,
-        threadId: node.threadId,
-        runId: node.runId,
-        nodeId: node.nodeId,
-        agentId: node.agentId,
-        reason: `deadline-${node.status}`,
-      }
-      wakeTargets.set(buildWakeDedupeKey(wakeTarget), wakeTarget)
-    }
-
-    for (const target of wakeTargets.values()) {
-      await enqueuePlanAgentHeartbeatWake(target)
-    }
-  }
-}
-
-export const planAgentHeartbeatService = new PlanAgentHeartbeatService()

package/src/services/plan-agent-query.service.ts

@@ -1,267 +0,0 @@
-import type { PlanExecutionVisibility, PlanNodeSpecRecord, PlanRunRecord, PlanSpecRecord } from '@lota-sdk/shared'
-import { PlanRunSchema } from '@lota-sdk/shared'
-import { BoundQuery } from 'surrealdb'
-
-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 { resolvePlanNodeExecutionVisibility } from '../runtime/execution-plan-visibility'
-import { planDeadlineService } from './plan-deadline.service'
-import { planRunService } from './plan-run.service'
-
-const ACTIVE_PLAN_RUN_STATUSES = ['running', 'awaiting-human', 'blocked'] as const
-const ACTIONABLE_NODE_STATUSES = new Set(['ready', 'running'])
-const DEADLINE_TRACKED_NODE_STATUSES = new Set(['ready', 'running', 'awaiting-human'])
-
-export interface ActionablePlanAgentNode {
-  organizationId: string
-  threadId: string
-  runId: string
-  nodeId: string
-  agentId: string
-  status: 'ready' | 'running'
-  visibility: PlanExecutionVisibility
-}
-
-export interface ApproachingDeadlineNode {
-  organizationId: string
-  threadId: string
-  runId: string
-  nodeId: string
-  agentId?: string
-  visibility?: PlanExecutionVisibility
-  dueAt?: string
-  status: 'warning' | 'escalated' | 'missed'
-  nextTriggerAt?: string | null
-}
-
-export interface RecentlyUnblockedNode {
-  organizationId: string
-  threadId: string
-  runId: string
-  nodeId: string
-  agentId: string
-  visibility: PlanExecutionVisibility
-  unblockedAt: string
-  sourceEventType: 'node-unblocked' | 'approval-resolved'
-}
-
-function isVisibleAgentNode(params: {
-  nodeSpec: PlanNodeSpecRecord
-  spec: PlanSpecRecord
-}): { agentId: string; visibility: PlanExecutionVisibility } | null {
-  if (params.nodeSpec.owner.executorType !== 'agent') {
-    return null
-  }
-
-  const visibility = resolvePlanNodeExecutionVisibility(params.spec, params.nodeSpec)
-  const isVisible = visibility === 'visible'
-  if (!isVisible) {
-    return null
-  }
-
-  return { agentId: params.nodeSpec.owner.ref, visibility }
-}
-
-class PlanAgentQueryService {
-  async getActionableNodesForAgent(params: {
-    agentId?: string
-    organizationId?: RecordIdInput
-  }): Promise<ActionablePlanAgentNode[]> {
-    const runs = await this.listActiveRuns(params.organizationId)
-    const actionable: ActionablePlanAgentNode[] = []
-
-    for (const run of runs) {
-      const spec = await planRunService.getPlanSpecById(run.planSpecId)
-
-      // Graph-full plans can have multiple visible agent nodes running in parallel
-      if (spec.executionMode === 'graph-full') {
-        const [nodeSpecs, nodeRuns] = await Promise.all([
-          planRunService.listNodeSpecs(spec.id),
-          planRunService.listNodeRuns(run.id),
-        ])
-        for (const nodeRun of nodeRuns) {
-          if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) continue
-          const nodeSpec = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
-          if (!nodeSpec) continue
-          const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
-          if (!visibleTarget) continue
-          if (params.agentId && params.agentId !== visibleTarget.agentId) continue
-          actionable.push({
-            organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-            threadId: recordIdToString(run.threadId, TABLES.THREAD),
-            runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-            nodeId: nodeSpec.nodeId,
-            agentId: visibleTarget.agentId,
-            status: nodeRun.status as 'ready' | 'running',
-            visibility: visibleTarget.visibility,
-          })
-        }
-        continue
-      }
-
-      // Linear plans: only the current node is actionable
-      const currentNodeId = run.currentNodeId
-      if (!currentNodeId) {
-        continue
-      }
-
-      const [nodeSpec, nodeRun] = await Promise.all([
-        planRunService.getNodeSpecByNodeId(spec.id, currentNodeId),
-        planRunService.getNodeRunByNodeId(run.id, currentNodeId),
-      ])
-      if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) {
-        continue
-      }
-
-      const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
-      if (!visibleTarget) {
-        continue
-      }
-      if (params.agentId && params.agentId !== visibleTarget.agentId) {
-        continue
-      }
-
-      actionable.push({
-        organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-        threadId: recordIdToString(run.threadId, TABLES.THREAD),
-        runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-        nodeId: nodeSpec.nodeId,
-        agentId: visibleTarget.agentId,
-        status: nodeRun.status as 'ready' | 'running',
-        visibility: visibleTarget.visibility,
-      })
-    }
-
-    return actionable
-  }
-
-  async getApproachingDeadlines(params?: {
-    organizationId?: RecordIdInput
-    withinMinutes?: number
-  }): Promise<ApproachingDeadlineNode[]> {
-    const now = new Date()
-    const maxWindowMs = (params?.withinMinutes ?? 60) * 60_000
-    const runs = await this.listActiveRuns(params?.organizationId)
-    const matches: ApproachingDeadlineNode[] = []
-
-    for (const run of runs) {
-      const spec = await planRunService.getPlanSpecById(run.planSpecId)
-      const [nodeSpecs, nodeRuns] = await Promise.all([
-        planRunService.listNodeSpecs(spec.id),
-        planRunService.listNodeRuns(run.id),
-      ])
-      const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
-
-      for (const nodeSpec of nodeSpecs) {
-        const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
-        if (!nodeRun || !nodeSpec.deadline || !DEADLINE_TRACKED_NODE_STATUSES.has(nodeRun.status)) {
-          continue
-        }
-
-        const evaluation = planDeadlineService.evaluateDeadline({
-          deadline: nodeSpec.deadline,
-          nodeStartedAt: new Date(nodeRun.startedAt ?? nodeRun.createdAt),
-          now,
-        })
-        if (evaluation.status === 'ok') {
-          continue
-        }
-
-        const nextTriggerTime = evaluation.nextTriggerAt?.getTime()
-        if (nextTriggerTime && nextTriggerTime - now.getTime() > maxWindowMs && evaluation.status !== 'missed') {
-          continue
-        }
-
-        const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
-        matches.push({
-          organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-          threadId: recordIdToString(run.threadId, TABLES.THREAD),
-          runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-          nodeId: nodeSpec.nodeId,
-          ...(visibleTarget ? { agentId: visibleTarget.agentId, visibility: visibleTarget.visibility } : {}),
-          ...(nodeSpec.deadline.dueAt ? { dueAt: nodeSpec.deadline.dueAt } : {}),
-          status: evaluation.status,
-          nextTriggerAt: evaluation.nextTriggerAt?.toISOString() ?? null,
-        })
-      }
-    }
-
-    return matches
-  }
-
-  async getRecentlyUnblockedNodes(params?: {
-    organizationId?: RecordIdInput
-    sinceMinutes?: number
-    agentId?: string
-  }): Promise<RecentlyUnblockedNode[]> {
-    const since = new Date(Date.now() - (params?.sinceMinutes ?? 30) * 60_000)
-    const runs = await this.listActiveRuns(params?.organizationId)
-    const matches: RecentlyUnblockedNode[] = []
-
-    for (const run of runs) {
-      const spec = await planRunService.getPlanSpecById(run.planSpecId)
-      const [nodeSpecs, events] = await Promise.all([
-        planRunService.listNodeSpecs(spec.id),
-        planRunService.listEvents(run.id, 200),
-      ])
-      const nodeSpecsById = new Map(nodeSpecs.map((nodeSpec) => [nodeSpec.nodeId, nodeSpec]))
-
-      for (const event of events) {
-        if (
-          (event.eventType !== 'node-unblocked' && event.eventType !== 'approval-resolved') ||
-          !event.nodeId ||
-          new Date(event.createdAt).getTime() < since.getTime()
-        ) {
-          continue
-        }
-
-        const currentNodeId = run.currentNodeId ?? event.nodeId
-        const nodeSpec = nodeSpecsById.get(currentNodeId)
-        if (!nodeSpec) {
-          continue
-        }
-
-        const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
-        if (!visibleTarget) {
-          continue
-        }
-        if (params?.agentId && params.agentId !== visibleTarget.agentId) {
-          continue
-        }
-
-        matches.push({
-          organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-          threadId: recordIdToString(run.threadId, TABLES.THREAD),
-          runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-          nodeId: currentNodeId,
-          agentId: visibleTarget.agentId,
-          visibility: visibleTarget.visibility,
-          unblockedAt: new Date(event.createdAt).toISOString(),
-          sourceEventType: event.eventType,
-        })
-      }
-    }
-
-    return matches
-  }
-
-  private async listActiveRuns(organizationId?: RecordIdInput): Promise<PlanRunRecord[]> {
-    const bindings = {
-      statuses: [...ACTIVE_PLAN_RUN_STATUSES],
-      ...(organizationId ? { organizationId: ensureRecordId(organizationId, TABLES.ORGANIZATION) } : {}),
-    }
-
-    const whereOrganization = organizationId ? ' AND organizationId = $organizationId' : ''
-    return databaseService.queryMany(
-      new BoundQuery(
-        `SELECT * FROM ${TABLES.PLAN_RUN} WHERE status INSIDE $statuses${whereOrganization} ORDER BY updatedAt DESC`,
-        bindings,
-      ),
-      PlanRunSchema,
-    )
-  }
-}
-
-export const planAgentQueryService = new PlanAgentQueryService()

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

@@ -1,83 +0,0 @@
-import { PlanApprovalSchema } from '@lota-sdk/shared'
-import type { PlanApprovalRecord, PlanApprovalStatus } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
-import type { DatabaseTransaction } from '../db/service'
-import { TABLES } from '../db/tables'
-
-class PlanApprovalService {
-  async createPendingApproval(params: {
-    tx: DatabaseTransaction
-    runId: RecordIdInput
-    nodeRunId: RecordIdInput
-    nodeId: string
-    requestedBy: string
-    presented: Record<string, unknown>
-  }): Promise<PlanApprovalRecord> {
-    const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
-    const created = await params.tx
-      .create(approvalId)
-      .content({
-        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-        nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
-        nodeId: params.nodeId,
-        status: 'pending',
-        requestedBy: params.requestedBy,
-        presented: params.presented,
-        requiredEdits: [],
-      })
-      .output('after')
-
-    return PlanApprovalSchema.parse(created)
-  }
-
-  async getApprovalById(approvalId: RecordIdInput): Promise<PlanApprovalRecord | null> {
-    return databaseService.findOne(
-      TABLES.PLAN_APPROVAL,
-      { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) },
-      PlanApprovalSchema,
-    )
-  }
-
-  async getPendingApprovalForNodeRun(nodeRunId: RecordIdInput): Promise<PlanApprovalRecord | null> {
-    const approvals = await databaseService.findMany(
-      TABLES.PLAN_APPROVAL,
-      { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
-      PlanApprovalSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
-    )
-
-    return approvals.at(0) ?? null
-  }
-
-  async updateApprovalResponse(params: {
-    tx: DatabaseTransaction
-    approval: PlanApprovalRecord
-    status: PlanApprovalStatus
-    response: Record<string, unknown>
-    respondedBy: string
-    approvalMessageId?: string
-    comments?: string
-    requiredEdits?: string[]
-  }): Promise<PlanApprovalRecord> {
-    const updated = await params.tx
-      .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
-      .merge({
-        status: params.status,
-        response: params.response,
-        respondedBy: params.respondedBy,
-        ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
-        ...(params.comments ? { comments: params.comments } : {}),
-        ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
-        respondedAt: new Date(),
-      })
-      .output('after')
-
-    return PlanApprovalSchema.parse(updated)
-  }
-}
-
-export const planApprovalService = new PlanApprovalService()

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

@@ -1,50 +0,0 @@
-import { PlanArtifactSchema } from '@lota-sdk/shared'
-import type { PlanArtifactRecord, PlanArtifactSubmission } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId } from '../db/record-id'
-import type { DatabaseTransaction } from '../db/service'
-import { TABLES } from '../db/tables'
-
-class PlanArtifactService {
-  async persistArtifacts(params: {
-    tx: DatabaseTransaction
-    runId: RecordIdInput
-    attemptId: RecordIdInput
-    nodeId: string
-    artifacts: PlanArtifactSubmission[]
-  }): Promise<PlanArtifactRecord[]> {
-    const records: PlanArtifactRecord[] = []
-
-    // Sequential: SurrealDB transactions require ordered operations
-    for (const artifact of params.artifacts) {
-      const artifactId = new RecordId(TABLES.PLAN_ARTIFACT, Bun.randomUUIDv7())
-      const created = await params.tx
-        .create(artifactId)
-        .content({
-          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-          attemptId: ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT),
-          nodeId: params.nodeId,
-          name: artifact.name,
-          kind: artifact.kind,
-          pointer: artifact.publishedArtifactId
-            ? `venturos://artifact/${artifact.publishedArtifactId}`
-            : `artifact://${params.nodeId}/${artifact.name}`,
-          ...(artifact.description ? { description: artifact.description } : {}),
-          ...(artifact.content ? { content: artifact.content } : {}),
-          ...(artifact.payload ? { payload: artifact.payload } : {}),
-          ...(artifact.publishedArtifactId
-            ? { publishedArtifactId: ensureRecordId(artifact.publishedArtifactId, TABLES.ARTIFACT) }
-            : {}),
-        })
-        .output('after')
-
-      records.push(PlanArtifactSchema.parse(created))
-    }
-
-    return records
-  }
-}
-
-export const planArtifactService = new PlanArtifactService()

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

@@ -1,67 +0,0 @@
-import type { PlanDraft } from '@lota-sdk/shared'
-
-import { isExecutableConditionExpression } from './plan-helpers'
-
-function buildImplicitLinearEdges(draft: PlanDraft) {
-  if (draft.edges.length > 0 || draft.nodes.length <= 1) {
-    return draft.edges
-  }
-
-  return draft.nodes
-    .slice(0, -1)
-    .map((node, index) => ({
-      id: `edge_${node.id}_to_${draft.nodes[index + 1]?.id ?? index + 1}`,
-      source: node.id,
-      target: draft.nodes[index + 1].id,
-      map: {},
-    }))
-}
-
-class PlanBuilderService {
-  structureDesign(draft: PlanDraft): PlanDraft {
-    return {
-      ...draft,
-      executionMode: draft.executionMode ?? 'linear',
-      edges: buildImplicitLinearEdges(draft),
-      entryNodeIds: draft.entryNodeIds && draft.entryNodeIds.length > 0 ? draft.entryNodeIds : [draft.nodes[0].id],
-    }
-  }
-
-  semanticCompletion(draft: PlanDraft): PlanDraft {
-    return {
-      ...draft,
-      nodes: draft.nodes.map((node) => ({
-        ...node,
-        deliverables: [...node.deliverables],
-        successCriteria: [...node.successCriteria],
-        completionChecks: [...node.completionChecks],
-        failurePolicy: [...node.failurePolicy],
-        retryPolicy: { ...node.retryPolicy, retryOn: [...node.retryPolicy.retryOn] },
-        toolPolicy: { allow: [...node.toolPolicy.allow], deny: [...node.toolPolicy.deny] },
-        contextPolicy: {
-          retrievalScopes: [...node.contextPolicy.retrievalScopes],
-          attachmentPolicy: node.contextPolicy.attachmentPolicy,
-          webPolicy: node.contextPolicy.webPolicy,
-        },
-      })),
-      edges: draft.edges.map((edge) => {
-        const normalizedWhen = edge.when?.trim()
-        const { when: _when, ...edgeWithoutWhen } = edge
-        return {
-          ...edgeWithoutWhen,
-          ...(normalizedWhen && isExecutableConditionExpression(normalizedWhen) ? { when: normalizedWhen } : {}),
-          map: { ...edge.map },
-        }
-      }),
-      schemas: structuredClone(draft.schemas),
-      entryNodeIds: [...(draft.entryNodeIds ?? [])],
-    }
-  }
-
-  prepareDraft(draft: PlanDraft): PlanDraft {
-    const withStructure = this.structureDesign(draft)
-    return this.semanticCompletion(withStructure)
-  }
-}
-
-export const planBuilderService = new PlanBuilderService()

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

@@ -1,81 +0,0 @@
-import { PlanCheckpointSchema } from '@lota-sdk/shared'
-import type { PlanCheckpointRecord, PlanRunStatus } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
-
-import { serverLogger } from '../config/logger'
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import type { DatabaseTransaction } from '../db/service'
-import { TABLES } from '../db/tables'
-import { planWorkspaceService } from './plan-workspace.service'
-
-class PlanCheckpointService {
-  async createCheckpoint(params: {
-    tx: DatabaseTransaction
-    runId: RecordIdInput
-    sequence: number
-    runStatus: PlanRunStatus
-    readyNodeIds: string[]
-    activeNodeIds: string[]
-    artifactIds: RecordIdInput[]
-    lastCompletedNodeIds: string[]
-    snapshot: Record<string, unknown>
-    includeWorkspace?: boolean
-  }): Promise<PlanCheckpointRecord> {
-    const snapshotData = { ...params.snapshot }
-
-    if (params.includeWorkspace) {
-      const runIdStr = recordIdToString(params.runId, TABLES.PLAN_RUN)
-      const workspaceSnapshot = await planWorkspaceService
-        .currentRead({ runId: runIdStr })
-        .then((all) => {
-          // Filter to entries at or before the checkpoint sequence
-          const filtered: Record<string, unknown> = {}
-          for (const [key, entry] of Object.entries(all)) {
-            if (entry.writeSequence <= params.sequence) {
-              filtered[key] = entry
-            }
-          }
-          return filtered
-        })
-        .catch((error) => {
-          serverLogger.warn`Workspace snapshot failed for run ${runIdStr}: ${error}`
-          return {}
-        })
-      if (Object.keys(workspaceSnapshot).length > 0) {
-        snapshotData.workspaceSnapshot = workspaceSnapshot
-      }
-    }
-
-    const checkpointId = new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7())
-    const created = await params.tx
-      .create(checkpointId)
-      .content({
-        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-        sequence: params.sequence,
-        runStatus: params.runStatus,
-        readyNodeIds: [...params.readyNodeIds],
-        activeNodeIds: [...params.activeNodeIds],
-        artifactIds: params.artifactIds.map((artifactId) => ensureRecordId(artifactId, TABLES.PLAN_ARTIFACT)),
-        lastCompletedNodeIds: [...params.lastCompletedNodeIds],
-        snapshot: snapshotData,
-      })
-      .output('after')
-
-    return PlanCheckpointSchema.parse(created)
-  }
-
-  async loadLatestForRun(runId: RecordIdInput): Promise<PlanCheckpointRecord | null> {
-    const checkpoints = await databaseService.findMany(
-      TABLES.PLAN_CHECKPOINT,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanCheckpointSchema,
-      { orderBy: 'sequence', orderDir: 'DESC', limit: 1 },
-    )
-
-    return checkpoints.at(0) ?? null
-  }
-}
-
-export const planCheckpointService = new PlanCheckpointService()