@lota-sdk/core 0.4.10 → 0.4.12

package/src/services/autonomous-job.service.ts

@@ -32,7 +32,8 @@ import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../effect/services'
-import type { AutonomousJobQueuePayload } from '../queues/autonomous-job.queue'
+import type { AutonomousJobQueuePayload, AutonomousJobQueueRuntime } from '../queues/autonomous-job.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { extractMessageText } from '../runtime/thread-chat-helpers'
 import { buildAutonomousAtJobId, encodeBullmqId } from '../utils/autonomous-job-ids'
@@ -49,12 +50,8 @@ import { ExecutionPlanServiceTag } from './execution-plan/execution-plan.service
 import type { makeQueueJobService } from './queue-job.service'
 import { QueueJobServiceTag } from './queue-job.service'
 import type { PreparedThreadTurnResult } from './thread/thread-turn'
-import type { ThreadTurnParams } from './thread/thread-turn-preparation.service'
 import type { makeThreadService } from './thread/thread.service'
 import { ThreadServiceTag } from './thread/thread.service'
-// runThreadTurnInBackground is imported dynamically below
-
-type ThreadTurnModule = { runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> }
 
 const AUTONOMOUS_JOB_QUEUE_NAME = 'autonomous-job'
 
@@ -312,27 +309,22 @@ function getRunRowEffect(
   })
 }
 
