@lota-sdk/core 0.1.13 → 0.1.15

package/src/db/service.ts

@@ -12,6 +12,8 @@ import {
 import type { ExprLike, Mutation, SurrealTransaction, Values } from 'surrealdb'
 import type { z } from 'zod'
 
+import { withTimeout } from '../utils/async'
+import { isRecord } from '../utils/string'
 import type { RecordIdInput } from './record-id'
 import { ensureRecordId, readCustomStringValue } from './record-id'
 import type { DatabaseTable } from './tables'
@@ -53,11 +55,12 @@ interface FindManyOptions {
 type MutationBuilder = {
   content: (data: Record<string, unknown>) => MutationBuilder
   replace: (data: Record<string, unknown>) => MutationBuilder
-  patch: (data: Record<string, unknown>) => MutationBuilder
   merge: (data: Record<string, unknown>) => MutationBuilder
   output: (mode: 'after' | 'before') => Promise<unknown>
 }
 
+type RecordMutation = Extract<Mutation, 'content' | 'replace' | 'merge'>
+
 export type CreateMutationBuilder = {
   content: (data: Record<string, unknown>) => CreateMutationBuilder
   output: (mode: 'after' | 'before') => Promise<unknown>
@@ -75,7 +78,7 @@ export interface DatabaseTransaction {
 
 function configureMutation(
   builder: MutationBuilder,
-  mutation: Mutation,
+  mutation: RecordMutation,
   data: Record<string, unknown>,
 ): MutationBuilder {
   if (mutation === 'content') {
@@ -84,18 +87,11 @@ function configureMutation(
   if (mutation === 'replace') {
     return builder.replace(data)
   }
-  if (mutation === 'patch') {
-    return builder.patch(data)
-  }
   return builder.merge(data)
 }
 
-function isRecordValue(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
 function isBoundQueryLike(value: unknown): value is BoundQueryLike {
-  if (!isRecordValue(value)) {
+  if (!isRecord(value)) {
     return false
   }
 
@@ -103,7 +99,7 @@ function isBoundQueryLike(value: unknown): value is BoundQueryLike {
     return false
   }
 
-  return value.bindings === undefined || isRecordValue(value.bindings)
+  return value.bindings === undefined || isRecord(value.bindings)
 }
 
 function toStringLikeValue(value: unknown): string | null {
@@ -124,23 +120,6 @@ const CONNECT_RETRY_BASE_DELAY_MS = 100
 const CONNECT_RETRY_JITTER_MS = 50
 const CONNECT_ATTEMPT_TIMEOUT_MS = 5_000
 
-async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined
-
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<T>((_, reject) => {
-        timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs)
-      }),
-    ])
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId)
-    }
-  }
-}
-
 export class SurrealDBService {
   private client: Surreal | null = null
   private isConnected = false
@@ -254,7 +233,7 @@ export class SurrealDBService {
                 : { username: this.config.username ?? '', password: this.config.password ?? '' },
             }),
             CONNECT_ATTEMPT_TIMEOUT_MS,
-            `Timed out connecting to SurrealDB at ${this.config.url}`,
+            `SurrealDB connect (${this.config.url})`,
           )
 
           this.isConnected = true
@@ -280,7 +259,7 @@ export class SurrealDBService {
         }
       }
 
