@lota-sdk/core 0.4.8 → 0.4.9

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

@@ -18,32 +18,57 @@ import type {
   ChatMessage,
   CreateAutonomousJobInput,
   QueueJobError,
+  SerializableExecutionPlan,
   UpdateAutonomousJobInput,
 } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
-import { CronExpressionParser } from 'cron-parser'
+import { Context, Cron, Schema, Effect, Layer } from 'effect'
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
-import { databaseService } from '../db/service'
+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 { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { extractMessageText } from '../runtime/thread-chat-helpers'
 import { buildAutonomousAtJobId, encodeBullmqId } from '../utils/autonomous-job-ids'
-import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
+import {
+  nowDate,
+  nowEpochMillis,
+  toIsoDateTimeString,
+  toOptionalIsoDateTimeString,
+  unsafeDateFrom,
+} from '../utils/date-time'
 import { compactRecord, compactWhitespace, stringifyUnknown, truncateText } from '../utils/string'
-import { executionPlanService } from './execution-plan.service'
-import { getNotificationService } from './notification.service'
-import { queueJobService } from './queue-job.service'
-import { runThreadTurnInBackground } from './thread-turn'
-import { threadService } from './thread.service'
+import type { makeExecutionPlanService } from './execution-plan/execution-plan.service'
+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'
 
+class AutonomousJobServiceError extends Schema.TaggedErrorClass<AutonomousJobServiceError>()(
+  'AutonomousJobServiceError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+const effectTryPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new AutonomousJobServiceError({ message, cause }),
+)
+
 function buildAutonomousManualJobId(autonomousJobId: string): string {
-  return `autonomous-manual-${encodeBullmqId(autonomousJobId)}-${Date.now()}`
+  return `autonomous-manual-${encodeBullmqId(autonomousJobId)}-${nowEpochMillis()}`
 }
 
 const AutonomousJobRowSchema = z.object({
@@ -89,6 +114,20 @@ const AutonomousJobRunRowSchema = z.object({
 
 type AutonomousJobRow = z.infer<typeof AutonomousJobRowSchema>
 type AutonomousJobRunRow = z.infer<typeof AutonomousJobRunRowSchema>
+type ActiveExecutionPlan = SerializableExecutionPlan | null
+
+function computeNextCronDate(cronExpression: string, baseTime: Date): Date | null {
+  const parsedCron = Cron.parse(cronExpression)
+  if (parsedCron._tag === 'Failure') {
+    return null
+  }
+
+  try {
+    return Cron.next(parsedCron.success, baseTime)
+  } catch {
+    return null
+  }
+}
 
 function toQueueJobError(error: unknown): QueueJobError {
   if (error instanceof Error) {
@@ -104,583 +143,941 @@ function toQueueJobError(error: unknown): QueueJobError {
   return QueueJobErrorSchema.parse({ message: truncateText(stringifyUnknown(error) ?? 'Unknown error', 5_000) })
 }
 
-class AutonomousJobService {
-  private toPublicJob(row: AutonomousJobRow): AutonomousJob {
-    return AutonomousJobSchema.parse({
-      id: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
-      organizationId: recordIdToString(row.organizationId, TABLES.ORGANIZATION),
-      ownerUserId: recordIdToString(row.ownerUserId, TABLES.USER),
-      ownerUserName: row.ownerUserName,
-      threadId: recordIdToString(row.threadId, TABLES.THREAD),
-      agentId: row.agentId,
-      title: row.title,
-      prompt: row.prompt,
-      schedule: row.schedule,
-      status: row.status,
-      autoPauseThreshold: row.autoPauseThreshold,
-      consecutiveErrorCount: row.consecutiveErrorCount,
-      lastRunStatus: row.lastRunStatus,
-      lastRunAt: toOptionalIsoDateTimeString(row.lastRunAt),
-      nextRunAt: toOptionalIsoDateTimeString(row.nextRunAt),
-      linkedPlanSpecId: row.linkedPlanSpecId ? recordIdToString(row.linkedPlanSpecId, TABLES.PLAN_SPEC) : undefined,
-      linkedPlanRunId: row.linkedPlanRunId ? recordIdToString(row.linkedPlanRunId, TABLES.PLAN_RUN) : undefined,
-      lastError: row.lastError,
-      createdAt: toIsoDateTimeString(row.createdAt),
-      updatedAt: toIsoDateTimeString(row.updatedAt),
-    })
-  }
+function toPublicJob(row: AutonomousJobRow): AutonomousJob {
+  return AutonomousJobSchema.parse({
+    id: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
+    organizationId: recordIdToString(row.organizationId, TABLES.ORGANIZATION),
+    ownerUserId: recordIdToString(row.ownerUserId, TABLES.USER),
+    ownerUserName: row.ownerUserName,
+    threadId: recordIdToString(row.threadId, TABLES.THREAD),
+    agentId: row.agentId,
+    title: row.title,
+    prompt: row.prompt,
+    schedule: row.schedule,
+    status: row.status,
+    autoPauseThreshold: row.autoPauseThreshold,
+    consecutiveErrorCount: row.consecutiveErrorCount,
+    lastRunStatus: row.lastRunStatus,
+    lastRunAt: toOptionalIsoDateTimeString(row.lastRunAt),
+    nextRunAt: toOptionalIsoDateTimeString(row.nextRunAt),
+    linkedPlanSpecId: row.linkedPlanSpecId ? recordIdToString(row.linkedPlanSpecId, TABLES.PLAN_SPEC) : undefined,
+    linkedPlanRunId: row.linkedPlanRunId ? recordIdToString(row.linkedPlanRunId, TABLES.PLAN_RUN) : undefined,
+    lastError: row.lastError,
+    createdAt: toIsoDateTimeString(row.createdAt),
+    updatedAt: toIsoDateTimeString(row.updatedAt),
+  })
+}
 
-  private toPublicRun(row: AutonomousJobRunRow): AutonomousJobRun {
-    return AutonomousJobRunSchema.parse({
-      id: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB_RUN),
-      autonomousJobId: recordIdToString(row.autonomousJobId, TABLES.AUTONOMOUS_JOB),
-      threadId: recordIdToString(row.threadId, TABLES.THREAD),
-      queueJobId: row.queueJobId ? recordIdToString(row.queueJobId, TABLES.QUEUE_JOB) : undefined,
-      status: row.status,
-      inputMessageId: row.inputMessageId,
-      assistantMessageIds: row.assistantMessageIds,
-      summary: row.summary,
-      error: row.error,
-      linkedPlanSpecId: row.linkedPlanSpecId ? recordIdToString(row.linkedPlanSpecId, TABLES.PLAN_SPEC) : undefined,
-      linkedPlanRunId: row.linkedPlanRunId ? recordIdToString(row.linkedPlanRunId, TABLES.PLAN_RUN) : undefined,
-      startedAt: toOptionalIsoDateTimeString(row.startedAt),
-      completedAt: toOptionalIsoDateTimeString(row.completedAt),
-      createdAt: toIsoDateTimeString(row.createdAt),
-      updatedAt: toIsoDateTimeString(row.updatedAt),
-    })
-  }
+function toPublicRun(row: AutonomousJobRunRow): AutonomousJobRun {
+  return AutonomousJobRunSchema.parse({
+    id: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB_RUN),
+    autonomousJobId: recordIdToString(row.autonomousJobId, TABLES.AUTONOMOUS_JOB),
+    threadId: recordIdToString(row.threadId, TABLES.THREAD),
+    queueJobId: row.queueJobId ? recordIdToString(row.queueJobId, TABLES.QUEUE_JOB) : undefined,
+    status: row.status,
+    inputMessageId: row.inputMessageId,
+    assistantMessageIds: row.assistantMessageIds,
+    summary: row.summary,
+    error: row.error,
+    linkedPlanSpecId: row.linkedPlanSpecId ? recordIdToString(row.linkedPlanSpecId, TABLES.PLAN_SPEC) : undefined,
+    linkedPlanRunId: row.linkedPlanRunId ? recordIdToString(row.linkedPlanRunId, TABLES.PLAN_RUN) : undefined,
+    startedAt: toOptionalIsoDateTimeString(row.startedAt),
+    completedAt: toOptionalIsoDateTimeString(row.completedAt),
+    createdAt: toIsoDateTimeString(row.createdAt),
+    updatedAt: toIsoDateTimeString(row.updatedAt),
+  })
+}
 
-  computeNextRunAt(schedule: AutonomousJobSchedule, baseTime: Date = new Date()): Date | null {
-    switch (schedule.kind) {
-      case 'cron': {
-        try {
-          const expr = CronExpressionParser.parse(schedule.cron, { currentDate: baseTime })
-          return expr.next().toDate()
-        } catch {
-          return null
-        }
-      }
-      case 'every':
-        return new Date(baseTime.getTime() + schedule.intervalMs)
-      case 'at': {
-        const at = new Date(schedule.at)
+export function computeNextRunAt(schedule: AutonomousJobSchedule, baseTime: Date = nowDate()): Date | null {
+  switch (schedule.kind) {
+    case 'cron': {
+      return computeNextCronDate(schedule.cron, baseTime)
+    }
+    case 'every':
+      return unsafeDateFrom(baseTime.getTime() + schedule.intervalMs)
+    case 'at': {
+      try {
+        const at = unsafeDateFrom(schedule.at)
         return Number.isNaN(at.getTime()) ? null : at
-      }
-      default:
+      } catch {
         return null
+      }
     }
+    default:
+      return null
   }
+}
 
-  private async maybeNotify(
-    kind: 'notify',
-    params: {
-      organizationId: string
-      threadId: string
-      title: string
-      body: string
-      severity: 'info' | 'warning'
-      metadata?: Record<string, unknown>
-    },
-  ): Promise<void> {
-    try {
-      const service = getNotificationService()
-      await service[kind](params)
-    } catch (error) {
-      if (error instanceof Error && error.message === 'Notification service is not configured.') {
-        return
-      }
-      throw error
-    }
+function maybeNotifyEffect(
+  deps: AutonomousJobDeps,
+  params: {
+    organizationId: string
+    threadId: string
+    title: string
+    body: string
+    severity: 'info' | 'warning'
+    metadata?: Record<string, unknown>
+  },
+): Effect.Effect<void, AutonomousJobServiceError> {
+  const notificationService = deps.config.notificationService
+  if (!notificationService) {
+    return Effect.void
   }
 
-  private buildSyntheticUserMessage(prompt: string): ChatMessage {
-    return {
-      id: Bun.randomUUIDv7(),
-      role: 'user',
-      parts: [{ type: 'text', text: prompt }],
-      metadata: { createdAt: Date.now() },
-    }
+  return effectTryPromise(() => notificationService.notify(params), 'Failed to send autonomous job notification.')
+}
+
+function buildSyntheticUserMessage(prompt: string): ChatMessage {
+  return {
+    id: Bun.randomUUIDv7(),
+    role: 'user',
+    parts: [{ type: 'text', text: prompt }],
+    metadata: { createdAt: nowEpochMillis() },
   }
+}
 
-  private async createRunRow(params: {
+function createRunRowEffect(
+  deps: AutonomousJobDeps,
+  params: {
     autonomousJobId: RecordIdInput
     threadId: RecordIdInput
     queueJobId?: RecordIdInput
     status?: AutonomousJobRunStatus
-  }): Promise<AutonomousJobRunRow> {
-    const runId = new RecordId(TABLES.AUTONOMOUS_JOB_RUN, Bun.randomUUIDv7())
-    return databaseService.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,
-    )
-  }
+  },
+): 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.',
+  )
+}
 
-  private async getRow(jobId: RecordIdInput): Promise<AutonomousJobRow> {
-    await databaseService.connect()
-    const row = await databaseService.findOne(
-      TABLES.AUTONOMOUS_JOB,
-      { id: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) },
-      AutonomousJobRowSchema,
+function getRowEffect(
+  deps: AutonomousJobDeps,
+  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.',
     )
     if (!row) {
-      throw new Error(`Autonomous job not found: ${recordIdToString(jobId, TABLES.AUTONOMOUS_JOB)}`)
+      return yield* new AutonomousJobServiceError({
+        message: `Autonomous job not found: ${recordIdToString(jobId, TABLES.AUTONOMOUS_JOB)}`,
+      })
     }
     return row
-  }
+  })
+}
 
-  private async getRunRow(runId: RecordIdInput): Promise<AutonomousJobRunRow> {
-    await databaseService.connect()
-    const row = await databaseService.findOne(
-      TABLES.AUTONOMOUS_JOB_RUN,
-      { id: ensureRecordId(runId, TABLES.AUTONOMOUS_JOB_RUN) },
-      AutonomousJobRunRowSchema,
+function getRunRowEffect(
+  deps: AutonomousJobDeps,
+  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.',
     )
     if (!row) {
-      throw new Error(`Autonomous job run not found: ${recordIdToString(runId, TABLES.AUTONOMOUS_JOB_RUN)}`)
+      return yield* new AutonomousJobServiceError({
+        message: `Autonomous job run not found: ${recordIdToString(runId, TABLES.AUTONOMOUS_JOB_RUN)}`,
+      })
     }
     return row
-  }
-
-  private async unscheduleRow(row: AutonomousJobRow): Promise<void> {
-    if (row.schedule.kind === 'at') {
-      const { removeAutonomousAtJob } = await import('../queues/autonomous-job.queue')
-      await removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB))
-      return
-    }
+  })
+}
 
-    const { removeAutonomousJobScheduler } = await import('../queues/autonomous-job.queue')
-    await removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB))
+function unscheduleRowEffect(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)),
+        'Failed to remove autonomous at-job.',
+      )
+    })
   }
 