-function unscheduleRowEffect(row: AutonomousJobRow): Effect.Effect<void, AutonomousJobServiceError> {
+function unscheduleRowEffect(
+  deps: AutonomousJobDeps,
+  row: AutonomousJobRow,
+): Effect.Effect<void, AutonomousJobServiceError> {
   if (row.schedule.kind === 'at') {
     return Effect.gen(function* () {
-      const { removeAutonomousAtJob } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
       yield* effectTryPromise(
-        () => removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+        () => deps.autonomousJobQueue.removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
         'Failed to remove autonomous at-job.',
       )
     })
   }
 
   return Effect.gen(function* () {
-    const { removeAutonomousJobScheduler } = yield* effectTryPromise(
-      () => import('../queues/autonomous-job.queue'),
-      'Failed to load autonomous job queue helpers.',
-    )
     yield* effectTryPromise(
-      () => removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+      () => deps.autonomousJobQueue.removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
       'Failed to remove autonomous job scheduler.',
     )
   })
@@ -386,14 +378,9 @@ function scheduleRowEffect(
           })
         : createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
 
-      const { enqueueAutonomousJobRun } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
-
       const enqueueResult = yield* effectTryPromise(
         () =>
-          enqueueAutonomousJobRun({
+          deps.autonomousJobQueue.enqueueAutonomousJobRun({
             payload: {
               autonomousJobId: jobId,
               autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
@@ -428,13 +415,9 @@ function scheduleRowEffect(
   } else {
     const recurringSchedule = row.schedule
     return Effect.gen(function* () {
-      const { upsertAutonomousJobScheduler } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
-
       yield* effectTryPromise(
-        () => upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: recurringSchedule }),
+        () =>
+          deps.autonomousJobQueue.upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: recurringSchedule }),
         'Failed to upsert autonomous job scheduler.',
       )
 
@@ -564,7 +547,7 @@ function updateEffect(
   return Effect.gen(function* () {
     const parsed = UpdateAutonomousJobInputSchema.parse(input)
     const existing = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(existing)
+    yield* unscheduleRowEffect(deps, existing)
     const nextTitle = parsed.title
     if (typeof nextTitle === 'string' && compactWhitespace(nextTitle) !== compactWhitespace(existing.title)) {
       const title = nextTitle
@@ -616,7 +599,7 @@ function pauseEffect(
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(row)
+    yield* unscheduleRowEffect(deps, row)
     yield* effectTryPromise(
       () =>
         deps.db.update(
@@ -667,14 +650,10 @@ function runNowEffect(
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
     const queuedRun = yield* createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
-    const { enqueueAutonomousJobRun } = yield* effectTryPromise(
-      () => import('../queues/autonomous-job.queue'),
-      'Failed to load autonomous job queue helpers.',
-    )
 
     const enqueueResult = yield* effectTryPromise(
       () =>
-        enqueueAutonomousJobRun({
+        deps.autonomousJobQueue.enqueueAutonomousJobRun({
           payload: {
             autonomousJobId: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
             autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
@@ -710,7 +689,7 @@ function cancelEffect(
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(row)
+    yield* unscheduleRowEffect(deps, row)
     yield* effectTryPromise(
       () =>
         deps.db.update(
@@ -923,7 +902,7 @@ function failQueuedRunEffect(
     )
 
     if (autoPause || terminalOneShot) {
-      yield* unscheduleRowEffect(currentJobRow)
+      yield* unscheduleRowEffect(deps, currentJobRow)
     }
 
     yield* effectTryPromise(
@@ -967,7 +946,7 @@ function failQueuedRunEffect(
 function executeQueuedRunEffect(
   deps: AutonomousJobDeps,
   job: Job<AutonomousJobQueuePayload>,
-): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError> {
+): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError, unknown> {
   return Effect.gen(function* () {
     const autonomousJobRowRef = yield* Ref.make<AutonomousJobRow | null>(null)
     const runRowRef = yield* Ref.make<AutonomousJobRunRow | null>(null)
@@ -987,30 +966,34 @@ function executeQueuedRunEffect(
       yield* Ref.set(runRowRef, currentRunRow)
       const inputMessage = buildSyntheticUserMessage(currentJobRow.prompt)
 
-      const [thread, turnModule] = yield* Effect.all([
-        deps.thread
-          .getThread(currentJobRow.threadId)
-          .pipe(
-            Effect.mapError(
-              (cause) => new AutonomousJobServiceError({ message: 'Failed to load autonomous job thread.', cause }),
-            ),
+      const thread = yield* deps.thread
+        .getThread(currentJobRow.threadId)
+        .pipe(
+          Effect.mapError(
+            (cause) => new AutonomousJobServiceError({ message: 'Failed to load autonomous job thread.', cause }),
           ),
-        effectTryPromise<ThreadTurnModule>(() => import('./thread/thread-turn'), 'Failed to load thread turn runtime.'),
-      ])
+        )
 
-      const turnResult = yield* effectTryPromise(
-        () =>
-          turnModule.runThreadTurnInBackground({
-            thread,
-            threadRef: ensureRecordId(currentJobRow.threadId, TABLES.THREAD),
-            orgRef: ensureRecordId(currentJobRow.organizationId, TABLES.ORGANIZATION),
-            userRef: ensureRecordId(currentJobRow.ownerUserId, TABLES.USER),
-            userName: currentJobRow.ownerUserName,
-            agentIdOverride: currentJobRow.agentId,
-            inputMessage,
-          }),
-        'Failed to run autonomous job thread turn.',
-      )
+      const turnModule = yield* Effect.tryPromise({
+        try: () => import('./thread/thread-turn'),
+        catch: (cause) => new AutonomousJobServiceError({ message: 'Failed to load thread turn runtime.', cause }),
+      })
+
+      const turnResult = yield* turnModule
+        .runThreadTurnInBackground({
+          thread,
+          threadRef: ensureRecordId(currentJobRow.threadId, TABLES.THREAD),
+          orgRef: ensureRecordId(currentJobRow.organizationId, TABLES.ORGANIZATION),
+          userRef: ensureRecordId(currentJobRow.ownerUserId, TABLES.USER),
+          userName: currentJobRow.ownerUserName,
+          agentIdOverride: currentJobRow.agentId,
+          inputMessage,
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) => new AutonomousJobServiceError({ message: 'Failed to run autonomous job thread turn.', cause }),
+          ),
+        )
 
       const activePlan = yield* deps.executionPlan
         .getActivePlanForThread(currentJobRow.threadId)
@@ -1061,6 +1044,7 @@ interface AutonomousJobDeps {
   executionPlan: ReturnType<typeof makeExecutionPlanService>
   queueJob: ReturnType<typeof makeQueueJobService>
   thread: ReturnType<typeof makeThreadService>
+  autonomousJobQueue: AutonomousJobQueueRuntime
 }
 
 export function makeAutonomousJobService(deps: AutonomousJobDeps) {
@@ -1080,6 +1064,14 @@ export const AutonomousJobServiceLive = Layer.effect(
     const executionPlan = yield* ExecutionPlanServiceTag
     const queueJob = yield* QueueJobServiceTag
     const thread = yield* ThreadServiceTag
-    return makeAutonomousJobService({ db, config, executionPlan, queueJob, thread })
+    const queues = yield* LotaQueuesServiceTag
+    return makeAutonomousJobService({
+      db,
+      config,
+      executionPlan,
+      queueJob,
+      thread,
+      autonomousJobQueue: queues.autonomousJob,
+    })
   }),
 )

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

@@ -77,14 +77,12 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
               typeof thread.lastCompactedMessageId === 'string' ? thread.lastCompactedMessageId : undefined,
             )
 
-            const result = yield* Effect.tryPromise(() =>
-              contextCompactionRuntime.compactHistory({
-                summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
-                liveMessages,
-                tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
-                contextSize: params.contextSize,
-              }),
-            )
+            const result = yield* contextCompactionRuntime.compactHistory({
+              summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
+              liveMessages,
+              tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
+              contextSize: params.contextSize,
+            })
 
             if (!result.compacted || !result.lastCompactedMessageId) {
               return { compacted: false }
@@ -122,7 +120,7 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
     })
 
   const compactMemoryBlockEffect = (params: { previousSummary: string; newEntriesText: string }) =>
-    Effect.tryPromise(() => contextCompactionRuntime.compactMemoryBlockSummary(params))
+    contextCompactionRuntime.compactMemoryBlockSummary(params)
 
   return {
     createSummaryMessage(summaryText: string) {

package/src/services/execution-plan/execution-plan-graph.ts

@@ -15,7 +15,6 @@ import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { ServiceError } from '../../effect/errors'
-import { runPromise } from '../../effect/runtime'
 import { nowDate } from '../../utils/date-time'
 import type { CompiledPlanNode } from '../plan/plan-compiler.service'
 import type { syncRunGraph } from '../plan/plan-executor-graph'
@@ -33,10 +32,10 @@ function parseRowOrFail<TSchema extends z.ZodTypeAny>(
 }
 
 type SyncRunGraphParams = Parameters<typeof syncRunGraph>[1]
-type SyncRunGraphResult = Awaited<ReturnType<typeof syncRunGraph>>
+type SyncRunGraphResult = ReturnType<typeof syncRunGraph>
 
 interface ExecutionPlanGraphExecutor {
-  syncRunGraph(params: SyncRunGraphParams): Promise<SyncRunGraphResult>
+  syncRunGraph(params: SyncRunGraphParams): SyncRunGraphResult
 }
 
 function buildNodeSpecCreateContent(compiledNode: CompiledPlanNode, planSpecId: RecordIdInput) {
@@ -148,131 +147,123 @@ export function createInitializedRunGraph(params: {
   runPatch?: { replacedRunId?: RecordIdInput }
   planExecutor: ExecutionPlanGraphExecutor
 }) {
-  return runPromise(
-    Effect.gen(function* () {
-      const nodeSpecs = yield* createNodeSpecs(params.tx, params.spec.id, params.nodes)
-      const runRaw = yield* params.tx
-        .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-          ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
-          leadAgentId: params.leadAgentId,
-          ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
-          status: params.requireApproval ? 'pending-approval' : 'running',
-          readyNodeIds: [],
-          failureCount: 0,
-          ...(params.runPatch?.replacedRunId
-            ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
-            : {}),
-          ...(params.requireApproval ? {} : { startedAt: nowDate() }),
+  return Effect.gen(function* () {
+    const nodeSpecs = yield* createNodeSpecs(params.tx, params.spec.id, params.nodes)
+    const runRaw = yield* params.tx
+      .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+        ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
+        leadAgentId: params.leadAgentId,
+        ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
+        status: params.requireApproval ? 'pending-approval' : 'running',
+        readyNodeIds: [],
+        failureCount: 0,
+        ...(params.runPatch?.replacedRunId
+          ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
+          : {}),
+        ...(params.requireApproval ? {} : { startedAt: nowDate() }),
+      })
+      .output('after')
+    const run = yield* parseRowOrFail(PlanRunSchema, runRaw, 'createInitializedRunGraph:run')
+
+    const nodeRuns = yield* createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
+    const synced = params.requireApproval
+      ? { run, nodeRuns }
+      : yield* params.planExecutor.syncRunGraph({
+          tx: params.tx,
+          run,
+          spec: params.spec,
+          nodeSpecs,
+          nodeRuns,
+          artifacts: [],
+          emittedBy: params.leadAgentId,
+          capturedEvents: params.emittedEvents,
         })
-        .output('after')
-      const run = yield* parseRowOrFail(PlanRunSchema, runRaw, 'createInitializedRunGraph:run')
 
-      const nodeRuns = yield* createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
-      const synced = params.requireApproval
-        ? { run, nodeRuns }
-        : yield* Effect.tryPromise(() =>
-            params.planExecutor.syncRunGraph({
-              tx: params.tx,
-              run,
-              spec: params.spec,
-              nodeSpecs,
-              nodeRuns,
-              artifacts: [],
-              emittedBy: params.leadAgentId,
-              capturedEvents: params.emittedEvents,
-            }),
-          )
+    const event = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+        eventType: params.createdEventType,
+        message: params.createdEventMessage,
+        emittedBy: params.leadAgentId,
+        detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
+      })
+      .output('after')
+    params.emittedEvents.push(yield* parseRowOrFail(PlanEventSchema, event, 'createInitializedRunGraph:createdEvent'))
 
-      const event = yield* params.tx
+    if (params.requireApproval) {
+      const pendingApprovalEvent = yield* params.tx
         .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
         .content({
           planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
           runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          eventType: params.createdEventType,
-          message: params.createdEventMessage,
+          eventType: 'plan-pending-approval',
+          toStatus: synced.run.status,
+          message: `Execution plan "${params.spec.title}" is pending approval.`,
           emittedBy: params.leadAgentId,
           detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
         })
         .output('after')
-      params.emittedEvents.push(yield* parseRowOrFail(PlanEventSchema, event, 'createInitializedRunGraph:createdEvent'))
-
-      if (params.requireApproval) {
-        const pendingApprovalEvent = yield* params.tx
-          .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-          .content({
-            planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-            eventType: 'plan-pending-approval',
-            toStatus: synced.run.status,
-            message: `Execution plan "${params.spec.title}" is pending approval.`,
-            emittedBy: params.leadAgentId,
-            detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
-          })
-          .output('after')
-        params.emittedEvents.push(
-          yield* parseRowOrFail(
-            PlanEventSchema,
-            pendingApprovalEvent,
-            'createInitializedRunGraph:pendingApprovalEvent',
-          ),
-        )
-      }
-
-      const checkpointRaw = yield* params.tx
-        .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-        .content({
-          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          sequence: 1,
-          runStatus: synced.run.status,
-          readyNodeIds: [...synced.run.readyNodeIds],
-          activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
-          artifactIds: [],
-          lastCompletedNodeIds: synced.nodeRuns
-            .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-            .map((nodeRun) => nodeRun.nodeId),
-          snapshot: {
-            reason: params.checkpointReason,
-            currentNodeId: synced.run.currentNodeId,
-            waitingNodeId: synced.run.waitingNodeId,
-            readyNodeIds: synced.run.readyNodeIds,
-          },
-        })
-        .output('after')
-      const checkpoint = yield* parseRowOrFail(
-        PlanCheckpointSchema,
-        checkpointRaw,
-        'createInitializedRunGraph:checkpoint',
+      params.emittedEvents.push(
+        yield* parseRowOrFail(PlanEventSchema, pendingApprovalEvent, 'createInitializedRunGraph:pendingApprovalEvent'),
       )
+    }
 
-      const updatedRunRaw = yield* params.tx
-        .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
-        .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
-        .output('after')
-      const updatedRun = yield* parseRowOrFail(PlanRunSchema, updatedRunRaw, 'createInitializedRunGraph:updatedRun')
+    const checkpointRaw = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
+      .content({
+        runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+        sequence: 1,
+        runStatus: synced.run.status,
+        readyNodeIds: [...synced.run.readyNodeIds],
+        activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
+        artifactIds: [],
+        lastCompletedNodeIds: synced.nodeRuns
+          .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
+          .map((nodeRun) => nodeRun.nodeId),
+        snapshot: {
+          reason: params.checkpointReason,
+          currentNodeId: synced.run.currentNodeId,
+          waitingNodeId: synced.run.waitingNodeId,
+          readyNodeIds: synced.run.readyNodeIds,
+        },
+      })
+      .output('after')
+    const checkpoint = yield* parseRowOrFail(
+      PlanCheckpointSchema,
+      checkpointRaw,
+      'createInitializedRunGraph:checkpoint',
+    )
 
-      const checkpointEvent = yield* params.tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-          eventType: 'checkpoint-saved',
-          message: 'Saved checkpoint 1.',
-          emittedBy: 'system',
-          detail: {
-            checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
-            reason: params.checkpointReason,
-          },
-        })
-        .output('after')
-      params.emittedEvents.push(
-        yield* parseRowOrFail(PlanEventSchema, checkpointEvent, 'createInitializedRunGraph:checkpointEvent'),
-      )
+    const updatedRunRaw = yield* params.tx
+      .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
+      .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
+      .output('after')
+    const updatedRun = yield* parseRowOrFail(PlanRunSchema, updatedRunRaw, 'createInitializedRunGraph:updatedRun')
+
+    const checkpointEvent = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+        eventType: 'checkpoint-saved',
+        message: 'Saved checkpoint 1.',
+        emittedBy: 'system',
+        detail: {
+          checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
+          reason: params.checkpointReason,
+        },
+      })
+      .output('after')
+    params.emittedEvents.push(
+      yield* parseRowOrFail(PlanEventSchema, checkpointEvent, 'createInitializedRunGraph:checkpointEvent'),
+    )
 
-      return updatedRun
-    }),
-  )
+    return updatedRun
+  })
 }

package/src/services/execution-plan/execution-plan-schedule.ts

@@ -1,4 +1,3 @@
-import type { PlanRunRecord } from '@lota-sdk/shared'
 import { PlanRunSchema } from '@lota-sdk/shared'
 import { Schema, Effect } from 'effect'
 
@@ -6,7 +5,6 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { runPromise } from '../../effect/runtime'
 import { toDatabaseDateTime } from '../../utils/date-time'
 import { toRunData } from '../plan/plan-run-data'
 import type { makePlanRunService } from '../plan/plan-run.service'
@@ -21,7 +19,7 @@ function toPlanScheduleAttachError(operation: string, cause: unknown) {
   return new PlanScheduleAttachError({ cause: `${operation}: ${detail}` })
 }
 
-function attachPlanScheduleIfNeededEffect(params: {
+export function attachPlanScheduleIfNeeded(params: {
   db: SurrealDBService
   planRunService: ReturnType<typeof makePlanRunService>
   planSchedulerService: ReturnType<typeof makePlanSchedulerService>
@@ -70,15 +68,3 @@ function attachPlanScheduleIfNeededEffect(params: {
     return updatedRun ?? run
   })
 }
-
-export function attachPlanScheduleIfNeeded(params: {
-  db: SurrealDBService
-  planRunService: ReturnType<typeof makePlanRunService>
-  planSchedulerService: ReturnType<typeof makePlanSchedulerService>
-  organizationId: RecordIdInput
-  threadId: RecordIdInput
-  runId: RecordIdInput
-  planSpecId: RecordIdInput
-}): Promise<PlanRunRecord> {
-  return runPromise(attachPlanScheduleIfNeededEffect(params))
-}