-      this.toSurrealError(lastError)
+      return this.toSurrealError(lastError)
     })()
 
     try {
@@ -329,8 +308,16 @@ export class SurrealDBService {
 
   private normalizeRecordId(id: unknown, table: DatabaseTable): ReturnType<typeof ensureRecordId> {
     try {
-      return ensureRecordId(id as RecordIdInput, table)
+      const recordId = ensureRecordId(id as RecordIdInput, table)
+      const resolvedTable = String(recordId.table)
+      if (resolvedTable !== table) {
+        throw new SurrealDBError(`Record id table mismatch: expected "${table}" but got "${resolvedTable}"`)
+      }
+      return recordId
     } catch (error) {
+      if (error instanceof SurrealDBError) {
+        throw error
+      }
       if (error instanceof Error) {
         throw new SurrealDBError(`Invalid record id for table "${table}": ${error.message}`, undefined, {
           cause: error,
@@ -394,7 +381,7 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeRuntimeValue(entry))
     }
 
-    if (!isRecordValue(value)) {
+    if (!isRecord(value)) {
       return value
     }
 
@@ -415,6 +402,8 @@ export class SurrealDBService {
     return Object.fromEntries(entries.map(([key, entryValue]) => [key, this.normalizeRuntimeValue(entryValue)]))
   }
 
+  // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
+  // (non-array objects are mapped entry-by-entry and returned as Object.fromEntries)
   private normalizeBindings(bindings?: Record<string, unknown>): Record<string, unknown> | undefined {
     if (!bindings) {
       return undefined
@@ -423,6 +412,7 @@ export class SurrealDBService {
     return this.normalizeRuntimeValue(bindings) as Record<string, unknown>
   }
 
+  // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
   private normalizeMutationData(data: Record<string, unknown>): Record<string, unknown> {
     const normalized = this.normalizeRuntimeValue(data) as Record<string, unknown>
     return this.stripNullValues(normalized)
@@ -496,7 +486,6 @@ export class SurrealDBService {
     return {
       content: (data) => this.wrapMutationBuilder(builder.content(this.normalizeMutationData(data))),
       replace: (data) => this.wrapMutationBuilder(builder.replace(this.normalizeMutationData(data))),
-      patch: (data) => this.wrapMutationBuilder(builder.patch(this.normalizeMutationData(data))),
       merge: (data) => this.wrapMutationBuilder(builder.merge(this.normalizeMutationData(data))),
       output: (mode) => builder.output(mode),
     }
@@ -515,9 +504,11 @@ export class SurrealDBService {
       create: (target: unknown) => {
         const normalizedTarget = this.normalizeCreateTarget(target)
         const builder = normalizedTarget instanceof Table ? tx.create(normalizedTarget) : tx.create(normalizedTarget)
+        // Cast needed: SurrealDB SDK transaction builder type differs nominally from internal CreateMutationBuilder interface
         return this.wrapCreateBuilder(builder as unknown as CreateMutationBuilder)
       },
       update: (target: unknown) =>
+        // Cast needed: SurrealDB SDK transaction builder type differs nominally from internal MutationBuilder interface
         this.wrapMutationBuilder(tx.update(ensureRecordId(target as RecordIdInput)) as unknown as MutationBuilder),
       delete: (target: unknown) => tx.delete(ensureRecordId(target as RecordIdInput)),
       relate: (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) =>
@@ -559,7 +550,7 @@ export class SurrealDBService {
         return this.normalizeQueryRows<T>(response.result, schema)
       })
     } catch (error) {
-      this.toSurrealError(error, queryText)
+      return this.toSurrealError(error, queryText)
     }
   }
 
@@ -607,7 +598,7 @@ export class SurrealDBService {
       const first = rows.at(0)
       return first ? schema.parse(first) : null
     } catch (error) {
-      this.toSurrealError(error, `SELECT * FROM ${table} LIMIT 1`)
+      return this.toSurrealError(error, `SELECT * FROM ${table} LIMIT 1`)
     }
   }
 
@@ -659,7 +650,7 @@ export class SurrealDBService {
       const rows = await query
       return rows.map((row) => schema.parse(row))
     } catch (error) {
-      this.toSurrealError(error, `SELECT * FROM ${table}`)
+      return this.toSurrealError(error, `SELECT * FROM ${table}`)
     }
   }
 
@@ -688,7 +679,7 @@ export class SurrealDBService {
 
       return schema.parse(first)
     } catch (error) {
-      this.toSurrealError(error, `CREATE ${table}`)
+      return this.toSurrealError(error, `CREATE ${table}`)
     }
   }
 
@@ -710,7 +701,7 @@ export class SurrealDBService {
       const created = await client.create<unknown>(recordId).content(this.normalizeMutationData(data)).output('after')
       return schema.parse(created)
     } catch (error) {
-      this.toSurrealError(error, `CREATE ${recordId.toString()}`)
+      return this.toSurrealError(error, `CREATE ${recordId.toString()}`)
     }
   }
 
@@ -719,7 +710,7 @@ export class SurrealDBService {
     id: unknown,
     data: Record<string, unknown>,
     schema: T,
-    options?: { mutation?: Mutation },
+    options?: { mutation?: RecordMutation },
   ): Promise<z.infer<T> | null> {
     const recordId = this.normalizeRecordId(id, table)
 
@@ -737,7 +728,7 @@ export class SurrealDBService {
       const updated = await configured.output('after')
       return updated ? schema.parse(updated) : null
     } catch (error) {
-      this.toSurrealError(error, `UPDATE ${recordId.toString()}`)
+      return this.toSurrealError(error, `UPDATE ${recordId.toString()}`)
     }
   }
 
@@ -746,7 +737,7 @@ export class SurrealDBService {
     id: unknown,
     data: Record<string, unknown>,
     schema: T,
-    options?: { mutation?: Mutation },
+    options?: { mutation?: RecordMutation },
   ): Promise<z.infer<T>> {
     const recordId = this.normalizeRecordId(id, table)
     const keys = Object.keys(data)
@@ -766,7 +757,7 @@ export class SurrealDBService {
       }
       return schema.parse(upserted)
     } catch (error) {
-      this.toSurrealError(error, `UPSERT ${recordId.toString()}`)
+      return this.toSurrealError(error, `UPSERT ${recordId.toString()}`)
     }
   }
 
@@ -782,7 +773,7 @@ export class SurrealDBService {
       await client.delete<unknown>(recordId).output('before')
       return true
     } catch (error) {
-      this.toSurrealError(error, `DELETE ${recordId.toString()}`)
+      return this.toSurrealError(error, `DELETE ${recordId.toString()}`)
     }
   }
 
@@ -812,7 +803,7 @@ export class SurrealDBService {
 
       return matched.length
     } catch (error) {
-      this.toSurrealError(error, `DELETE ${table} WHERE ...`)
+      return this.toSurrealError(error, `DELETE ${table} WHERE ...`)
     }
   }
 
@@ -838,7 +829,7 @@ export class SurrealDBService {
       }
       return 1
     } catch (error) {
-      this.toSurrealError(error, `UPDATE ${table} WHERE ...`)
+      return this.toSurrealError(error, `UPDATE ${table} WHERE ...`)
     }
   }
 
