@lota-sdk/core 0.4.13 → 0.4.15

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

@@ -30,8 +30,8 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../effect/services'
+import { toValidationError } from '../effect/zod'
 import type { AutonomousJobQueuePayload, AutonomousJobQueueRuntime } from '../queues/autonomous-job.queue'
 import { LotaQueuesServiceTag } from '../queues/queues.service'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
@@ -56,13 +56,13 @@ import { ThreadServiceTag } from './thread/thread.service'
 const AUTONOMOUS_JOB_QUEUE_NAME = 'autonomous-job'
 
 class AutonomousJobServiceError extends Schema.TaggedErrorClass<AutonomousJobServiceError>()(
-  'AutonomousJobServiceError',
+  '@lota-sdk/core/AutonomousJobServiceError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new AutonomousJobServiceError({ message, cause }),
-)
+function toAutonomousJobServiceError(message: string, cause: unknown): AutonomousJobServiceError {
+  return new AutonomousJobServiceError({ message, cause })
+}
 
 function buildAutonomousManualJobId(autonomousJobId: string): string {
   return `autonomous-manual-${encodeBullmqId(autonomousJobId)}-${nowEpochMillis()}`
@@ -221,7 +221,10 @@ function maybeNotifyEffect(
     return Effect.void
   }
 
-  return effectTryPromise(() => notificationService.notify(params), 'Failed to send autonomous job notification.')
+  return Effect.tryPromise({
+    try: () => notificationService.notify(params),
+    catch: (cause) => toAutonomousJobServiceError('Failed to send autonomous job notification.', cause),
+  })
 }
 
 function buildSyntheticUserMessage(prompt: string): ChatMessage {
@@ -243,22 +246,20 @@ function createRunRowEffect(
   },
 ): Effect.Effect<AutonomousJobRunRow, AutonomousJobServiceError> {
   const runId = new RecordId(TABLES.AUTONOMOUS_JOB_RUN, Bun.randomUUIDv7())
-  return effectTryPromise(
-    () =>
-      deps.db.createWithId(
-        TABLES.AUTONOMOUS_JOB_RUN,
-        runId,
-        compactRecord({
-          autonomousJobId: ensureRecordId(params.autonomousJobId, TABLES.AUTONOMOUS_JOB),
-          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-          queueJobId: params.queueJobId ? ensureRecordId(params.queueJobId, TABLES.QUEUE_JOB) : undefined,
-          status: params.status ?? 'queued',
-          assistantMessageIds: [],
-        }),
-        AutonomousJobRunRowSchema,
-      ),
-    'Failed to create autonomous job run.',
-  )
+  return deps.db
+    .createWithId(
+      TABLES.AUTONOMOUS_JOB_RUN,
+      runId,
+      compactRecord({
+        autonomousJobId: ensureRecordId(params.autonomousJobId, TABLES.AUTONOMOUS_JOB),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+        queueJobId: params.queueJobId ? ensureRecordId(params.queueJobId, TABLES.QUEUE_JOB) : undefined,
+        status: params.status ?? 'queued',
+        assistantMessageIds: [],
+      }),
+      AutonomousJobRunRowSchema,
+    )
+    .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to create autonomous job run.', cause)))
 }
 
 function getRowEffect(
@@ -266,16 +267,14 @@ function getRowEffect(
   jobId: RecordIdInput,
 ): Effect.Effect<AutonomousJobRow, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const row = yield* effectTryPromise(
-      () =>
-        deps.db.findOne(
-          TABLES.AUTONOMOUS_JOB,
-          { id: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) },
-          AutonomousJobRowSchema,
-        ),
-      'Failed to load autonomous job.',
-    )
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const row = yield* deps.db
+      .findOne(TABLES.AUTONOMOUS_JOB, { id: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) }, AutonomousJobRowSchema)
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to load autonomous job.', cause)))
     if (!row) {
       return yield* new AutonomousJobServiceError({
         message: `Autonomous job not found: ${recordIdToString(jobId, TABLES.AUTONOMOUS_JOB)}`,
@@ -290,16 +289,18 @@ function getRunRowEffect(
   runId: RecordIdInput,
 ): Effect.Effect<AutonomousJobRunRow, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const row = yield* effectTryPromise(
-      () =>
-        deps.db.findOne(
-          TABLES.AUTONOMOUS_JOB_RUN,
-          { id: ensureRecordId(runId, TABLES.AUTONOMOUS_JOB_RUN) },
-          AutonomousJobRunRowSchema,
-        ),
-      'Failed to load autonomous job run.',
-    )
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const row = yield* deps.db
+      .findOne(
+        TABLES.AUTONOMOUS_JOB_RUN,
+        { id: ensureRecordId(runId, TABLES.AUTONOMOUS_JOB_RUN) },
+        AutonomousJobRunRowSchema,
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to load autonomous job run.', cause)))
     if (!row) {
       return yield* new AutonomousJobServiceError({
         message: `Autonomous job run not found: ${recordIdToString(runId, TABLES.AUTONOMOUS_JOB_RUN)}`,
@@ -314,20 +315,20 @@ function unscheduleRowEffect(
   row: AutonomousJobRow,
 ): Effect.Effect<void, AutonomousJobServiceError> {
   if (row.schedule.kind === 'at') {
-    return Effect.gen(function* () {
-      yield* effectTryPromise(
-        () => deps.autonomousJobQueue.removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
-        'Failed to remove autonomous at-job.',
-      )
-    })
+    return Effect.asVoid(
+      Effect.tryPromise({
+        try: () => deps.autonomousJobQueue.removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+        catch: (cause) => toAutonomousJobServiceError('Failed to remove autonomous at-job.', cause),
+      }),
+    )
   }
 
-  return Effect.gen(function* () {
-    yield* effectTryPromise(
-      () => deps.autonomousJobQueue.removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
-      'Failed to remove autonomous job scheduler.',
-    )
-  })
+  return Effect.asVoid(
+    Effect.tryPromise({
+      try: () => deps.autonomousJobQueue.removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+      catch: (cause) => toAutonomousJobServiceError('Failed to remove autonomous job scheduler.', cause),
+    }),
+  )
 }
 
 function findRecoverableRunRowEffect(
@@ -335,24 +336,23 @@ function findRecoverableRunRowEffect(
   autonomousJobId: RecordIdInput,
 ): Effect.Effect<AutonomousJobRunRow | null, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    const rows = yield* effectTryPromise(
-      () =>
-        deps.db.queryMany(
-          new BoundQuery(
-            `SELECT * FROM ${TABLES.AUTONOMOUS_JOB_RUN}
+    const rows = yield* deps.db
+      .queryMany(
+        new BoundQuery(
+          `SELECT * FROM ${TABLES.AUTONOMOUS_JOB_RUN}
             WHERE autonomousJobId = $autonomousJobId
               AND status IN $statuses
             ORDER BY createdAt DESC
             LIMIT 1`,
-            {
-              autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB),
-              statuses: ['queued', 'running'],
-            },
-          ),
-          AutonomousJobRunRowSchema,
+          { autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB), statuses: ['queued', 'running'] },
         ),
-      'Failed to find recoverable autonomous job run.',
-    )
+        AutonomousJobRunRowSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toAutonomousJobServiceError('Failed to find recoverable autonomous job run.', cause),
+        ),
+      )
     return rows[0] ?? null
   })
 }
@@ -378,8 +378,8 @@ function scheduleRowEffect(
           })
         : createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
 
-      const enqueueResult = yield* effectTryPromise(
-        () =>
+      const enqueueResult = yield* Effect.tryPromise({
+        try: () =>
           deps.autonomousJobQueue.enqueueAutonomousJobRun({
             payload: {
               autonomousJobId: jobId,
@@ -389,47 +389,53 @@ function scheduleRowEffect(
             delayMs: Math.max(0, (nextRunAt ?? referenceTime).getTime() - referenceTime.getTime()),
             jobId: buildAutonomousAtJobId(jobId),
           }),
-        'Failed to enqueue autonomous job run.',
-      )
+        catch: (cause) => toAutonomousJobServiceError('Failed to enqueue autonomous job run.', cause),
+      })
 
       const queueJobId = enqueueResult.queueJobId
       if (queueJobId) {
-        yield* effectTryPromise(
-          () =>
-            deps.db.update(
-              TABLES.AUTONOMOUS_JOB_RUN,
-              queuedRun.id,
-              { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
-              AutonomousJobRunRowSchema,
+        yield* deps.db
+          .update(
+            TABLES.AUTONOMOUS_JOB_RUN,
+            queuedRun.id,
+            { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
+            AutonomousJobRunRowSchema,
+          )
+          .pipe(
+            Effect.mapError((cause) =>
+              toAutonomousJobServiceError('Failed to persist autonomous job run queue job id.', cause),
             ),
-          'Failed to persist autonomous job run queue job id.',
-        )
+          )
       }
 
-      yield* effectTryPromise(
-        () =>
-          deps.db.update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema),
-        'Failed to update autonomous job next run time.',
-      )
+      yield* deps.db
+        .update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema)
+        .pipe(
+          Effect.mapError((cause) =>
+            toAutonomousJobServiceError('Failed to update autonomous job next run time.', cause),
+          ),
+        )
     })
   } else {
     const recurringSchedule = row.schedule
     return Effect.gen(function* () {
-      yield* effectTryPromise(
-        () =>
+      yield* Effect.tryPromise({
+        try: () =>
           deps.autonomousJobQueue.upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: recurringSchedule }),
-        'Failed to upsert autonomous job scheduler.',
-      )
+        catch: (cause) => toAutonomousJobServiceError('Failed to upsert autonomous job scheduler.', cause),
+      })
 
       if (options.runImmediate ?? recurringSchedule.immediately) {
         yield* runNowEffect(deps, jobId).pipe(Effect.asVoid)
       }
 
-      yield* effectTryPromise(
-        () =>
-          deps.db.update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema),
-        'Failed to update autonomous job next run time.',
-      )
+      yield* deps.db
+        .update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema)
+        .pipe(
+          Effect.mapError((cause) =>
+            toAutonomousJobServiceError('Failed to update autonomous job next run time.', cause),
+          ),
+        )
     })
   }
 }
@@ -439,8 +445,19 @@ function createEffect(
   input: CreateAutonomousJobInput,
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const parsed = CreateAutonomousJobInputSchema.parse(input)
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const parsed = yield* Effect.try({
+      try: () => CreateAutonomousJobInputSchema.parse(input),
+      catch: (cause) =>
+        new AutonomousJobServiceError({
+          message: 'Failed to validate CreateAutonomousJobInput.',
+          cause: toValidationError(cause),
+        }),
+    })
     const organizationId = ensureRecordId(parsed.organizationId, TABLES.ORGANIZATION)
     const ownerUserId = ensureRecordId(parsed.ownerUserId, TABLES.USER)
     const thread = yield* deps.thread
@@ -453,29 +470,27 @@ function createEffect(
 
     const jobId = new RecordId(TABLES.AUTONOMOUS_JOB, Bun.randomUUIDv7())
     const nextRunAt = computeNextRunAt(parsed.schedule)
-    const created = yield* effectTryPromise(
-      () =>
-        deps.db.createWithId(
-          TABLES.AUTONOMOUS_JOB,
-          jobId,
-          compactRecord({
-            organizationId,
-            ownerUserId,
-            ownerUserName: parsed.ownerUserName,
-            threadId: ensureRecordId(thread.id, TABLES.THREAD),
-            agentId: parsed.agentId,
-            title: parsed.title,
-            prompt: parsed.prompt,
-            schedule: parsed.schedule,
-            status: 'active',
-            autoPauseThreshold: parsed.autoPauseThreshold,
-            consecutiveErrorCount: 0,
-            nextRunAt: nextRunAt ?? undefined,
-          }),
-          AutonomousJobRowSchema,
-        ),
-      'Failed to create autonomous job.',
-    )
+    const created = yield* deps.db
+      .createWithId(
+        TABLES.AUTONOMOUS_JOB,
+        jobId,
+        compactRecord({
+          organizationId,
+          ownerUserId,
+          ownerUserName: parsed.ownerUserName,
+          threadId: ensureRecordId(thread.id, TABLES.THREAD),
+          agentId: parsed.agentId,
+          title: parsed.title,
+          prompt: parsed.prompt,
+          schedule: parsed.schedule,
+          status: 'active',
+          autoPauseThreshold: parsed.autoPauseThreshold,
+          consecutiveErrorCount: 0,
+          nextRunAt: nextRunAt ?? undefined,
+        }),
+        AutonomousJobRowSchema,
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to create autonomous job.', cause)))
 
     yield* scheduleRowEffect(deps, created)
     const row = yield* getRowEffect(deps, created.id)
@@ -488,17 +503,19 @@ function recoverActiveJobsEffect(
   now = nowDate(),
 ): Effect.Effect<void, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const activeRows = yield* effectTryPromise(
-      () =>
-        deps.db.queryMany(
-          new BoundQuery(`SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`, {
-            status: 'active',
-          }),
-          AutonomousJobRowSchema,
-        ),
-      'Failed to load active autonomous jobs.',
-    )
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const activeRows = yield* deps.db
+      .queryMany(
+        new BoundQuery(`SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`, {
+          status: 'active',
+        }),
+        AutonomousJobRowSchema,
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to load active autonomous jobs.', cause)))
     yield* Effect.forEach(activeRows, (row) =>
       scheduleRowEffect(deps, row, { runImmediate: false, referenceTime: now, reusePendingAtRun: true }),
     )
@@ -520,21 +537,23 @@ function listEffect(
   params: { organizationId: RecordIdInput; ownerUserId?: RecordIdInput; status?: AutonomousJobStatus },
 ): Effect.Effect<AutonomousJob[], AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const rows = yield* effectTryPromise(
-      () =>
-        deps.db.findMany(
-          TABLES.AUTONOMOUS_JOB,
-          compactRecord({
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            ownerUserId: params.ownerUserId ? ensureRecordId(params.ownerUserId, TABLES.USER) : undefined,
-            status: params.status,
-          }),
-          AutonomousJobRowSchema,
-          { orderBy: 'createdAt', orderDir: 'DESC' },
-        ),
-      'Failed to list autonomous jobs.',
-    )
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const rows = yield* deps.db
+      .findMany(
+        TABLES.AUTONOMOUS_JOB,
+        compactRecord({
+          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+          ownerUserId: params.ownerUserId ? ensureRecordId(params.ownerUserId, TABLES.USER) : undefined,
+          status: params.status,
+        }),
+        AutonomousJobRowSchema,
+        { orderBy: 'createdAt', orderDir: 'DESC' },
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to list autonomous jobs.', cause)))
     return rows.map((row) => toPublicJob(row))
   })
 }
@@ -545,7 +564,14 @@ function updateEffect(
   input: UpdateAutonomousJobInput,
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    const parsed = UpdateAutonomousJobInputSchema.parse(input)
+    const parsed = yield* Effect.try({
+      try: () => UpdateAutonomousJobInputSchema.parse(input),
+      catch: (cause) =>
+        new AutonomousJobServiceError({
+          message: 'Failed to validate UpdateAutonomousJobInput.',
+          cause: toValidationError(cause),
+        }),
+    })
     const existing = yield* getRowEffect(deps, jobId)
     yield* unscheduleRowEffect(deps, existing)
     const nextTitle = parsed.title
@@ -562,22 +588,20 @@ function updateEffect(
     }
 
     const nextRunAt = computeNextRunAt(parsed.schedule ?? existing.schedule)
-    const updated = yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          existing.id,
-          compactRecord({
-            title: parsed.title,
-            prompt: parsed.prompt,
-            schedule: parsed.schedule,
-            autoPauseThreshold: parsed.autoPauseThreshold,
-            nextRunAt: existing.status === 'active' ? (nextRunAt ?? undefined) : undefined,
-          }),
-          AutonomousJobRowSchema,
-        ),
-      'Failed to update autonomous job.',
-    )
+    const updated = yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB,
+        existing.id,
+        compactRecord({
+          title: parsed.title,
+          prompt: parsed.prompt,
+          schedule: parsed.schedule,
+          autoPauseThreshold: parsed.autoPauseThreshold,
+          nextRunAt: existing.status === 'active' ? (nextRunAt ?? undefined) : undefined,
+        }),
+        AutonomousJobRowSchema,
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to update autonomous job.', cause)))
     if (!updated) {
       return yield* new AutonomousJobServiceError({
         message: `Failed to update autonomous job: ${recordIdToString(existing.id, TABLES.AUTONOMOUS_JOB)}`,
@@ -600,16 +624,9 @@ function pauseEffect(
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
     yield* unscheduleRowEffect(deps, row)
-    yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          row.id,
-          { status: 'paused', nextRunAt: undefined },
-          AutonomousJobRowSchema,
-        ),
-      'Failed to pause autonomous job.',
-    )
+    yield* deps.db
+      .update(TABLES.AUTONOMOUS_JOB, row.id, { status: 'paused', nextRunAt: undefined }, AutonomousJobRowSchema)
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to pause autonomous job.', cause)))
     const updatedRow = yield* getRowEffect(deps, row.id)
     return toPublicJob(updatedRow)
   })
@@ -622,16 +639,14 @@ function resumeEffect(
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
     const nextRunAt = computeNextRunAt(row.schedule)
-    const resumed = yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          row.id,
-          { status: 'active', nextRunAt: nextRunAt ?? undefined },
-          AutonomousJobRowSchema,
-        ),
-      'Failed to resume autonomous job.',
-    )
+    const resumed = yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB,
+        row.id,
+        { status: 'active', nextRunAt: nextRunAt ?? undefined },
+        AutonomousJobRowSchema,
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to resume autonomous job.', cause)))
     if (!resumed) {
       return yield* new AutonomousJobServiceError({
         message: `Failed to resume autonomous job: ${recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)}`,
@@ -651,8 +666,8 @@ function runNowEffect(
     const row = yield* getRowEffect(deps, jobId)
     const queuedRun = yield* createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
 
-    const enqueueResult = yield* effectTryPromise(
-      () =>
+    const enqueueResult = yield* Effect.tryPromise({
+      try: () =>
         deps.autonomousJobQueue.enqueueAutonomousJobRun({
           payload: {
             autonomousJobId: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
@@ -661,21 +676,23 @@ function runNowEffect(
           },
           jobId: buildAutonomousManualJobId(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
         }),
-      'Failed to enqueue autonomous job run.',
-    )
+      catch: (cause) => toAutonomousJobServiceError('Failed to enqueue autonomous job run.', cause),
+    })
 
     const queueJobId = enqueueResult.queueJobId
     if (queueJobId) {
-      yield* effectTryPromise(
-        () =>
-          deps.db.update(
-            TABLES.AUTONOMOUS_JOB_RUN,
-            queuedRun.id,
-            { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
-            AutonomousJobRunRowSchema,
+      yield* deps.db
+        .update(
+          TABLES.AUTONOMOUS_JOB_RUN,
+          queuedRun.id,
+          { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
+          AutonomousJobRunRowSchema,
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toAutonomousJobServiceError('Failed to persist autonomous job run queue job id.', cause),
           ),
-        'Failed to persist autonomous job run queue job id.',
-      )
+        )
     }
 
     const runRow = yield* getRunRowEffect(deps, queuedRun.id)
@@ -690,16 +707,9 @@ function cancelEffect(
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
     yield* unscheduleRowEffect(deps, row)
-    yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          row.id,
-          { status: 'cancelled', nextRunAt: undefined },
-          AutonomousJobRowSchema,
-        ),
-      'Failed to cancel autonomous job.',
-    )
+    yield* deps.db
+      .update(TABLES.AUTONOMOUS_JOB, row.id, { status: 'cancelled', nextRunAt: undefined }, AutonomousJobRowSchema)
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to cancel autonomous job.', cause)))
     const updatedRow = yield* getRowEffect(deps, row.id)
     return toPublicJob(updatedRow)
   })
@@ -728,17 +738,19 @@ function listRunsEffect(
   jobId: RecordIdInput,
 ): Effect.Effect<AutonomousJobRun[], AutonomousJobServiceError> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    const rows = yield* effectTryPromise(
-      () =>
-        deps.db.findMany(
-          TABLES.AUTONOMOUS_JOB_RUN,
-          { autonomousJobId: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) },
-          AutonomousJobRunRowSchema,
-          { orderBy: 'createdAt', orderDir: 'DESC' },
-        ),
-      'Failed to list autonomous job runs.',
-    )
+    yield* deps.db
+      .connect()
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause)),
+      )
+    const rows = yield* deps.db
+      .findMany(
+        TABLES.AUTONOMOUS_JOB_RUN,
+        { autonomousJobId: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) },
+        AutonomousJobRunRowSchema,
+        { orderBy: 'createdAt', orderDir: 'DESC' },
+      )
+      .pipe(Effect.mapError((cause) => toAutonomousJobServiceError('Failed to list autonomous job runs.', cause)))
     return rows.map((row) => toPublicRun(row))
   })
 }
@@ -772,16 +784,16 @@ function markQueuedRunRunningEffect(
   const startedAt = nowDate()
 
   return Effect.gen(function* () {
-    const updatedRunRow = yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB_RUN,
-          runRow.id,
-          { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB), status: 'running', startedAt },
-          AutonomousJobRunRowSchema,
-        ),
-      'Failed to mark autonomous job run as running.',
-    )
+    const updatedRunRow = yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB_RUN,
+        runRow.id,
+        { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB), status: 'running', startedAt },
+        AutonomousJobRunRowSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to mark autonomous job run as running.', cause)),
+      )
 
     return updatedRunRow ?? runRow
   })
@@ -810,9 +822,9 @@ function completeQueuedRunEffect(
     )
     const completedAt = nowDate()
 
-    void (yield* effectTryPromise(
-      () =>
-        deps.db.update(
+    yield* Effect.asVoid(
+      deps.db
+        .update(
           TABLES.AUTONOMOUS_JOB_RUN,
           currentRunRow.id,
           compactRecord({
@@ -825,9 +837,13 @@ function completeQueuedRunEffect(
             completedAt,
           }),
           AutonomousJobRunRowSchema,
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toAutonomousJobServiceError('Failed to update autonomous job run completion.', cause),
+          ),
         ),
-      'Failed to update autonomous job run completion.',
-    ))
+    )
 
     const nextRunAt =
       job.data.trigger === 'scheduled' && currentJobRow.schedule.kind !== 'at'
@@ -836,25 +852,27 @@ function completeQueuedRunEffect(
     const nextStatus =
       currentJobRow.schedule.kind === 'at' && job.data.trigger === 'scheduled' ? 'completed' : currentJobRow.status
 
-    yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          currentJobRow.id,
-          compactRecord({
-            status: nextStatus,
-            consecutiveErrorCount: 0,
-            lastRunStatus: runStatus,
-            lastRunAt: completedAt,
-            nextRunAt: nextStatus === 'active' ? (nextRunAt ?? undefined) : undefined,
-            linkedPlanSpecId: activePlan?.specId ? ensureRecordId(activePlan.specId, TABLES.PLAN_SPEC) : undefined,
-            linkedPlanRunId: activePlan?.runId ? ensureRecordId(activePlan.runId, TABLES.PLAN_RUN) : undefined,
-            lastError: undefined,
-          }),
-          AutonomousJobRowSchema,
+    yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB,
+        currentJobRow.id,
+        compactRecord({
+          status: nextStatus,
+          consecutiveErrorCount: 0,
+          lastRunStatus: runStatus,
+          lastRunAt: completedAt,
+          nextRunAt: nextStatus === 'active' ? (nextRunAt ?? undefined) : undefined,
+          linkedPlanSpecId: activePlan?.specId ? ensureRecordId(activePlan.specId, TABLES.PLAN_SPEC) : undefined,
+          linkedPlanRunId: activePlan?.runId ? ensureRecordId(activePlan.runId, TABLES.PLAN_RUN) : undefined,
+          lastError: undefined,
+        }),
+        AutonomousJobRowSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toAutonomousJobServiceError('Failed to update autonomous job after successful run.', cause),
         ),
-      'Failed to update autonomous job after successful run.',
-    )
+      )
 
     yield* maybeNotifyEffect(deps, {
       organizationId: recordIdToString(currentJobRow.organizationId, TABLES.ORGANIZATION),
@@ -890,41 +908,43 @@ function failQueuedRunEffect(
     const terminalOneShot = currentJobRow.schedule.kind === 'at' && job.data.trigger === 'scheduled'
     const nextStatus: AutonomousJobStatus = terminalOneShot ? 'failed' : autoPause ? 'paused' : currentJobRow.status
 
-    yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB_RUN,
-          currentRunRow.id,
-          { status: 'failed', error: normalizedError, completedAt },
-          AutonomousJobRunRowSchema,
-        ),
-      'Failed to persist failed autonomous job run.',
-    )
+    yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB_RUN,
+        currentRunRow.id,
+        { status: 'failed', error: normalizedError, completedAt },
+        AutonomousJobRunRowSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toAutonomousJobServiceError('Failed to persist failed autonomous job run.', cause)),
+      )
 
     if (autoPause || terminalOneShot) {
       yield* unscheduleRowEffect(deps, currentJobRow)
     }
 
-    yield* effectTryPromise(
-      () =>
-        deps.db.update(
-          TABLES.AUTONOMOUS_JOB,
-          currentJobRow.id,
-          compactRecord({
-            status: nextStatus,
-            consecutiveErrorCount: nextConsecutiveErrorCount,
-            lastRunStatus: 'failed',
-            lastRunAt: completedAt,
-            nextRunAt:
-              nextStatus === 'active' && currentJobRow.schedule.kind !== 'at'
-                ? (computeNextRunAt(currentJobRow.schedule, completedAt) ?? undefined)
-                : undefined,
-            lastError: normalizedError,
-          }),
-          AutonomousJobRowSchema,
+    yield* deps.db
+      .update(
+        TABLES.AUTONOMOUS_JOB,
+        currentJobRow.id,
+        compactRecord({
+          status: nextStatus,
+          consecutiveErrorCount: nextConsecutiveErrorCount,
+          lastRunStatus: 'failed',
+          lastRunAt: completedAt,
+          nextRunAt:
+            nextStatus === 'active' && currentJobRow.schedule.kind !== 'at'
+              ? (computeNextRunAt(currentJobRow.schedule, completedAt) ?? undefined)
+              : undefined,
+          lastError: normalizedError,
+        }),
+        AutonomousJobRowSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toAutonomousJobServiceError('Failed to update autonomous job failure state.', cause),
         ),
-      'Failed to update autonomous job failure state.',
-    )
+      )
 
     yield* maybeNotifyEffect(deps, {
       organizationId: recordIdToString(currentJobRow.organizationId, TABLES.ORGANIZATION),
@@ -946,13 +966,19 @@ function failQueuedRunEffect(
 function executeQueuedRunEffect(
   deps: AutonomousJobDeps,
   job: Job<AutonomousJobQueuePayload>,
-): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError, unknown> {
+): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError, never> {
   return Effect.gen(function* () {
     const autonomousJobRowRef = yield* Ref.make<AutonomousJobRow | null>(null)
     const runRowRef = yield* Ref.make<AutonomousJobRunRow | null>(null)
 
     return yield* Effect.gen(function* () {
-      yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
+      yield* deps.db
+        .connect()
+        .pipe(
+          Effect.mapError((cause) =>
+            toAutonomousJobServiceError('Failed to connect to autonomous job database.', cause),
+          ),
+        )
       const currentJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
       yield* Ref.set(autonomousJobRowRef, currentJobRow)
       const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
@@ -990,6 +1016,7 @@ function executeQueuedRunEffect(
           inputMessage,
         })
         .pipe(
+          deps.provideCurrentContext,
           Effect.mapError(
             (cause) => new AutonomousJobServiceError({ message: 'Failed to run autonomous job thread turn.', cause }),
           ),
@@ -1022,19 +1049,48 @@ function executeQueuedRunEffect(
 function createAutonomousJobService(deps: AutonomousJobDeps) {
   return {
     computeNextRunAt,
-    create: (input: CreateAutonomousJobInput) => createEffect(deps, input),
-    recoverActiveJobs: (now = nowDate()) => recoverActiveJobsEffect(deps, now),
-    get: (jobId: RecordIdInput) => getEffect(deps, jobId),
-    list: (params: { organizationId: RecordIdInput; ownerUserId?: RecordIdInput; status?: AutonomousJobStatus }) =>
-      listEffect(deps, params),
-    update: (jobId: RecordIdInput, input: UpdateAutonomousJobInput) => updateEffect(deps, jobId, input),
-    pause: (jobId: RecordIdInput) => pauseEffect(deps, jobId),
-    resume: (jobId: RecordIdInput) => resumeEffect(deps, jobId),
-    runNow: (jobId: RecordIdInput) => runNowEffect(deps, jobId),
-    cancel: (jobId: RecordIdInput) => cancelEffect(deps, jobId),
-    delete: (jobId: RecordIdInput) => deleteJobEffect(deps, jobId),
-    listRuns: (jobId: RecordIdInput) => listRunsEffect(deps, jobId),
-    executeQueuedRun: (job: Job<AutonomousJobQueuePayload>) => executeQueuedRunEffect(deps, job),
+    create: Effect.fn('AutonomousJobService.create')(function* (input: CreateAutonomousJobInput) {
+      return yield* createEffect(deps, input)
+    }),
+    recoverActiveJobs: Effect.fn('AutonomousJobService.recoverActiveJobs')(function* (now: Date = nowDate()) {
+      return yield* recoverActiveJobsEffect(deps, now)
+    }),
+    get: Effect.fn('AutonomousJobService.get')(function* (jobId: RecordIdInput) {
+      return yield* getEffect(deps, jobId)
+    }),
+    list: Effect.fn('AutonomousJobService.list')(function* (params: {
+      organizationId: RecordIdInput
+      ownerUserId?: RecordIdInput
+      status?: AutonomousJobStatus
+    }) {
+      return yield* listEffect(deps, params)
+    }),
+    update: Effect.fn('AutonomousJobService.update')(function* (jobId: RecordIdInput, input: UpdateAutonomousJobInput) {
+      return yield* updateEffect(deps, jobId, input)
+    }),
+    pause: Effect.fn('AutonomousJobService.pause')(function* (jobId: RecordIdInput) {
+      return yield* pauseEffect(deps, jobId)
+    }),
+    resume: Effect.fn('AutonomousJobService.resume')(function* (jobId: RecordIdInput) {
+      return yield* resumeEffect(deps, jobId)
+    }),
+    runNow: Effect.fn('AutonomousJobService.runNow')(function* (jobId: RecordIdInput) {
+      return yield* runNowEffect(deps, jobId)
+    }),
+    cancel: Effect.fn('AutonomousJobService.cancel')(function* (jobId: RecordIdInput) {
+      return yield* cancelEffect(deps, jobId)
+    }),
+    delete: Effect.fn('AutonomousJobService.delete')(function* (jobId: RecordIdInput) {
+      return yield* deleteJobEffect(deps, jobId)
+    }),
+    listRuns: Effect.fn('AutonomousJobService.listRuns')(function* (jobId: RecordIdInput) {
+      return yield* listRunsEffect(deps, jobId)
+    }),
+    executeQueuedRun: Effect.fn('AutonomousJobService.executeQueuedRun')(function* (
+      job: Job<AutonomousJobQueuePayload>,
+    ) {
+      return yield* executeQueuedRunEffect(deps, job)
+    }),
   } as const
 }
 
@@ -1043,6 +1099,7 @@ interface AutonomousJobDeps {
   config: ResolvedLotaRuntimeConfig
   executionPlan: ReturnType<typeof makeExecutionPlanService>
   queueJob: ReturnType<typeof makeQueueJobService>
+  provideCurrentContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>
   thread: ReturnType<typeof makeThreadService>
   autonomousJobQueue: AutonomousJobQueueRuntime
 }
@@ -1059,6 +1116,9 @@ export class AutonomousJobServiceTag extends Context.Service<
 export const AutonomousJobServiceLive = Layer.effect(
   AutonomousJobServiceTag,
   Effect.gen(function* () {
+    const currentContext = yield* Effect.context()
+    const provideCurrentContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, never> =>
+      effect.pipe(Effect.provide(currentContext)) as Effect.Effect<A, E, never>
     const db = yield* DatabaseServiceTag
     const config = yield* RuntimeConfigServiceTag
     const executionPlan = yield* ExecutionPlanServiceTag
@@ -1070,6 +1130,7 @@ export const AutonomousJobServiceLive = Layer.effect(
       config,
       executionPlan,
       queueJob,
+      provideCurrentContext,
       thread,
       autonomousJobQueue: queues.autonomousJob,
     })