-  private async findRecoverableRunRow(autonomousJobId: RecordIdInput): Promise<AutonomousJobRunRow | null> {
-    const rows = await databaseService.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,
+  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)),
+      'Failed to remove autonomous job scheduler.',
     )
+  })
+}
 
+function findRecoverableRunRowEffect(
+  deps: AutonomousJobDeps,
+  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}
+            WHERE autonomousJobId = $autonomousJobId
+              AND status IN $statuses
+            ORDER BY createdAt DESC
+            LIMIT 1`,
+            {
+              autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB),
+              statuses: ['queued', 'running'],
+            },
+          ),
+          AutonomousJobRunRowSchema,
+        ),
+      'Failed to find recoverable autonomous job run.',
+    )
     return rows[0] ?? null
-  }
+  })
+}
 
-  private async scheduleRow(
-    row: AutonomousJobRow,
-    options: { runImmediate?: boolean; referenceTime?: Date; reusePendingAtRun?: boolean } = {},
-  ): Promise<void> {
-    const jobId = recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)
-    const referenceTime = options.referenceTime ?? new Date()
-    const nextRunAt =
-      row.schedule.kind === 'at'
-        ? (row.nextRunAt ?? this.computeNextRunAt(row.schedule, referenceTime))
-        : this.computeNextRunAt(row.schedule, referenceTime)
-
-    if (row.schedule.kind === 'at') {
-      const queuedRun = options.reusePendingAtRun
-        ? ((await this.findRecoverableRunRow(row.id)) ??
-          (await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })))
-        : await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })
-      const { enqueueAutonomousJobRun } = await import('../queues/autonomous-job.queue')
-      const enqueueResult = await enqueueAutonomousJobRun({
-        payload: {
-          autonomousJobId: jobId,
-          autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
-          trigger: 'scheduled',
-        },
-        delayMs: Math.max(0, (nextRunAt ?? referenceTime).getTime() - referenceTime.getTime()),
-        jobId: buildAutonomousAtJobId(jobId),
-      })
+function scheduleRowEffect(
+  deps: AutonomousJobDeps,
+  row: AutonomousJobRow,
+  options: { runImmediate?: boolean; referenceTime?: Date; reusePendingAtRun?: boolean } = {},
+): Effect.Effect<void, AutonomousJobServiceError> {
+  const jobId = recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)
+  const referenceTime = options.referenceTime ?? nowDate()
+  const nextRunAt =
+    row.schedule.kind === 'at'
+      ? (row.nextRunAt ?? computeNextRunAt(row.schedule, referenceTime))
+      : computeNextRunAt(row.schedule, referenceTime)
 
-      if (enqueueResult.queueJobId) {
-        await databaseService.update(
-          TABLES.AUTONOMOUS_JOB_RUN,
-          queuedRun.id,
-          { queueJobId: ensureRecordId(enqueueResult.queueJobId, TABLES.QUEUE_JOB) },
-          AutonomousJobRunRowSchema,
+  if (row.schedule.kind === 'at') {
+    return Effect.gen(function* () {
+      const queuedRun = yield* options.reusePendingAtRun
+        ? Effect.gen(function* () {
+            const recoverable = yield* findRecoverableRunRowEffect(deps, row.id)
+            return recoverable ?? (yield* createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId }))
+          })
+        : 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({
+            payload: {
+              autonomousJobId: jobId,
+              autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
+              trigger: 'scheduled',
+            },
+            delayMs: Math.max(0, (nextRunAt ?? referenceTime).getTime() - referenceTime.getTime()),
+            jobId: buildAutonomousAtJobId(jobId),
+          }),
+        'Failed to enqueue autonomous job run.',
+      )
+
+      const queueJobId = enqueueResult.queueJobId
+      if (queueJobId) {
+        yield* effectTryPromise(
+          () =>
+            deps.db.update(
+              TABLES.AUTONOMOUS_JOB_RUN,
+              queuedRun.id,
+              { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
+              AutonomousJobRunRowSchema,
+            ),
+          'Failed to persist autonomous job run queue job id.',
         )
       }
-    } else {
-      const { upsertAutonomousJobScheduler } = await import('../queues/autonomous-job.queue')
-      await upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: row.schedule })
 
-      if (options.runImmediate ?? row.schedule.immediately) {
-        await this.runNow(jobId)
+      yield* effectTryPromise(
+        () =>
+          deps.db.update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema),
+        'Failed to update autonomous job next run time.',
+      )
+    })
+  } 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 }),
+        'Failed to upsert autonomous job scheduler.',
+      )
+
+      if (options.runImmediate ?? recurringSchedule.immediately) {
+        yield* runNowEffect(deps, jobId).pipe(Effect.asVoid)
       }
-    }
 
-    await databaseService.update(
-      TABLES.AUTONOMOUS_JOB,
-      row.id,
-      { nextRunAt: nextRunAt ?? undefined },
-      AutonomousJobRowSchema,
-    )
+      yield* effectTryPromise(
+        () =>
+          deps.db.update(TABLES.AUTONOMOUS_JOB, row.id, { nextRunAt: nextRunAt ?? undefined }, AutonomousJobRowSchema),
+        'Failed to update autonomous job next run time.',
+      )
+    })
   }
+}
 
-  async create(input: CreateAutonomousJobInput): Promise<AutonomousJob> {
-    await databaseService.connect()
+function createEffect(
+  deps: AutonomousJobDeps,
+  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)
     const organizationId = ensureRecordId(parsed.organizationId, TABLES.ORGANIZATION)
     const ownerUserId = ensureRecordId(parsed.ownerUserId, TABLES.USER)
-    const thread = await threadService.createThread({
-      userId: ownerUserId,
-      organizationId,
-      type: 'group',
-      title: parsed.threadTitle ?? parsed.title,
-    })
+    const thread = yield* deps.thread
+      .createThread({ userId: ownerUserId, organizationId, type: 'group', title: parsed.threadTitle ?? parsed.title })
+      .pipe(
+        Effect.mapError(
+          (cause) => new AutonomousJobServiceError({ message: 'Failed to create autonomous job thread.', cause }),
+        ),
+      )
+
     const jobId = new RecordId(TABLES.AUTONOMOUS_JOB, Bun.randomUUIDv7())
-    const nextRunAt = this.computeNextRunAt(parsed.schedule)
-    const created = await databaseService.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,
+    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.',
     )
 
-    await this.scheduleRow(created)
-    return this.toPublicJob(await this.getRow(created.id))
-  }
+    yield* scheduleRowEffect(deps, created)
+    const row = yield* getRowEffect(deps, created.id)
+    return toPublicJob(row)
+  })
+}
 
-  async recoverActiveJobs(now = new Date()): Promise<void> {
-    await databaseService.connect()
-    const activeRows = await databaseService.queryMany(
-      new BoundQuery(`SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`, {
-        status: 'active',
-      }),
-      AutonomousJobRowSchema,
+function recoverActiveJobsEffect(
+  deps: AutonomousJobDeps,
+  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* Effect.forEach(activeRows, (row) =>
+      scheduleRowEffect(deps, row, { runImmediate: false, referenceTime: now, reusePendingAtRun: true }),
+    )
+  })
+}
 
-    for (const row of activeRows) {
-      await this.scheduleRow(row, { runImmediate: false, referenceTime: now, reusePendingAtRun: true })
-    }
-  }
-
-  async get(jobId: RecordIdInput): Promise<AutonomousJob> {
-    return this.toPublicJob(await this.getRow(jobId))
-  }
+function getEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const row = yield* getRowEffect(deps, jobId)
+    return toPublicJob(row)
+  })
+}
 
-  async list(params: {
-    organizationId: RecordIdInput
-    ownerUserId?: RecordIdInput
-    status?: AutonomousJobStatus
-  }): Promise<AutonomousJob[]> {
-    await databaseService.connect()
-    const rows = await databaseService.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' },
+function listEffect(
+  deps: AutonomousJobDeps,
+  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.',
     )
-    return rows.map((row) => this.toPublicJob(row))
-  }
+    return rows.map((row) => toPublicJob(row))
+  })
+}
 
-  async update(jobId: RecordIdInput, input: UpdateAutonomousJobInput): Promise<AutonomousJob> {
+function updateEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+  input: UpdateAutonomousJobInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
     const parsed = UpdateAutonomousJobInputSchema.parse(input)
-    const existing = await this.getRow(jobId)
-    await this.unscheduleRow(existing)
-
-    if (parsed.title && compactWhitespace(parsed.title) !== compactWhitespace(existing.title)) {
-      await threadService.updateTitle(existing.threadId, parsed.title)
+    const existing = yield* getRowEffect(deps, jobId)
+    yield* unscheduleRowEffect(existing)
+    const nextTitle = parsed.title
+    if (typeof nextTitle === 'string' && compactWhitespace(nextTitle) !== compactWhitespace(existing.title)) {
+      const title = nextTitle
+      yield* deps.thread
+        .updateTitle(existing.threadId, title)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new AutonomousJobServiceError({ message: 'Failed to update autonomous job thread title.', cause }),
+          ),
+        )
     }
 
-    const nextRunAt = this.computeNextRunAt(parsed.schedule ?? existing.schedule)
-    const updated = await databaseService.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,
+    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.',
     )
     if (!updated) {
-      throw new Error(`Failed to update autonomous job: ${recordIdToString(existing.id, TABLES.AUTONOMOUS_JOB)}`)
+      return yield* new AutonomousJobServiceError({
+        message: `Failed to update autonomous job: ${recordIdToString(existing.id, TABLES.AUTONOMOUS_JOB)}`,
+      })
     }
 
     if (updated.status === 'active') {
-      await this.scheduleRow(updated)
+      yield* scheduleRowEffect(deps, updated)
     }
-    return this.toPublicJob(await this.getRow(updated.id))
-  }
 
-  async pause(jobId: RecordIdInput): Promise<AutonomousJob> {
-    const row = await this.getRow(jobId)
-    await this.unscheduleRow(row)
-    await databaseService.update(
-      TABLES.AUTONOMOUS_JOB,
-      row.id,
-      { status: 'paused', nextRunAt: undefined },
-      AutonomousJobRowSchema,
+    const row = yield* getRowEffect(deps, updated.id)
+    return toPublicJob(row)
+  })
+}
+
+function pauseEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const row = yield* getRowEffect(deps, jobId)
+    yield* unscheduleRowEffect(row)
+    yield* effectTryPromise(
+      () =>
+        deps.db.update(
+          TABLES.AUTONOMOUS_JOB,
+          row.id,
+          { status: 'paused', nextRunAt: undefined },
+          AutonomousJobRowSchema,
+        ),
+      'Failed to pause autonomous job.',
     )
-    return this.toPublicJob(await this.getRow(row.id))
-  }
+    const updatedRow = yield* getRowEffect(deps, row.id)
+    return toPublicJob(updatedRow)
+  })
+}
 
-  async resume(jobId: RecordIdInput): Promise<AutonomousJob> {
-    const row = await this.getRow(jobId)
-    const nextRunAt = this.computeNextRunAt(row.schedule)
-    const resumed = await databaseService.update(
-      TABLES.AUTONOMOUS_JOB,
-      row.id,
-      { status: 'active', nextRunAt: nextRunAt ?? undefined },
-      AutonomousJobRowSchema,
+function resumeEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  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.',
     )
     if (!resumed) {
-      throw new Error(`Failed to resume autonomous job: ${recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)}`)
+      return yield* new AutonomousJobServiceError({
+        message: `Failed to resume autonomous job: ${recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)}`,
+      })
     }
-    await this.scheduleRow(resumed)
-    return this.toPublicJob(await this.getRow(resumed.id))
-  }
+    yield* scheduleRowEffect(deps, resumed)
+    const updatedRow = yield* getRowEffect(deps, resumed.id)
+    return toPublicJob(updatedRow)
+  })
+}
 
-  async runNow(jobId: RecordIdInput): Promise<AutonomousJobRun> {
-    const row = await this.getRow(jobId)
-    const queuedRun = await this.createRunRow({ autonomousJobId: row.id, threadId: row.threadId })
-    const { enqueueAutonomousJobRun } = await import('../queues/autonomous-job.queue')
-    const enqueueResult = await enqueueAutonomousJobRun({
-      payload: {
-        autonomousJobId: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
-        autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
-        trigger: 'manual',
-      },
-      jobId: buildAutonomousManualJobId(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
-    })
+function runNowEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJobRun, AutonomousJobServiceError> {
+  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.',
+    )
 
-    if (enqueueResult.queueJobId) {
-      await databaseService.update(
-        TABLES.AUTONOMOUS_JOB_RUN,
-        queuedRun.id,
-        { queueJobId: ensureRecordId(enqueueResult.queueJobId, TABLES.QUEUE_JOB) },
-        AutonomousJobRunRowSchema,
+    const enqueueResult = yield* effectTryPromise(
+      () =>
+        enqueueAutonomousJobRun({
+          payload: {
+            autonomousJobId: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
+            autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
+            trigger: 'manual',
+          },
+          jobId: buildAutonomousManualJobId(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+        }),
+      'Failed to enqueue autonomous job run.',
+    )
+
+    const queueJobId = enqueueResult.queueJobId
+    if (queueJobId) {
+      yield* effectTryPromise(
+        () =>
+          deps.db.update(
+            TABLES.AUTONOMOUS_JOB_RUN,
+            queuedRun.id,
+            { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB) },
+            AutonomousJobRunRowSchema,
+          ),
+        'Failed to persist autonomous job run queue job id.',
       )
     }
 
-    return this.toPublicRun(await this.getRunRow(queuedRun.id))
-  }
+    const runRow = yield* getRunRowEffect(deps, queuedRun.id)
+    return toPublicRun(runRow)
+  })
+}
 
-  async cancel(jobId: RecordIdInput): Promise<AutonomousJob> {
-    const row = await this.getRow(jobId)
-    await this.unscheduleRow(row)
-    await databaseService.update(
-      TABLES.AUTONOMOUS_JOB,
-      row.id,
-      { status: 'cancelled', nextRunAt: undefined },
-      AutonomousJobRowSchema,
+function cancelEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const row = yield* getRowEffect(deps, jobId)
+    yield* unscheduleRowEffect(row)
+    yield* effectTryPromise(
+      () =>
+        deps.db.update(
+          TABLES.AUTONOMOUS_JOB,
+          row.id,
+          { status: 'cancelled', nextRunAt: undefined },
+          AutonomousJobRowSchema,
+        ),
+      'Failed to cancel autonomous job.',
     )
-    return this.toPublicJob(await this.getRow(row.id))
-  }
+    const updatedRow = yield* getRowEffect(deps, row.id)
+    return toPublicJob(updatedRow)
+  })
+}
 
-  async delete(jobId: RecordIdInput): Promise<AutonomousJob> {
-    const row = await this.getRow(jobId)
-    const cancelled = await this.cancel(row.id)
-    await threadService.updateStatus(row.threadId, 'archived')
+function deleteJobEffect(
+  deps: AutonomousJobDeps,
+  jobId: RecordIdInput,
+): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const row = yield* getRowEffect(deps, jobId)
+    const cancelled = yield* cancelEffect(deps, row.id)
+    yield* deps.thread
+      .updateStatus(row.threadId, 'archived')
+      .pipe(
+        Effect.mapError(
+          (cause) => new AutonomousJobServiceError({ message: 'Failed to archive autonomous job thread.', cause }),
+        ),
+      )
     return cancelled
-  }
+  })
+}
 
-  async listRuns(jobId: RecordIdInput): Promise<AutonomousJobRun[]> {
-    await databaseService.connect()
-    const rows = await databaseService.findMany(
-      TABLES.AUTONOMOUS_JOB_RUN,
-      { autonomousJobId: ensureRecordId(jobId, TABLES.AUTONOMOUS_JOB) },
-      AutonomousJobRunRowSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC' },
+function listRunsEffect(
+  deps: AutonomousJobDeps,
+  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.',
     )
-    return rows.map((row) => this.toPublicRun(row))
-  }
-
-  async executeQueuedRun(job: Job<AutonomousJobQueuePayload>): Promise<{ status: string; summary?: string }> {
-    await databaseService.connect()
+    return rows.map((row) => toPublicRun(row))
+  })
+}
 
-    const autonomousJobRow = await this.getRow(job.data.autonomousJobId)
-    const queueJobId = queueJobService.getQueueJobId(AUTONOMOUS_JOB_QUEUE_NAME, String(job.id))
-    let runRow =
+function getOrCreateQueuedRunRowEffect(
+  deps: AutonomousJobDeps,
+  job: Job<AutonomousJobQueuePayload>,
+  currentJobRow: AutonomousJobRow,
+): Effect.Effect<{ queueJobId: string; runRow: AutonomousJobRunRow }, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const queueJobId = deps.queueJob.getQueueJobId(AUTONOMOUS_JOB_QUEUE_NAME, String(job.id))
+    const runRow =
       job.data.autonomousJobRunId !== undefined
-        ? await this.getRunRow(job.data.autonomousJobRunId)
-        : await this.createRunRow({
-            autonomousJobId: autonomousJobRow.id,
-            threadId: autonomousJobRow.threadId,
+        ? yield* getRunRowEffect(deps, job.data.autonomousJobRunId)
+        : yield* createRunRowEffect(deps, {
+            autonomousJobId: currentJobRow.id,
+            threadId: currentJobRow.threadId,
             queueJobId,
             status: 'queued',
           })
 
-    const activeStatus = autonomousJobRow.status
-    if (activeStatus !== 'active' && job.data.trigger === 'scheduled') {
-      return { status: 'skipped' }
+    return { queueJobId, runRow }
+  })
+}
+
+function markQueuedRunRunningEffect(
+  deps: AutonomousJobDeps,
+  runRow: AutonomousJobRunRow,
+  queueJobId: string,
+): Effect.Effect<AutonomousJobRunRow, AutonomousJobServiceError> {
+  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.',
+    )
+
+    return updatedRunRow ?? runRow
+  })
+}
+
+function completeQueuedRunEffect(
+  deps: AutonomousJobDeps,
+  params: {
+    job: Job<AutonomousJobQueuePayload>
+    currentJobRow: AutonomousJobRow
+    currentRunRow: AutonomousJobRunRow
+    turnResult: PreparedThreadTurnResult
+    activePlan: ActiveExecutionPlan
+  },
+): Effect.Effect<{ status: AutonomousJobRunStatus; summary: string }, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const { job, currentJobRow, currentRunRow, turnResult, activePlan } = params
+    const runStatus: AutonomousJobRunStatus = activePlan?.status === 'awaiting-human' ? 'awaiting-human' : 'completed'
+    const summary = truncateText(
+      turnResult.assistantMessages
+        .map((message) => extractMessageText(message))
+        .filter(Boolean)
+        .join('\n\n')
+        .trim() || `${currentJobRow.title} completed.`,
+      2_000,
+    )
+    const completedAt = nowDate()
+
+    void (yield* effectTryPromise(
+      () =>
+        deps.db.update(
+          TABLES.AUTONOMOUS_JOB_RUN,
+          currentRunRow.id,
+          compactRecord({
+            status: runStatus,
+            inputMessageId: turnResult.inputMessageId,
+            assistantMessageIds: turnResult.assistantMessages.map((message) => message.id),
+            summary,
+            linkedPlanSpecId: activePlan?.specId ? ensureRecordId(activePlan.specId, TABLES.PLAN_SPEC) : undefined,
+            linkedPlanRunId: activePlan?.runId ? ensureRecordId(activePlan.runId, TABLES.PLAN_RUN) : undefined,
+            completedAt,
+          }),
+          AutonomousJobRunRowSchema,
+        ),
+      'Failed to update autonomous job run completion.',
+    ))
+
+    const nextRunAt =
+      job.data.trigger === 'scheduled' && currentJobRow.schedule.kind !== 'at'
+        ? computeNextRunAt(currentJobRow.schedule, completedAt)
+        : currentJobRow.nextRunAt
+    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,
+        ),
+      'Failed to update autonomous job after successful run.',
+    )
+
+    yield* maybeNotifyEffect(deps, {
+      organizationId: recordIdToString(currentJobRow.organizationId, TABLES.ORGANIZATION),
+      threadId: recordIdToString(currentJobRow.threadId, TABLES.THREAD),
+      severity: 'info',
+      title: `${currentJobRow.title} completed`,
+      body: summary,
+      metadata: {
+        autonomousJobId: params.job.data.autonomousJobId,
+        runId: recordIdToString(currentRunRow.id, TABLES.AUTONOMOUS_JOB_RUN),
+      },
+    })
+
+    return { status: runStatus, summary }
+  })
+}
+
+function failQueuedRunEffect(
+  deps: AutonomousJobDeps,
+  params: {
+    job: Job<AutonomousJobQueuePayload>
+    currentJobRow: AutonomousJobRow
+    currentRunRow: AutonomousJobRunRow
+    error: unknown
+  },
+): Effect.Effect<never, AutonomousJobServiceError> {
+  return Effect.gen(function* () {
+    const { job, currentJobRow, currentRunRow, error } = params
+    const normalizedError = toQueueJobError(error)
+    const completedAt = nowDate()
+    const nextConsecutiveErrorCount = currentJobRow.consecutiveErrorCount + 1
+    const autoPause = nextConsecutiveErrorCount >= currentJobRow.autoPauseThreshold
+    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.',
+    )
+
+    if (autoPause || terminalOneShot) {
+      yield* unscheduleRowEffect(currentJobRow)
     }
 
-    const startedAt = new Date()
-    runRow =
-      (await databaseService.update(
-        TABLES.AUTONOMOUS_JOB_RUN,
-        runRow.id,
-        { queueJobId: ensureRecordId(queueJobId, TABLES.QUEUE_JOB), status: 'running', startedAt },
-        AutonomousJobRunRowSchema,
-      )) ?? runRow
-
-    try {
-      const thread = await threadService.getThread(autonomousJobRow.threadId)
-      const inputMessage = this.buildSyntheticUserMessage(autonomousJobRow.prompt)
-      const turnResult = await runThreadTurnInBackground({
-        thread,
-        threadRef: ensureRecordId(autonomousJobRow.threadId, TABLES.THREAD),
-        orgRef: ensureRecordId(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
-        userRef: ensureRecordId(autonomousJobRow.ownerUserId, TABLES.USER),
-        userName: autonomousJobRow.ownerUserName,
-        agentIdOverride: autonomousJobRow.agentId,
-        inputMessage,
-      })
-      const activePlan = await executionPlanService.getActivePlanForThread(autonomousJobRow.threadId)
-      const runStatus: AutonomousJobRunStatus = activePlan?.status === 'awaiting-human' ? 'awaiting-human' : 'completed'
-      const summary = truncateText(
-        turnResult.assistantMessages
-          .map((message) => extractMessageText(message))
-          .filter(Boolean)
-          .join('\n\n')
-          .trim() || `${autonomousJobRow.title} completed.`,
-        2_000,
-      )
-      const completedAt = new Date()
+    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,
+        ),
+      'Failed to update autonomous job failure state.',
+    )
 
-      await databaseService.update(
-        TABLES.AUTONOMOUS_JOB_RUN,
-        runRow.id,
-        compactRecord({
-          status: runStatus,
-          inputMessageId: turnResult.inputMessageId,
-          assistantMessageIds: turnResult.assistantMessages.map((message) => message.id),
-          summary,
-          linkedPlanSpecId: activePlan?.specId ? ensureRecordId(activePlan.specId, TABLES.PLAN_SPEC) : undefined,
-          linkedPlanRunId: activePlan?.runId ? ensureRecordId(activePlan.runId, TABLES.PLAN_RUN) : undefined,
-          completedAt,
-        }),
-        AutonomousJobRunRowSchema,
-      )
+    yield* maybeNotifyEffect(deps, {
+      organizationId: recordIdToString(currentJobRow.organizationId, TABLES.ORGANIZATION),
+      threadId: recordIdToString(currentJobRow.threadId, TABLES.THREAD),
+      severity: 'warning',
+      title: autoPause ? `${currentJobRow.title} paused after repeated failures` : `${currentJobRow.title} failed`,
+      body: normalizedError.message,
+      metadata: {
+        autonomousJobId: job.data.autonomousJobId,
+        runId: recordIdToString(currentRunRow.id, TABLES.AUTONOMOUS_JOB_RUN),
+        autoPaused: autoPause,
+      },
+    })
 
-      const nextRunAt =
-        job.data.trigger === 'scheduled' && autonomousJobRow.schedule.kind !== 'at'
-          ? this.computeNextRunAt(autonomousJobRow.schedule, completedAt)
-          : autonomousJobRow.nextRunAt
-      const nextStatus =
-        autonomousJobRow.schedule.kind === 'at' && job.data.trigger === 'scheduled'
-          ? 'completed'
-          : autonomousJobRow.status
-
-      await databaseService.update(
-        TABLES.AUTONOMOUS_JOB,
-        autonomousJobRow.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,
-      )
+    return yield* new AutonomousJobServiceError({ message: normalizedError.message, cause: error })
+  })
+}
 
-      await this.maybeNotify('notify', {
-        organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
-        threadId: recordIdToString(autonomousJobRow.threadId, TABLES.THREAD),
-        severity: 'info',
-        title: `${autonomousJobRow.title} completed`,
-        body: summary,
-        metadata: {
-          autonomousJobId: job.data.autonomousJobId,
-          runId: recordIdToString(runRow.id, TABLES.AUTONOMOUS_JOB_RUN),
-        },
-      })
+function executeQueuedRunEffect(
+  deps: AutonomousJobDeps,
+  job: Job<AutonomousJobQueuePayload>,
+): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError> {
+  let autonomousJobRow: AutonomousJobRow | null = null
+  let runRow: AutonomousJobRunRow | null = null
 
-      return { status: runStatus, summary }
-    } catch (error) {
-      const normalizedError = toQueueJobError(error)
-      const completedAt = new Date()
-      const nextConsecutiveErrorCount = autonomousJobRow.consecutiveErrorCount + 1
-      const autoPause = nextConsecutiveErrorCount >= autonomousJobRow.autoPauseThreshold
-      const terminalOneShot = autonomousJobRow.schedule.kind === 'at' && job.data.trigger === 'scheduled'
-      const nextStatus: AutonomousJobStatus = terminalOneShot
-        ? 'failed'
-        : autoPause
-          ? 'paused'
-          : autonomousJobRow.status
-
-      await databaseService.update(
-        TABLES.AUTONOMOUS_JOB_RUN,
-        runRow.id,
-        { status: 'failed', error: normalizedError, completedAt },
-        AutonomousJobRunRowSchema,
-      )
+  return Effect.gen(function* () {
+    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
+    autonomousJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
+    const currentJobRow = autonomousJobRow
+    const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
 
-      if (autoPause || terminalOneShot) {
-        await this.unscheduleRow(autonomousJobRow)
-      }
+    runRow = initialRunRow
+    if (currentJobRow.status !== 'active' && job.data.trigger === 'scheduled') {
+      return { status: 'skipped' }
+    }
 
-      await databaseService.update(
-        TABLES.AUTONOMOUS_JOB,
-        autonomousJobRow.id,
-        compactRecord({
-          status: nextStatus,
-          consecutiveErrorCount: nextConsecutiveErrorCount,
-          lastRunStatus: 'failed',
-          lastRunAt: completedAt,
-          nextRunAt:
-            nextStatus === 'active' && autonomousJobRow.schedule.kind !== 'at'
-              ? (this.computeNextRunAt(autonomousJobRow.schedule, completedAt) ?? undefined)
-              : undefined,
-          lastError: normalizedError,
+    runRow = yield* markQueuedRunRunningEffect(deps, initialRunRow, queueJobId)
+    const currentRunRow = runRow
+    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 }),
+          ),
+        ),
+      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,
         }),
-        AutonomousJobRowSchema,
+      'Failed to run autonomous job thread turn.',
+    )
+
+    const activePlan = yield* deps.executionPlan
+      .getActivePlanForThread(currentJobRow.threadId)
+      .pipe(
+        Effect.mapError(
+          (cause) => new AutonomousJobServiceError({ message: 'Failed to load active execution plan.', cause }),
+        ),
       )
 
-      await this.maybeNotify('notify', {
-        organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
-        threadId: recordIdToString(autonomousJobRow.threadId, TABLES.THREAD),
-        severity: 'warning',
-        title: autoPause
-          ? `${autonomousJobRow.title} paused after repeated failures`
-          : `${autonomousJobRow.title} failed`,
-        body: normalizedError.message,
-        metadata: {
-          autonomousJobId: job.data.autonomousJobId,
-          runId: recordIdToString(runRow.id, TABLES.AUTONOMOUS_JOB_RUN),
-          autoPaused: autoPause,
-        },
-      })
+    return yield* completeQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, turnResult, activePlan })
+  }).pipe(
+    Effect.catch((error: unknown) =>
+      Effect.gen(function* () {
+        const currentJobRow = autonomousJobRow
+        const currentRunRow = runRow
+        if (!currentJobRow || !currentRunRow) {
+          return yield* new AutonomousJobServiceError({ message: 'Failed to execute autonomous job.', cause: error })
+        }
+        return yield* failQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, error })
+      }),
+    ),
+  )
+}
 
-      throw error
-    }
-  }
+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),
+  } as const
+}
+
+interface AutonomousJobDeps {
+  db: SurrealDBService
+  config: ResolvedLotaRuntimeConfig
+  executionPlan: ReturnType<typeof makeExecutionPlanService>
+  queueJob: ReturnType<typeof makeQueueJobService>
+  thread: ReturnType<typeof makeThreadService>
 }
 
-export const autonomousJobService = new AutonomousJobService()
+export function makeAutonomousJobService(deps: AutonomousJobDeps) {
+  return createAutonomousJobService(deps)
+}
+
+export class AutonomousJobServiceTag extends Context.Service<
+  AutonomousJobServiceTag,
+  ReturnType<typeof makeAutonomousJobService>
+>()('AutonomousJobService') {}
+
+export const AutonomousJobServiceLive = Layer.effect(
+  AutonomousJobServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const config = yield* RuntimeConfigServiceTag
+    const executionPlan = yield* ExecutionPlanServiceTag
+    const queueJob = yield* QueueJobServiceTag
+    const thread = yield* ThreadServiceTag
+    return makeAutonomousJobService({ db, config, executionPlan, queueJob, thread })
+  }),
+)