@@ -857,7 +848,7 @@ export class SurrealDBService {
         .output('after')
       return inserted as T[]
     } catch (error) {
-      this.toSurrealError(error, `INSERT ${table}`)
+      return this.toSurrealError(error, `INSERT ${table}`)
     }
   }
 
@@ -887,7 +878,7 @@ export class SurrealDBService {
       }
       return related
     } catch (error) {
-      this.toSurrealError(error, `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`)
+      return this.toSurrealError(error, `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`)
     }
   }
 
@@ -896,7 +887,7 @@ export class SurrealDBService {
     try {
       return this.wrapTransaction(await client.beginTransaction())
     } catch (error) {
-      this.toSurrealError(error, 'BEGIN TRANSACTION')
+      return this.toSurrealError(error, 'BEGIN TRANSACTION')
     }
   }
 
@@ -945,10 +936,13 @@ export const databaseService = new Proxy({} as SurrealDBService, {
       return databaseServiceOverrides.get(property)
     }
 
-    const target = resolveConfiguredDatabaseService() as unknown as Record<PropertyKey, unknown>
-    const value = target[property]
+    const resolved = resolveConfiguredDatabaseService()
+    const value: unknown = Reflect.get(resolved, property)
     if (typeof value === 'function') {
-      return bindTargetMethod(target, value as (...args: unknown[]) => unknown)
+      return bindTargetMethod(
+        resolved as unknown as Record<PropertyKey, unknown>,
+        value as (...args: unknown[]) => unknown,
+      )
     }
 
     return value

package/src/db/startup.ts

@@ -1,9 +1,9 @@
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
-import type { SurrealDBService, SurrealDatabaseLogger } from '../db/service'
-import { TABLES } from '../db/tables'
-import { getErrorMessage } from '../utils/error'
+import { getErrorMessage } from '../utils/errors'
+import type { SurrealDBService, SurrealDatabaseLogger } from './service'
+import { TABLES } from './tables'
 
 const DATABASE_BOOTSTRAP_KEY = 'database-schema-ready'
 const DEFAULT_RETRY_DELAY_MS = 1_000

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './runtime'
+export * from './create-runtime'
 export * from './ai'
 export * from './bifrost'
 export * from './config'

package/src/queues/context-compaction.queue.ts

@@ -12,6 +12,7 @@ import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
   createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
   registerShutdownSignals,
 } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
