@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -33,7 +33,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../../utils/date-time'
 
@@ -159,7 +159,10 @@ function serializeEvent(event: PlanEventRecord): SerializablePlanEvent {
   }
 }
 
-type PlanRunServiceError = ServiceError
+class PlanRunServiceError extends Schema.TaggedErrorClass<PlanRunServiceError>()('PlanRunServiceError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
 
 class PlanRunNotFoundError extends Schema.TaggedErrorClass<PlanRunNotFoundError>()('PlanRunNotFoundError', {
   message: Schema.String,
@@ -172,25 +175,15 @@ class PlanRunSerializationError extends Schema.TaggedErrorClass<PlanRunSerializa
   { message: Schema.String },
 ) {}
 
+const effectTryPlanRunPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new PlanRunServiceError({ message, cause }),
+)
+
 function tryPlanRunPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, PlanRunServiceError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new ServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new ServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new ServiceError({ message, cause }))
-    }
-  })
+  return effectTryPlanRunPromise(evaluate, message)
 }
 
 export function makePlanRunService(db: SurrealDBService) {
@@ -632,7 +625,7 @@ export function makePlanRunService(db: SurrealDBService) {
 }
 
 export class PlanRunServiceTag extends Context.Service<PlanRunServiceTag, ReturnType<typeof makePlanRunService>>()(
-  'PlanRunService',
+  '@lota-sdk/core/PlanRunService',
 ) {}
 
 export const PlanRunServiceLive = Layer.effect(

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

@@ -8,8 +8,10 @@ import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { NotFoundError } from '../../effect/errors'
-import { effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
+import type { PlanSchedulerQueueRuntime } from '../../queues/plan-scheduler.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import { nowDate, nowEpochMillis, toDatabaseDateTime, unsafeDateFrom } from '../../utils/date-time'
 
 interface PlanSchedulerRuntimeDeps {
@@ -23,72 +25,77 @@ class PlanSchedulerError extends Schema.TaggedErrorClass<PlanSchedulerError>()('
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-function effectTryPromise<A>(
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-  message: string,
-): Effect.Effect<A, PlanSchedulerError> {
-  return effectTryPromiseShared(evaluate, (cause) => new PlanSchedulerError({ message, cause }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new PlanSchedulerError({ message, cause }))
 
-function failPlanScheduler(message: string, cause?: unknown): Effect.Effect<never, PlanSchedulerError> {
-  return Effect.fail(new PlanSchedulerError({ message, ...(cause === undefined ? {} : { cause }) }))
+function requireScheduleField<A>(value: A | undefined, message: string): A {
+  if (value === undefined) {
+    throw new PlanSchedulerError({ message })
+  }
+  return value
 }
 
-function requireScheduleField<A>(value: A | undefined, message: string): Effect.Effect<A, PlanSchedulerError> {
-  return value === undefined ? failPlanScheduler(message) : Effect.succeed(value)
-}
+function computeNextCronDate(cronExpression: string, baseTime: Date): Date {
+  const parsedCron = Cron.parse(cronExpression)
+  if (!Result.isSuccess(parsedCron)) {
+    throw new PlanSchedulerError({ message: `Invalid cron expression: "${cronExpression}".` })
+  }
 
-const computeNextCronDateEffect: (cronExpression: string, baseTime: Date) => Effect.Effect<Date, PlanSchedulerError> =
-  Effect.fn('PlanScheduler.computeNextCronDate')(function* (cronExpression: string, baseTime: Date) {
-    const parsedCron = Cron.parse(cronExpression)
-    const cron = Result.isSuccess(parsedCron)
-      ? parsedCron.success
-      : yield* failPlanScheduler(`Invalid cron expression: "${cronExpression}".`)
-
-    return yield* Effect.try({
-      try: () => Cron.next(cron, baseTime),
-      catch: (cause) =>
-        new PlanSchedulerError({
-          message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
-          cause,
-        }),
+  try {
+    return Cron.next(parsedCron.success, baseTime)
+  } catch (cause) {
+    throw new PlanSchedulerError({
+      message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
+      cause,
     })
-  })
-
-const computeNextFireAtEffect: (spec: PlanScheduleSpec, baseTime?: Date) => Effect.Effect<Date, PlanSchedulerError> =
-  Effect.fn('PlanScheduler.computeNextFireAt')(function* (spec: PlanScheduleSpec, baseTime: Date = nowDate()) {
-    switch (spec.type) {
-      case 'immediate':
-        return baseTime
+  }
+}
 
-      case 'absolute': {
-        const at = yield* requireScheduleField(spec.at, 'Absolute schedules require an "at" timestamp.')
-        return unsafeDateFrom(at)
-      }
+// `computeNextFireAt` must stay purely synchronous — no Clock, no service lookups, no async.
+// `computeNextFireAtEffect` wraps it with `Effect.try` so the same logic is composable from
+// Effect callers without an `Effect.runSync` round trip.
+function computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
+  switch (spec.type) {
+    case 'immediate':
+      return baseTime
 
-      case 'relative': {
-        const delayMs = yield* requireScheduleField(spec.delayMs, 'Relative schedules require "delayMs".')
-        return unsafeDateFrom(baseTime.getTime() + delayMs)
-      }
+    case 'absolute':
+      return unsafeDateFrom(requireScheduleField(spec.at, 'Absolute schedules require an "at" timestamp.'))
 
-      case 'cron': {
-        const cronExpression = yield* requireScheduleField(spec.cron, 'Cron schedules require a "cron" expression.')
-        return yield* computeNextCronDateEffect(cronExpression, baseTime)
-      }
+    case 'relative': {
+      const delayMs = requireScheduleField(spec.delayMs, 'Relative schedules require "delayMs".')
+      return unsafeDateFrom(baseTime.getTime() + delayMs)
+    }
 
-      case 'monitoring': {
-        const intervalMs = yield* requireScheduleField(spec.intervalMs, 'Monitoring schedules require "intervalMs".')
-        return unsafeDateFrom(baseTime.getTime() + intervalMs)
-      }
+    case 'cron': {
+      const cronExpression = requireScheduleField(spec.cron, 'Cron schedules require a "cron" expression.')
+      return computeNextCronDate(cronExpression, baseTime)
+    }
 
-      default:
-        return yield* failPlanScheduler('Unsupported schedule type in schedule specification.')
+    case 'monitoring': {
+      const intervalMs = requireScheduleField(spec.intervalMs, 'Monitoring schedules require "intervalMs".')
+      return unsafeDateFrom(baseTime.getTime() + intervalMs)
     }
+
+    default:
+      throw new PlanSchedulerError({ message: 'Unsupported schedule type in schedule specification.' })
+  }
+}
+
+const isPlanSchedulerError = Schema.is(PlanSchedulerError)
+
+function computeNextFireAtEffect(spec: PlanScheduleSpec, baseTime?: Date): Effect.Effect<Date, PlanSchedulerError> {
+  return Effect.try({
+    try: () => computeNextFireAt(spec, baseTime),
+    catch: (cause) =>
+      isPlanSchedulerError(cause)
+        ? cause
+        : new PlanSchedulerError({ message: 'Failed to compute the next fire time.', cause }),
   })
+}
 
-export function makePlanSchedulerService(db: SurrealDBService) {
-  const loadPlanSchedulerQueue = () =>
-    effectTryPromise(() => import('../../queues/plan-scheduler.queue'), 'Failed to load plan scheduler queue module.')
+export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: PlanSchedulerQueueRuntime) {
+  const loadPlanSchedulerQueue = (): Effect.Effect<PlanSchedulerQueueRuntime, PlanSchedulerError> =>
+    Effect.succeed(schedulerQueue)
 
   const createScheduleEffect = (params: {
     organizationId: RecordIdInput
@@ -143,13 +150,9 @@ export function makePlanSchedulerService(db: SurrealDBService) {
       const isRecurring = schedule.scheduleSpec.type === 'cron' || schedule.scheduleSpec.type === 'monitoring'
       const maxReached = schedule.scheduleSpec.maxFires !== undefined && newFireCount >= schedule.scheduleSpec.maxFires
 
-      let nextFireAt: Date | null = null
-      let newStatus: 'active' | 'completed' = 'completed'
-
-      if (isRecurring && !maxReached) {
-        nextFireAt = yield* computeNextFireAtEffect(schedule.scheduleSpec, now)
-        newStatus = 'active'
-      }
+      const isActive = isRecurring && !maxReached
+      const nextFireAt: Date | null = isActive ? yield* computeNextFireAtEffect(schedule.scheduleSpec, now) : null
+      const newStatus: 'active' | 'completed' = isActive ? 'active' : 'completed'
 
       yield* effectTryPromise(
         () =>
@@ -167,7 +170,6 @@ export function makePlanSchedulerService(db: SurrealDBService) {
         'Failed to update fired schedule.',
       )
 
-      let shouldRecoverDeadlineChecks = false
       if (newStatus === 'active') {
         if (!nextFireAt) {
           return yield* new PlanSchedulerError({ message: 'Recurring schedules must resolve a next fire time.' })
@@ -185,6 +187,7 @@ export function makePlanSchedulerService(db: SurrealDBService) {
 
       const runId = schedule.runId
       const nodeId = schedule.nodeId
+      const promotedNode = Boolean(runId && nodeId)
       if (runId && nodeId) {
         yield* effectTryPromise(
           () =>
@@ -195,26 +198,29 @@ export function makePlanSchedulerService(db: SurrealDBService) {
             }),
           'Failed to promote delayed plan node.',
         )
-        shouldRecoverDeadlineChecks = true
       }
 
-      if (schedule.planSpecId && !schedule.runId) {
-        const cycle = yield* effectTryPromise(
-          () =>
-            db.findOne(
-              TABLES.PLAN_CYCLE,
-              { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
-              PlanCycleRecordSchema,
-            ),
-          'Failed to load plan cycle for schedule.',
-        )
-        if (cycle) {
-          yield* effectTryPromise(() => runtimeDeps.advanceCycle(cycle.id), 'Failed to advance plan cycle.')
-          shouldRecoverDeadlineChecks = true
-        }
-      }
+      const advancedCycle =
+        schedule.planSpecId && !schedule.runId
+          ? yield* effectTryPromise(
+              () =>
+                db.findOne(
+                  TABLES.PLAN_CYCLE,
+                  { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
+                  PlanCycleRecordSchema,
+                ),
+              'Failed to load plan cycle for schedule.',
+            ).pipe(
+              Effect.tap((cycle) =>
+                cycle
+                  ? effectTryPromise(() => runtimeDeps.advanceCycle(cycle.id), 'Failed to advance plan cycle.')
+                  : Effect.void,
+              ),
+              Effect.map((cycle) => cycle !== null),
+            )
+          : false
 
-      if (shouldRecoverDeadlineChecks) {
+      if (promotedNode || advancedCycle) {
         yield* effectTryPromise(() => runtimeDeps.recoverDeadlineChecks(), 'Failed to recover deadline checks.')
       }
     })
@@ -357,7 +363,7 @@ export function makePlanSchedulerService(db: SurrealDBService) {
   return {
     createSchedule: createScheduleEffect,
     computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
-      return Effect.runSync(computeNextFireAtEffect(spec, baseTime))
+      return computeNextFireAt(spec, baseTime)
     },
     /** Called by the BullMQ worker when a fire-schedule job executes. */
     fireScheduleById: fireScheduleByIdEffect,
@@ -374,12 +380,13 @@ export function makePlanSchedulerService(db: SurrealDBService) {
 export class PlanSchedulerServiceTag extends Context.Service<
   PlanSchedulerServiceTag,
   ReturnType<typeof makePlanSchedulerService>
->()('PlanSchedulerService') {}
+>()('@lota-sdk/core/PlanSchedulerService') {}
 
 export const PlanSchedulerServiceLive = Layer.effect(
   PlanSchedulerServiceTag,
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
-    return makePlanSchedulerService(db)
+    const queues = yield* LotaQueuesServiceTag
+    return makePlanSchedulerService(db, queues.planScheduler)
   }),
 )

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

@@ -212,7 +212,7 @@ export function makePlanTemplateService(deps: PlanTemplateDeps) {
 export class PlanTemplateServiceTag extends Context.Service<
   PlanTemplateServiceTag,
   ReturnType<typeof makePlanTemplateService>
->()('PlanTemplateService') {}
+>()('@lota-sdk/core/PlanTemplateService') {}
 
 export const PlanTemplateServiceLive = Layer.effect(
   PlanTemplateServiceTag,

package/src/services/plan/plan-transaction-events.ts

@@ -23,11 +23,14 @@ export function withTransactionAndEventsEffect<T, E, R>(params: {
           (error) => new PlanTransactionEventsError({ message: 'Failed to run plan transaction.', cause: error }),
         ),
       )
-    yield* Effect.tryPromise({
-      try: () => params.planEventDeliveryService.dispatchEvents(emittedEvents),
-      catch: (error) =>
-        new PlanTransactionEventsError({ message: 'Failed to dispatch plan transaction events.', cause: error }),
-    })
+    yield* params.planEventDeliveryService
+      .dispatchEvents(emittedEvents)
+      .pipe(
+        Effect.mapError(
+          (error) =>
+            new PlanTransactionEventsError({ message: 'Failed to dispatch plan transaction events.', cause: error }),
+        ),
+      )
     return result
   })
 }

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

@@ -897,7 +897,7 @@ export function makePlanValidatorService(planCoordinationService: ReturnType<typ
 export class PlanValidatorServiceTag extends Context.Service<
   PlanValidatorServiceTag,
   ReturnType<typeof makePlanValidatorService>
->()('PlanValidatorService') {}
+>()('@lota-sdk/core/PlanValidatorService') {}
 
 export const PlanValidatorServiceLive = Layer.effect(
   PlanValidatorServiceTag,

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

@@ -1,10 +1,14 @@
 import { Context, Effect, Layer, Schema } from 'effect'
 
+import { ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { RedisServiceTag } from '../../effect/services'
 import { toValidationError } from '../../effect/zod'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { nowEpochMillis } from '../../utils/date-time'
 
+const tryWorkspacePromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
 const PlanWorkspaceEntrySchema = Schema.Struct({
   value: Schema.Unknown,
   version: Schema.Number,
@@ -29,10 +33,9 @@ function parsePlanWorkspaceEntryEffect(
   fieldKey: string,
   raw: string,
 ): Effect.Effect<PlanWorkspaceEntry, ReturnType<typeof toValidationError>> {
-  return Effect.try({
-    try: () => Schema.decodeUnknownSync(PlanWorkspaceEntryJsonSchema)(raw),
-    catch: (error) => toValidationError(error, `Invalid plan workspace entry JSON for "${fieldKey}"`),
-  })
+  return Schema.decodeUnknownEffect(PlanWorkspaceEntryJsonSchema)(raw).pipe(
+    Effect.mapError((error) => toValidationError(error, `Invalid plan workspace entry JSON for "${fieldKey}"`)),
+  )
 }
 
 export function makePlanWorkspaceService(redis: RedisConnectionManager) {
@@ -56,7 +59,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
         timestamp: nowEpochMillis(),
       }
       const serialized = yield* Schema.encodeEffect(PlanWorkspaceEntryJsonSchema)(entry)
-      yield* Effect.tryPromise(() => conn.hset(hashKey, fieldKey, serialized))
+      yield* tryWorkspacePromise(
+        () => conn.hset(hashKey, fieldKey, serialized),
+        'Failed to write plan workspace entry.',
+      )
     })
 
   const snapshotReadEffect = (params: { runId: string; readerNodeId: string; snapshotSequence?: number }) =>
@@ -64,7 +70,7 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const conn = redis.getConnection()
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const nodePrefix = `${params.readerNodeId}:`
-      const all = yield* Effect.tryPromise(() => conn.hgetall(hashKey))
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace snapshot.')
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [fieldKey, raw] of Object.entries(all)) {
         if (!fieldKey.startsWith(nodePrefix)) continue
@@ -83,11 +89,11 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const key = params.key
       if (key !== undefined) {
-        const raw = yield* Effect.tryPromise(() => conn.hget(hashKey, key))
+        const raw = yield* tryWorkspacePromise(() => conn.hget(hashKey, key), 'Failed to read plan workspace entry.')
         if (!raw) return {}
         return { [key]: yield* parsePlanWorkspaceEntryEffect(key, raw) }
       }
-      const all = yield* Effect.tryPromise(() => conn.hgetall(hashKey))
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace entries.')
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [k, v] of Object.entries(all)) {
         result[k] = yield* parsePlanWorkspaceEntryEffect(k, v)
@@ -97,10 +103,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
 
   const cleanupEffect = (runId: string) =>
     Effect.asVoid(
-      Effect.tryPromise(() => {
+      tryWorkspacePromise(() => {
         const conn = redis.getConnection()
         return conn.del(`${PLAN_WORKSPACE_KEY_PREFIX}${runId}`)
-      }),
+      }, 'Failed to clean up plan workspace.'),
     )
 
   return {
@@ -114,7 +120,7 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
 export class PlanWorkspaceServiceTag extends Context.Service<
   PlanWorkspaceServiceTag,
   ReturnType<typeof makePlanWorkspaceService>
->()('PlanWorkspaceService') {}
+>()('@lota-sdk/core/PlanWorkspaceService') {}
 
 export const PlanWorkspaceServiceLive = Layer.effect(
   PlanWorkspaceServiceTag,

package/src/services/plugin-executor.service.ts

@@ -1,8 +1,13 @@
 import type { OwnershipDispatchContext, PlanNodeSpec, PluginPlanNodeOwner } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { BadRequestError } from '../effect/errors'
+import { BadRequestError, ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
+
+const tryPluginExecutorPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
 import type { LotaPlugin, PluginNodeExecutionParams } from '../runtime/plugin-types'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { PlanValidationIssueInput } from './plan/plan-validator.service'
@@ -82,28 +87,28 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
       return []
     },
 
-    executeNode(params: {
+    executeNode: Effect.fn('PluginExecutor.executeNode')(function* (params: {
       nodeSpec: PlanNodeSpec
       resolvedInput: Record<string, unknown>
       context: OwnershipDispatchContext
     }) {
-      return Effect.gen(function* () {
-        const owner = params.nodeSpec.owner
-        if (!isPluginOwner(owner)) {
-          return yield* new BadRequestError({
-            message: `PluginExecutor cannot execute owner type "${owner.executorType}".`,
-          })
-        }
+      const owner = params.nodeSpec.owner
+      if (!isPluginOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `PluginExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-        const plugin = getPluginRuntime()[owner.ref]
-        const nodeExecutor = plugin?.nodeExecutor
-        if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(owner.operation)) {
-          return yield* new BadRequestError({
-            message: `Plugin executor ${owner.ref}.${owner.operation} is not registered.`,
-          })
-        }
+      const plugin = getPluginRuntime()[owner.ref]
+      const nodeExecutor = plugin?.nodeExecutor
+      if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `Plugin executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
 
-        return yield* Effect.tryPromise(() =>
+      return yield* tryPluginExecutorPromise(
+        () =>
           nodeExecutor.executeNode(
             buildPluginExecutionParams({
               owner,
@@ -112,16 +117,16 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        )
-      })
-    },
+        `Plugin executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('PluginExecutor.invoke'))
+    }),
   }
 }
 
 export class PluginExecutorServiceTag extends Context.Service<
   PluginExecutorServiceTag,
   ReturnType<typeof makePluginExecutorService>
->()('PluginExecutorService') {}
+>()('@lota-sdk/core/PluginExecutorService') {}
 
 export const PluginExecutorServiceLive = Layer.effect(
   PluginExecutorServiceTag,

package/src/services/quality-metrics.service.ts

@@ -139,7 +139,7 @@ export function makeQualityMetricsService(db: SurrealDBService) {
 export class QualityMetricsServiceTag extends Context.Service<
   QualityMetricsServiceTag,
   ReturnType<typeof makeQualityMetricsService>
->()('QualityMetricsService') {}
+>()('@lota-sdk/core/QualityMetricsService') {}
 
 export const QualityMetricsServiceLive = Layer.effect(
   QualityMetricsServiceTag,

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

@@ -14,6 +14,7 @@ import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { isRetriableTransactionConflict } from '../db/transaction-conflict'
 import { BadRequestError, DatabaseError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag } from '../effect/services'
 import { createDeterministicRecordId } from '../utils/crypto'
 import { nowDate, unsafeDateFrom } from '../utils/date-time'
@@ -184,25 +185,15 @@ function getQueuedStatus(job: TrackedBullJobLike): QueueJobStatus {
   return typeof delay === 'number' && delay > 0 ? 'delayed' : 'waiting'
 }
 
+const effectTryQueueJobPersistence = makeEffectTryPromiseWithMessage(
+  (message, cause) => new DatabaseError({ message, cause }),
+)
+
 function tryQueueJobPersistence<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, DatabaseError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new DatabaseError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause: unknown) => new DatabaseError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new DatabaseError({ message, cause }))
-    }
-  })
+  return effectTryQueueJobPersistence(evaluate, message)
 }
 
 function withPersistenceRetry<T>(work: Effect.Effect<T, DatabaseError>): Effect.Effect<T, DatabaseError> {
@@ -456,7 +447,7 @@ export function makeQueueJobService(db: SurrealDBService) {
 }
 
 export class QueueJobServiceTag extends Context.Service<QueueJobServiceTag, ReturnType<typeof makeQueueJobService>>()(
-  'QueueJobService',
+  '@lota-sdk/core/QueueJobService',
 ) {}
 
 export const QueueJobServiceLive = Layer.effect(

package/src/services/recent-activity-title.service.ts

@@ -1,5 +1,9 @@
 import { Context, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { AgentConfigServiceTag } from '../effect/services'
 import type { HelperModelRuntime } from '../runtime/helper-model'
 import { HelperModelTag } from '../runtime/helper-model'
 import { normalizeTitle } from '../runtime/title-helpers'
@@ -12,6 +16,10 @@ import { RecentActivityServiceTag } from './recent-activity.service'
 
 const RECENT_ACTIVITY_TITLE_TIMEOUT_MS = 60_000
 
+const tryRecentActivityTitlePromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
+
 function buildRefinementPromptInput(
   candidate: {
     id: string
@@ -39,6 +47,7 @@ function buildRefinementPromptInput(
 }
 
 export function makeRecentActivityTitleService(
+  agentConfig: ResolvedAgentConfig,
   recentActivityService: ReturnType<typeof makeRecentActivityService>,
   helperModelRuntime: HelperModelRuntime,
 ) {
@@ -55,14 +64,16 @@ export function makeRecentActivityTitleService(
       }
 
       const refinedTitle = normalizeTitle(
-        yield* Effect.tryPromise(() =>
-          helperModelRuntime.generateHelperText({
-            tag: 'recent-activity-title-refinement',
-            createAgent: createRecentActivityTitleRefinerAgent,
-            defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
-            timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
-            messages: [{ role: 'user', content: promptInput }],
-          }),
+        yield* tryRecentActivityTitlePromise(
+          () =>
+            helperModelRuntime.generateHelperText({
+              tag: 'recent-activity-title-refinement',
+              createAgent: (options) => createRecentActivityTitleRefinerAgent(agentConfig, options),
+              defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
+              timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
+              messages: [{ role: 'user', content: promptInput }],
+            }),
+          'Failed to generate recent activity title refinement.',
         ),
       )
       if (
@@ -84,13 +95,14 @@ export function makeRecentActivityTitleService(
 export class RecentActivityTitleServiceTag extends Context.Service<
   RecentActivityTitleServiceTag,
   ReturnType<typeof makeRecentActivityTitleService>
->()('RecentActivityTitleService') {}
+>()('@lota-sdk/core/RecentActivityTitleService') {}
 
 export const RecentActivityTitleServiceLive = Layer.effect(
   RecentActivityTitleServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const recentActivityService = yield* RecentActivityServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    return makeRecentActivityTitleService(recentActivityService, helperModelRuntime)
+    return makeRecentActivityTitleService(agentConfig, recentActivityService, helperModelRuntime)
   }),
 )

package/src/services/recent-activity.service.ts

@@ -387,7 +387,7 @@ export function makeRecentActivityService(db: SurrealDBService) {
 export class RecentActivityServiceTag extends Context.Service<
   RecentActivityServiceTag,
   ReturnType<typeof makeRecentActivityService>
->()('RecentActivityService') {}
+>()('@lota-sdk/core/RecentActivityService') {}
 
 export const RecentActivityServiceLive = Layer.effect(
   RecentActivityServiceTag,