@lota-sdk/core 0.1.19 → 0.1.20

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

@@ -0,0 +1,692 @@
+import {
+  AutonomousJobRunSchema,
+  AutonomousJobRunStatusSchema,
+  AutonomousJobScheduleSchema,
+  AutonomousJobSchema,
+  AutonomousJobStatusSchema,
+  CreateAutonomousJobInputSchema,
+  QueueJobErrorSchema,
+  UpdateAutonomousJobInputSchema,
+  recordIdSchema,
+} from '@lota-sdk/shared'
+import type {
+  AutonomousJob,
+  AutonomousJobRun,
+  AutonomousJobRunStatus,
+  AutonomousJobSchedule,
+  AutonomousJobStatus,
+  ChatMessage,
+  CreateAutonomousJobInput,
+  QueueJobError,
+  UpdateAutonomousJobInput,
+} from '@lota-sdk/shared'
+import type { Job } from 'bullmq'
+import { CronExpressionParser } from 'cron-parser'
+import { 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 { TABLES } from '../db/tables'
+import type { AutonomousJobQueuePayload } from '../queues/autonomous-job.queue'
+import { extractMessageText } from '../runtime/workstream-chat-helpers'
+import { toIsoDateTimeString, toOptionalIsoDateTimeString } 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 { runWorkstreamTurnInBackground } from './workstream-turn'
+import { workstreamService } from './workstream.service'
+
+const AUTONOMOUS_JOB_QUEUE_NAME = 'autonomous-job'
+
+function encodeBullmqId(raw: string): string {
+  return Buffer.from(raw).toString('base64url')
+}
+
+function buildAutonomousAtJobId(autonomousJobId: string): string {
+  return `autonomous-at-${encodeBullmqId(autonomousJobId)}`
+}
+
+function buildAutonomousManualJobId(autonomousJobId: string): string {
+  return `autonomous-manual-${encodeBullmqId(autonomousJobId)}-${Date.now()}`
+}
+
+const AutonomousJobRowSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  ownerUserId: recordIdSchema,
+  ownerUserName: z.string().optional(),
+  workstreamId: recordIdSchema,
+  agentId: z.string(),
+  title: z.string(),
+  prompt: z.string(),
+  schedule: AutonomousJobScheduleSchema,
+  status: AutonomousJobStatusSchema,
+  autoPauseThreshold: z.number().int().positive(),
+  consecutiveErrorCount: z.number().int().nonnegative(),
+  lastRunStatus: AutonomousJobRunStatusSchema.optional(),
+  lastRunAt: z.coerce.date().optional(),
+  nextRunAt: z.coerce.date().optional(),
+  linkedPlanSpecId: recordIdSchema.optional(),
+  linkedPlanRunId: recordIdSchema.optional(),
+  lastError: QueueJobErrorSchema.optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+const AutonomousJobRunRowSchema = z.object({
+  id: recordIdSchema,
+  autonomousJobId: recordIdSchema,
+  workstreamId: recordIdSchema,
+  queueJobId: recordIdSchema.optional(),
+  status: AutonomousJobRunStatusSchema,
+  inputMessageId: z.string().optional(),
+  assistantMessageIds: z.array(z.string()).default([]),
+  summary: z.string().optional(),
+  error: QueueJobErrorSchema.optional(),
+  linkedPlanSpecId: recordIdSchema.optional(),
+  linkedPlanRunId: recordIdSchema.optional(),
+  startedAt: z.coerce.date().optional(),
+  completedAt: z.coerce.date().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+type AutonomousJobRow = z.infer<typeof AutonomousJobRowSchema>
+type AutonomousJobRunRow = z.infer<typeof AutonomousJobRunRowSchema>
+
+function toQueueJobError(error: unknown): QueueJobError {
+  if (error instanceof Error) {
+    return QueueJobErrorSchema.parse(
+      compactRecord({
+        name: error.name || undefined,
+        message: truncateText(error.message || 'Unknown error', 5_000),
+        stack: typeof error.stack === 'string' ? truncateText(error.stack, 20_000) : undefined,
+      }),
+    )
+  }
+
+  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,
+      workstreamId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
+      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),
+      workstreamId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
+      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)
+        return Number.isNaN(at.getTime()) ? null : at
+      }
+      default:
+        return null
+    }
+  }
+
+  private async maybeNotify(
+    kind: 'notify',
+    params: {
+      organizationId: string
+      workstreamId: 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
+    }
+  }
+
+  private buildSyntheticUserMessage(prompt: string): ChatMessage {
+    return {
+      id: Bun.randomUUIDv7(),
+      role: 'user',
+      parts: [{ type: 'text', text: prompt }],
+      metadata: { createdAt: Date.now() },
+    }
+  }
+
+  private async createRunRow(params: {
+    autonomousJobId: RecordIdInput
+    workstreamId: 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),
+        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        queueJobId: params.queueJobId ? ensureRecordId(params.queueJobId, TABLES.QUEUE_JOB) : undefined,
+        status: params.status ?? 'queued',
+        assistantMessageIds: [],
+      }),
+      AutonomousJobRunRowSchema,
+    )
+  }
+
+  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,
+    )
+    if (!row) {
+      throw new Error(`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,
+    )
+    if (!row) {
+      throw new Error(`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))
+  }
+
+  private async findRecoverableRunRow(autonomousJobId: RecordIdInput): Promise<AutonomousJobRunRow | null> {
+    const rows = await databaseService.queryMany(
+      {
+        query: `SELECT * FROM ${TABLES.AUTONOMOUS_JOB_RUN}
+          WHERE autonomousJobId = $autonomousJobId
+            AND status IN $statuses
+          ORDER BY createdAt DESC
+          LIMIT 1`,
+        bindings: {
+          autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB),
+          statuses: ['queued', 'running'],
+        },
+      },
+      AutonomousJobRunRowSchema,
+    )
+
+    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, workstreamId: row.workstreamId })))
+        : await this.createRunRow({ autonomousJobId: row.id, workstreamId: row.workstreamId })
+      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),
+      })
+
+      await databaseService.update(
+        TABLES.AUTONOMOUS_JOB_RUN,
+        queuedRun.id,
+        { queueJobId: ensureRecordId(enqueueResult.queueJobId, TABLES.QUEUE_JOB) },
+        AutonomousJobRunRowSchema,
+      )
+    } 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)
+      }
+    }
+
+    await databaseService.update(
+      TABLES.AUTONOMOUS_JOB,
+      row.id,
+      { nextRunAt: nextRunAt ?? undefined },
+      AutonomousJobRowSchema,
+    )
+  }
+
+  async create(input: CreateAutonomousJobInput): Promise<AutonomousJob> {
+    await databaseService.connect()
+    const parsed = CreateAutonomousJobInputSchema.parse(input)
+    const organizationId = ensureRecordId(parsed.organizationId, TABLES.ORGANIZATION)
+    const ownerUserId = ensureRecordId(parsed.ownerUserId, TABLES.USER)
+    const workstream = await workstreamService.createWorkstream(ownerUserId, organizationId, {
+      mode: 'group',
+      core: false,
+      title: parsed.workstreamTitle ?? parsed.title,
+    })
+    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,
+        workstreamId: ensureRecordId(workstream.id, TABLES.WORKSTREAM),
+        agentId: parsed.agentId,
+        title: parsed.title,
+        prompt: parsed.prompt,
+        schedule: parsed.schedule,
+        status: 'active',
+        autoPauseThreshold: parsed.autoPauseThreshold,
+        consecutiveErrorCount: 0,
+        nextRunAt: nextRunAt ?? undefined,
+      }),
+      AutonomousJobRowSchema,
+    )
+
+    await this.scheduleRow(created)
+    return this.toPublicJob(await this.getRow(created.id))
+  }
+
+  async recoverActiveJobs(now = new Date()): Promise<void> {
+    await databaseService.connect()
+    const activeRows = await databaseService.queryMany(
+      {
+        query: `SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`,
+        bindings: { status: 'active' },
+      },
+      AutonomousJobRowSchema,
+    )
+
+    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))
+  }
+
+  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' },
+    )
+    return rows.map((row) => this.toPublicJob(row))
+  }
+
+  async update(jobId: RecordIdInput, input: UpdateAutonomousJobInput): Promise<AutonomousJob> {
+    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 workstreamService.updateTitle(existing.workstreamId, parsed.title)
+    }
+
+    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,
+    )
+    if (!updated) {
+      throw new Error(`Failed to update autonomous job: ${recordIdToString(existing.id, TABLES.AUTONOMOUS_JOB)}`)
+    }
+
+    if (updated.status === 'active') {
+      await this.scheduleRow(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,
+    )
+    return this.toPublicJob(await this.getRow(row.id))
+  }
+
+  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,
+    )
+    if (!resumed) {
+      throw new Error(`Failed to resume autonomous job: ${recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)}`)
+    }
+    await this.scheduleRow(resumed)
+    return this.toPublicJob(await this.getRow(resumed.id))
+  }
+
+  async runNow(jobId: RecordIdInput): Promise<AutonomousJobRun> {
+    const row = await this.getRow(jobId)
+    const queuedRun = await this.createRunRow({ autonomousJobId: row.id, workstreamId: row.workstreamId })
+    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)),
+    })
+
+    await databaseService.update(
+      TABLES.AUTONOMOUS_JOB_RUN,
+      queuedRun.id,
+      { queueJobId: ensureRecordId(enqueueResult.queueJobId, TABLES.QUEUE_JOB) },
+      AutonomousJobRunRowSchema,
+    )
+
+    return this.toPublicRun(await this.getRunRow(queuedRun.id))
+  }
+
+  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,
+    )
+    return this.toPublicJob(await this.getRow(row.id))
+  }
+
+  async delete(jobId: RecordIdInput): Promise<AutonomousJob> {
+    const row = await this.getRow(jobId)
+    const cancelled = await this.cancel(row.id)
+    await workstreamService.updateStatus(row.workstreamId, 'archived')
+    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' },
+    )
+    return rows.map((row) => this.toPublicRun(row))
+  }
+
+  async executeQueuedRun(job: Job<AutonomousJobQueuePayload>): Promise<{ status: string; summary?: string }> {
+    await databaseService.connect()
+
+    const autonomousJobRow = await this.getRow(job.data.autonomousJobId)
+    const queueJobId = queueJobService.getQueueJobId(AUTONOMOUS_JOB_QUEUE_NAME, String(job.id))
+    let runRow =
+      job.data.autonomousJobRunId !== undefined
+        ? await this.getRunRow(job.data.autonomousJobRunId)
+        : await this.createRunRow({
+            autonomousJobId: autonomousJobRow.id,
+            workstreamId: autonomousJobRow.workstreamId,
+            queueJobId,
+            status: 'queued',
+          })
+
+    const activeStatus = autonomousJobRow.status
+    if (activeStatus !== 'active' && job.data.trigger === 'scheduled') {
+      return { status: 'skipped' }
+    }
+
+    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 workstream = await workstreamService.getWorkstream(autonomousJobRow.workstreamId)
+      const inputMessage = this.buildSyntheticUserMessage(autonomousJobRow.prompt)
+      const turnResult = await runWorkstreamTurnInBackground({
+        workstream,
+        workstreamRef: ensureRecordId(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+        orgRef: ensureRecordId(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
+        userRef: ensureRecordId(autonomousJobRow.ownerUserId, TABLES.USER),
+        userName: autonomousJobRow.ownerUserName,
+        agentIdOverride: autonomousJobRow.agentId,
+        inputMessage,
+      })
+      const activePlan = await executionPlanService.getActivePlanForWorkstream(autonomousJobRow.workstreamId)
+      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()
+
+      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,
+      )
+
+      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,
+      )
+
+      await this.maybeNotify('notify', {
+        organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
+        workstreamId: recordIdToString(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+        severity: 'info',
+        title: `${autonomousJobRow.title} completed`,
+        body: summary,
+        metadata: {
+          autonomousJobId: job.data.autonomousJobId,
+          runId: recordIdToString(runRow.id, TABLES.AUTONOMOUS_JOB_RUN),
+        },
+      })
+
+      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,
+      )
+
+      if (autoPause || terminalOneShot) {
+        await this.unscheduleRow(autonomousJobRow)
+      }
+
+      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,
+        }),
+        AutonomousJobRowSchema,
+      )
+
+      await this.maybeNotify('notify', {
+        organizationId: recordIdToString(autonomousJobRow.organizationId, TABLES.ORGANIZATION),
+        workstreamId: recordIdToString(autonomousJobRow.workstreamId, TABLES.WORKSTREAM),
+        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,
+        },
+      })
+
+      throw error
+    }
+  }
+}
+
+export const autonomousJobService = new AutonomousJobService()

package/src/services/index.ts

@@ -2,6 +2,7 @@ export * from './adaptive-playbook.service'
 export * from './agent-executor.service'
 export * from './artifact-provenance.service'
 export * from './attachment.service'
+export * from './autonomous-job.service'
 export * from './context-enrichment.service'
 export * from './coordination-registry.service'
 export * from './document-chunk.service'
@@ -25,6 +26,7 @@ export * from './plan-scheduler.service'
 export * from './plan-template.service'
 export * from './playbook-registry.service'
 export * from './quality-metrics.service'
+export * from './queue-job.service'
 export * from './monitoring-window.service'
 export * from './plugin-executor.service'
 export * from './recent-activity-title.service'