@@ -29,12 +30,7 @@ function getContextCompactionQueue(): Queue<ContextCompactionJob> {
   if (!_contextCompactionQueue) {
     _contextCompactionQueue = new Queue<ContextCompactionJob>(CONTEXT_COMPACTION_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 2,
-        backoff: { type: 'exponential', delay: 3_000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 3_000 } },
     })
   }
   return _contextCompactionQueue
@@ -51,11 +47,11 @@ async function processContextCompactionJob(job: Job<ContextCompactionJob>): Prom
 
   const { entityId, contextSize } = job.data
   const workstreamRef = ensureRecordId(entityId, TABLES.WORKSTREAM)
-  await workstreamService.setCompacting(workstreamRef, true)
+  await workstreamService.markCompacting(workstreamRef)
   try {
     await contextCompactionService.compactWorkstreamHistory({ workstreamId: workstreamRef, contextSize })
   } finally {
-    await workstreamService.setCompacting(workstreamRef, false)
+    await workstreamService.clearCompacting(workstreamRef)
   }
 }
 

package/src/queues/document-processor.queue.ts

@@ -4,7 +4,12 @@ import { Queue, Worker } from 'bullmq'
 import type IORedis from 'ioredis'
 
 import type { chatLogger } from '../config/logger'
-import { attachWorkerEvents, createWorkerShutdown, registerShutdownSignals } from '../workers/worker-utils'
+import {
+  attachWorkerEvents,
+  createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
+  registerShutdownSignals,
+} from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
 
 export type DocumentSourceChannel = string
@@ -82,12 +87,7 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
 
     queue = new Queue<TJob, unknown, string>(queueName, {
       connection: params.getConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 3,
-        backoff: { type: 'exponential', delay: 1000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
     })
 
     return queue

package/src/queues/memory-consolidation.queue.ts

@@ -5,6 +5,8 @@ import { getRedisConnectionForBullMQ } from '../redis'
 import {
   attachWorkerEvents,
   getWorkerPath,
+  LONG_JOB_LOCK_DURATION_MS,
+  LOW_JOB_RETENTION,
   createWorkerShutdown,
   registerShutdownSignals,
 } from '../workers/worker-utils'
@@ -15,18 +17,15 @@ export interface MemoryConsolidationJob {
 }
 
 const MEMORY_CONSOLIDATION_QUEUE = 'memory-consolidation'
+const MEMORY_CONSOLIDATION_INTERVAL_MS = 24 * 60 * 60 * 1000
+const MEMORY_CONSOLIDATION_JOB_ID = 'memory-consolidation-recurring'
 
 let _memoryConsolidationQueue: Queue<MemoryConsolidationJob> | null = null
 function getMemoryConsolidationQueue(): Queue<MemoryConsolidationJob> {
   if (!_memoryConsolidationQueue) {
     _memoryConsolidationQueue = new Queue<MemoryConsolidationJob>(MEMORY_CONSOLIDATION_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 50,
-        removeOnFail: 50,
-        attempts: 2,
-        backoff: { type: 'exponential', delay: 5000 },
-      },
+      defaultJobOptions: { ...LOW_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
     })
   }
   return _memoryConsolidationQueue
@@ -42,7 +41,7 @@ export async function scheduleRecurringConsolidation() {
   await getMemoryConsolidationQueue().add(
     'consolidate',
     {},
-    { repeat: { every: 24 * 60 * 60 * 1000 }, jobId: 'memory-consolidation-recurring' },
+    { repeat: { every: MEMORY_CONSOLIDATION_INTERVAL_MS }, jobId: MEMORY_CONSOLIDATION_JOB_ID },
   )
 }
 
@@ -51,7 +50,7 @@ export function startMemoryConsolidationWorker(options: { registerSignals?: bool
   const processorPath = getWorkerPath('memory-consolidation.worker.ts')
   const worker = new Worker(MEMORY_CONSOLIDATION_QUEUE, processorPath, {
     connection: getRedisConnectionForBullMQ(),
-    lockDuration: 600_000,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
     concurrency: 1,
   })
 

package/src/queues/post-chat-memory.queue.ts

@@ -10,6 +10,7 @@ import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
   createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
   registerShutdownSignals,
 } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
@@ -43,12 +44,7 @@ function getPostChatMemoryQueue(): Queue<PostChatMemoryExtractionJob> {
   if (!_postChatMemoryQueue) {
     _postChatMemoryQueue = new Queue<PostChatMemoryExtractionJob>(POST_CHAT_MEMORY_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 3,
-        backoff: { type: 'exponential', delay: 2_000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
     })
   }
   return _postChatMemoryQueue

package/src/queues/recent-activity-title-refinement.queue.ts

@@ -9,6 +9,7 @@ import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
   createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
   registerShutdownSignals,
 } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
@@ -26,12 +27,7 @@ function getRecentActivityTitleRefinementQueue(): Queue<RecentActivityTitleRefin
       RECENT_ACTIVITY_TITLE_REFINEMENT_QUEUE,
       {
         connection: getRedisConnectionForBullMQ(),
-        defaultJobOptions: {
-          removeOnComplete: 200,
-          removeOnFail: 200,
-          attempts: 3,
-          backoff: { type: 'exponential', delay: 2_000 },
-        },
+        defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
       },
     )
   }

package/src/queues/regular-chat-memory-digest.queue.ts

@@ -4,7 +4,9 @@ import { serverLogger } from '../config/logger'
 import { getRedisConnectionForBullMQ } from '../redis'
 import {
   attachWorkerEvents,
+  DEFAULT_JOB_RETENTION,
   getWorkerPath,
+  LONG_JOB_LOCK_DURATION_MS,
   createWorkerShutdown,
   registerShutdownSignals,
 } from '../workers/worker-utils'
@@ -25,12 +27,7 @@ function getRegularChatMemoryDigestQueue(): Queue<RegularChatMemoryDigestJob> {
   if (!_regularChatMemoryDigestQueue) {
     _regularChatMemoryDigestQueue = new Queue<RegularChatMemoryDigestJob>(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 2,
-        backoff: { type: 'exponential', delay: 5000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
     })
   }
   return _regularChatMemoryDigestQueue
@@ -54,7 +51,7 @@ export function startRegularChatMemoryDigestWorker(options: { registerSignals?:
   const worker = new Worker(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, processorPath, {
     connection: getRedisConnectionForBullMQ(),
     concurrency: 1,
-    lockDuration: 600_000,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
   })
 
   attachWorkerEvents(worker, 'Regular chat memory digest', serverLogger)

package/src/queues/skill-extraction.queue.ts

@@ -4,7 +4,9 @@ import { serverLogger } from '../config/logger'
 import { getRedisConnectionForBullMQ } from '../redis'
 import {
   attachWorkerEvents,
+  DEFAULT_JOB_RETENTION,
   getWorkerPath,
+  LONG_JOB_LOCK_DURATION_MS,
   createWorkerShutdown,
   registerShutdownSignals,
 } from '../workers/worker-utils'
@@ -22,12 +24,7 @@ function getSkillExtractionQueue(): Queue<SkillExtractionJob> {
   if (!_skillExtractionQueue) {
     _skillExtractionQueue = new Queue<SkillExtractionJob>(SKILL_EXTRACTION_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 2,
-        backoff: { type: 'exponential', delay: 5000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
     })
   }
   return _skillExtractionQueue
@@ -43,7 +40,7 @@ export function startSkillExtractionWorker(options: { registerSignals?: boolean
   const worker = new Worker(SKILL_EXTRACTION_QUEUE, processorPath, {
     connection: getRedisConnectionForBullMQ(),
     concurrency: 1,
-    lockDuration: 600_000,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
   })
 
   attachWorkerEvents(worker, 'Skill extraction', serverLogger)

package/src/queues/workstream-title-generation.queue.ts

@@ -10,6 +10,7 @@ import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
   createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
   registerShutdownSignals,
 } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
@@ -26,12 +27,7 @@ function getWorkstreamTitleGenerationQueue(): Queue<WorkstreamTitleGenerationJob
   if (!_workstreamTitleGenerationQueue) {
     _workstreamTitleGenerationQueue = new Queue<WorkstreamTitleGenerationJob>(WORKSTREAM_TITLE_GENERATION_QUEUE, {
       connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: {
-        removeOnComplete: 200,
-        removeOnFail: 200,
-        attempts: 2,
-        backoff: { type: 'exponential', delay: 2_000 },
-      },
+      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
     })
   }
   return _workstreamTitleGenerationQueue

package/src/redis/connection.ts

@@ -1,7 +1,7 @@
 import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
-import { getErrorMessage } from '../utils/error'
+import { getErrorMessage } from '../utils/errors'
 
 export interface RedisConnectionLogger {
   debug?: (message: string) => void
@@ -25,20 +25,23 @@ export interface RedisConnectionManager {
 }
 
 const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 30_000
+const REDIS_RETRY_STEP_MS = 50
+const REDIS_RETRY_MAX_DELAY_MS = 2000
+const REDIS_CONNECT_TIMEOUT_MS = 10_000
 
 export const DEFAULT_REDIS_OPTIONS: RedisOptions = {
   maxRetriesPerRequest: null,
   enableReadyCheck: true,
   enableOfflineQueue: true,
   retryStrategy: (times: number) => {
-    const delay = Math.min(times * 50, 2000)
+    const delay = Math.min(times * REDIS_RETRY_STEP_MS, REDIS_RETRY_MAX_DELAY_MS)
     return delay
   },
   reconnectOnError: (err: Error) => {
     const targetErrors = ['READONLY', 'ETIMEDOUT', 'ECONNREFUSED', 'EAI_AGAIN']
     return targetErrors.some((candidate) => err.message.includes(candidate))
   },
-  connectTimeout: 10000,
+  connectTimeout: REDIS_CONNECT_TIMEOUT_MS,
   lazyConnect: false,
 }
 

package/src/redis/index.ts

@@ -8,6 +8,7 @@ export {
   type RedisConnectionAccessor,
 } from './connection-accessor'
 export { withOrgMemoryLock } from './org-memory-lock'
+export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
 export { createWorkstreamResumableContext } from './stream-context'
 
 export { createRedisConnectionManager }

package/src/redis/org-memory-lock.ts

@@ -9,7 +9,7 @@ const ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_MAX_WAIT_MS = 15 * 60 * 1000
 
-export async function withOrgMemoryLock<T>(orgId: string, fn: () => Promise<T>): Promise<T> {
+export async function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
   const normalizedOrgId = orgId.trim()
 
   if (!normalizedOrgId) {