@lota-sdk/core 0.4.9 → 0.4.11

package/src/redis/connection.ts

@@ -1,8 +1,8 @@
-import { Duration, Effect, Exit, Fiber } from 'effect'
+import { Duration, Effect, Exit, Scope } from 'effect'
 import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
-import { ConfigurationError } from '../effect/errors'
+import { RedisError } from '../effect/errors'
 import { effectTryServicePromise } from '../effect/helpers'
 import { getErrorMessage } from '../utils/errors'
 
@@ -32,8 +32,6 @@ const REDIS_RETRY_STEP_MS = 50
 const REDIS_RETRY_MAX_DELAY_MS = 2000
 const REDIS_CONNECT_TIMEOUT_MS = 10_000
 
-type HealthCheckFiber = ReturnType<typeof Effect.runFork>
-
 export const DEFAULT_REDIS_OPTIONS: RedisOptions = {
   maxRetriesPerRequest: null,
   enableReadyCheck: true,
@@ -57,181 +55,200 @@ function log(logger: RedisConnectionLogger | undefined, level: keyof RedisConnec
   }
 }
 
-class RedisConnectionManagerImpl implements RedisConnectionManager {
-  private redis: IORedis | null = null
-  private isHealthy = false
-  private isInitialized = false
-  private isClosing = false
-  private isHealthCheckRunning = false
-  private healthChecksActive = false
-  private healthCheckFiber: HealthCheckFiber | null = null
-
-  constructor(private readonly options: CreateRedisConnectionManagerOptions) {
-    this.initializeConnection()
-  }
-
-  private initializeConnection(): void {
-    if (this.isInitialized) {
-      return
-    }
-
-    this.isInitialized = true
-
-    try {
-      const redisOptions = this.options.redisOptions ?? DEFAULT_REDIS_OPTIONS
-      this.redis = new IORedis(this.options.url, redisOptions)
-      this.setupEventHandlers()
-      this.startHealthChecks()
-    } catch (error) {
-      log(this.options.logger, 'error', `Failed to initialize Redis connection: ${getErrorMessage(error)}`)
-    }
-  }
-
-  private setupEventHandlers(): void {
-    if (!this.redis) return
-
-    this.redis.on('connect', () => {
-      log(this.options.logger, 'info', 'Redis connected')
-      this.isHealthy = true
-    })
-
-    this.redis.on('ready', () => {
-      log(this.options.logger, 'info', 'Redis ready')
-      this.isHealthy = true
-    })
-
-    this.redis.on('error', (error: Error) => {
-      log(this.options.logger, 'error', `Redis error: ${error.message}`)
-      this.isHealthy = false
-    })
-
-    this.redis.on('close', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
-      )
-      this.isHealthy = false
-    })
-
-    this.redis.on('reconnecting', () => {
-      log(this.options.logger, 'info', 'Redis reconnecting...')
-    })
-
-    this.redis.on('end', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
-      )
-      this.isHealthy = false
-    })
-  }
+interface ManagerState {
+  isHealthy: boolean
+  isClosing: boolean
+}
 
-  private startHealthChecks(): void {
-    if (this.healthChecksActive || this.healthCheckFiber) {
-      return
-    }
+/**
+ * Build the IORedis client + listeners as an `Effect.acquireRelease`. Each
+ * handler is held as a const ref so the release step can pass the same
+ * function to `client.off(...)`, then `quit()` (falling back to
+ * `disconnect()`) the client. Prevents tracked-handler leaks on disposal.
+ */
+function acquireRedisClient(
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<IORedis, RedisError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.try({
+      try: () => {
+        const redisOptions = options.redisOptions ?? DEFAULT_REDIS_OPTIONS
+        const client = new IORedis(options.url, redisOptions)
+
+        const onConnect = () => {
+          log(options.logger, 'info', 'Redis connected')
+          state.isHealthy = true
+        }
+        const onReady = () => {
+          log(options.logger, 'info', 'Redis ready')
+          state.isHealthy = true
+        }
+        const onError = (error: Error) => {
+          log(options.logger, 'error', `Redis error: ${error.message}`)
+          state.isHealthy = false
+        }
+        const onClose = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
+          )
+          state.isHealthy = false
+        }
+        const onReconnecting = () => {
+          log(options.logger, 'info', 'Redis reconnecting...')
+        }
+        const onEnd = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
+          )
+          state.isHealthy = false
+        }
 
-    this.healthChecksActive = true
-    const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
-    const logger = this.options.logger
-    const isHealthChecksActive = () => this.healthChecksActive
-    const isHealthCheckRunning = () => this.isHealthCheckRunning
-    const setHealthCheckRunning = (value: boolean) => {
-      this.isHealthCheckRunning = value
-    }
-    const getRedis = () => this.redis
-    const setHealthy = (value: boolean) => {
-      this.isHealthy = value
-    }
+        client.on('connect', onConnect)
+        client.on('ready', onReady)
+        client.on('error', onError)
+        client.on('close', onClose)
+        client.on('reconnecting', onReconnecting)
+        client.on('end', onEnd)
+
+        // Carry the handler refs alongside the client so the release closure
+        // can detach exactly what was attached.
+        ;(client as ClientWithHandlers).__lotaHandlers = {
+          connect: onConnect,
+          ready: onReady,
+          error: onError,
+          close: onClose,
+          reconnecting: onReconnecting,
+          end: onEnd,
+        }
 
-    this.healthCheckFiber = Effect.runFork(
+        return client
+      },
+      catch: (cause) =>
+        new RedisError({ message: `Failed to initialize Redis connection: ${getErrorMessage(cause)}`, cause }),
+    }),
+    (client) =>
       Effect.gen(function* () {
-        for (;;) {
-          yield* Effect.sleep(Duration.millis(intervalMs))
-          if (!isHealthChecksActive()) break
-          if (isHealthCheckRunning()) continue
-
-          setHealthCheckRunning(true)
-          try {
-            const redis = getRedis()
-            if (redis && redis.status === 'ready') {
-              const pingExit = yield* Effect.exit(
-                effectTryServicePromise(() => redis.ping(), 'Redis health check failed'),
-              )
-              if (Exit.isFailure(pingExit)) {
-                log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
-                setHealthy(false)
-              } else {
-                setHealthy(true)
-              }
-            }
-          } finally {
-            setHealthCheckRunning(false)
+        state.isClosing = true
+
+        const handlers = (client as ClientWithHandlers).__lotaHandlers
+        if (handlers) {
+          client.off('connect', handlers.connect)
+          client.off('ready', handlers.ready)
+          client.off('error', handlers.error)
+          client.off('close', handlers.close)
+          client.off('reconnecting', handlers.reconnecting)
+          client.off('end', handlers.end)
+        }
+
+        if (client.status !== 'end') {
+          const quitExit = yield* Effect.exit(
+            effectTryServicePromise(() => client.quit(), 'Failed to close Redis connection manager'),
+          )
+          if (Exit.isFailure(quitExit)) {
+            log(options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
+            client.disconnect()
           }
         }
       }),
-    )
-  }
-
-  private stopHealthChecks(): Promise<void> {
-    this.healthChecksActive = false
-
-    const fiber = this.healthCheckFiber
-    if (!fiber) {
-      return Promise.resolve()
-    }
+  )
+}
 
-    this.healthCheckFiber = null
-    return Effect.runPromise(Fiber.interrupt(fiber)).then(
-      () => undefined,
-      () => undefined,
-    )
-  }
+interface RedisHandlers {
+  readonly connect: () => void
+  readonly ready: () => void
+  readonly error: (error: Error) => void
+  readonly close: () => void
+  readonly reconnecting: () => void
+  readonly end: () => void
+}
 
-  getConnection(): IORedis {
-    if (!this.redis) {
-      throw new ConfigurationError({ message: 'Redis connection not initialized', key: 'redis' })
+type ClientWithHandlers = IORedis & { __lotaHandlers?: RedisHandlers }
+
+/**
+ * Health-check loop wired via `Effect.forkScoped` so interruption is automatic
+ * when the owning scope closes. No more imperative fiber tracking.
+ */
+function startHealthCheckFiber(
+  client: IORedis,
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<void, never, Scope.Scope> {
+  const intervalMs = options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
+  const logger = options.logger
+  let isHealthCheckRunning = false
+
+  const loop = Effect.gen(function* () {
+    for (;;) {
+      yield* Effect.sleep(Duration.millis(intervalMs))
+      if (isHealthCheckRunning) continue
+
+      isHealthCheckRunning = true
+      try {
+        if (client.status === 'ready') {
+          const pingExit = yield* Effect.exit(effectTryServicePromise(() => client.ping(), 'Redis health check failed'))
+          if (Exit.isFailure(pingExit)) {
+            log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
+            state.isHealthy = false
+          } else {
+            state.isHealthy = true
+          }
+        }
+      } finally {
+        isHealthCheckRunning = false
+      }
     }
-    return this.redis
-  }
+  })
 
-  getConnectionForBullMQ(): IORedis {
-    return this.getConnection()
-  }
-
-  isConnectionHealthy(): boolean {
-    return this.isHealthy && this.redis?.status === 'ready'
-  }
+  return Effect.asVoid(Effect.forkScoped(loop))
+}
 
-  closeConnection(): Promise<void> {
-    this.isClosing = true
-    const logger = this.options.logger
-    const getRedis = () => this.redis
-    const stopHealthChecks = () => this.stopHealthChecks()
-    const disconnect = () => {
-      this.redis?.disconnect()
+/**
+ * Scoped builder for the Redis connection manager. The IORedis client and
+ * health-check fiber are both bound to the surrounding scope, so closing the
+ * scope tears down listeners + quits the client + interrupts the fiber.
+ */
+export function makeRedisConnectionManager(
+  options: CreateRedisConnectionManagerOptions,
+): Effect.Effect<RedisConnectionManager, RedisError, Scope.Scope> {
+  return Effect.gen(function* () {
+    const state: ManagerState = { isHealthy: false, isClosing: false }
+    const client = yield* acquireRedisClient(options, state)
+    yield* startHealthCheckFiber(client, options, state)
+
+    const manager: RedisConnectionManager = {
+      getConnection: () => client,
+      getConnectionForBullMQ: () => client,
+      isConnectionHealthy: () => state.isHealthy && client.status === 'ready',
+      closeConnection: () => Promise.resolve(),
     }
 
-    return Effect.runPromise(
-      Effect.gen(function* () {
-        yield* Effect.tryPromise(() => stopHealthChecks())
-        const redis = getRedis()
-        if (redis && redis.status !== 'end') {
-          const quitExit = yield* Effect.exit(
-            effectTryServicePromise(() => redis.quit(), 'Failed to close Redis connection manager'),
-          )
-          if (Exit.isFailure(quitExit)) {
-            log(logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
-            disconnect()
-          }
-        }
-      }),
-    )
-  }
+    return manager
+  })
 }
 
+/**
+ * Standalone Promise-friendly factory for hosts that build the manager outside
+ * a Layer. Owns its own `Scope`; `closeConnection()` closes that scope, which
+ * runs the same finalizer chain (listener removal, quit/disconnect, fiber
+ * interrupt) that `Layer.effect` runs at runtime shutdown.
+ */
 export function createRedisConnectionManager(options: CreateRedisConnectionManagerOptions): RedisConnectionManager {
-  return new RedisConnectionManagerImpl(options)
+  const scope = Scope.makeUnsafe()
+  const built = Effect.runSync(Scope.provide(makeRedisConnectionManager(options), scope))
+  let closePromise: Promise<void> | null = null
+
+  return {
+    ...built,
+    closeConnection: () => {
+      if (!closePromise) {
+        closePromise = Effect.runPromise(Scope.close(scope, Exit.void).pipe(Effect.catchCause(() => Effect.void)))
+      }
+      return closePromise
+    },
+  }
 }

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

@@ -1,12 +1,12 @@
 import { Schema, Effect } from 'effect'
-import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { LockAcquisitionError } from '../effect/errors'
 import type { LockLostError, RedisError } from '../effect/errors'
+import { RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from './connection'
 import { withLeaseLock } from './redis-lease-lock'
 import type { RedisLeaseLockOptions } from './redis-lease-lock'
-import { getRuntimeRedisConnection } from './runtime-connection'
 
 const ORG_MEMORY_LOCK_PREFIX = 'lock:org-memory:org:'
 const ORG_MEMORY_LOCK_TTL_MS = 120_000
@@ -20,9 +20,8 @@ class OrgMemoryLockCallbackError extends Schema.TaggedErrorClass<OrgMemoryLockCa
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
-function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLockOptions & { redis: IORedis } {
+function createOrgMemoryLockOptions(orgId: string): RedisLeaseLockOptions {
   return {
-    redis,
     lockKey: `${ORG_MEMORY_LOCK_PREFIX}${orgId}`,
     lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
     retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
@@ -44,13 +43,28 @@ function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLo
   }
 }
 
-export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+/**
+ * Promise-returning wrapper for hosts that live outside Effect.
+ *
+ * Callers must pass in a `RedisConnectionManager` (usually
+ * `runtime.redis.manager`) so the wrapper can build a standalone Redis layer
+ * instead of relying on an ambient managed runtime.
+ */
+export function withOrgMemoryLock<T>(
+  orgId: string,
+  fn: (signal: AbortSignal) => Promise<T>,
+  redisManager: RedisConnectionManager,
+): Promise<T> {
   return Effect.runPromise(
     withOrgMemoryLockEffect(orgId, (signal) =>
       Effect.tryPromise({
         try: () => fn(signal),
         catch: (cause) => new OrgMemoryLockCallbackError({ message: 'Org memory lock callback failed.', cause }),
       }),
+    ).pipe(
+      // Provide the redis service synchronously so the Effect has no residual
+      // requirements; the outer Promise call edge needs `R = never`.
+      Effect.provideService(RedisServiceTag, redisManager),
     ),
   )
 }
@@ -58,7 +72,7 @@ export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) =>
 export function withOrgMemoryLockEffect<A, E>(
   orgId: string,
   fn: (signal: AbortSignal) => Effect.Effect<A, E>,
-): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError> {
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError, RedisServiceTag> {
   const normalizedOrgId = orgId.trim()
 
   if (!normalizedOrgId) {
@@ -70,7 +84,8 @@ export function withOrgMemoryLockEffect<A, E>(
     )
   }
 
-  return Effect.sync(() => getRuntimeRedisConnection()).pipe(
-    Effect.flatMap((redis) => withLeaseLock(createOrgMemoryLockOptions(redis, normalizedOrgId), fn)),
-  )
+  return Effect.gen(function* () {
+    const redis = yield* RedisServiceTag
+    return yield* withLeaseLock({ ...createOrgMemoryLockOptions(normalizedOrgId), redis: redis.getConnection() }, fn)
+  })
 }

package/src/redis/redis-lease-lock.ts

@@ -259,9 +259,16 @@ export function withLeaseLock<A, E, R>(
       Effect.ignore,
     )
 
+    // The refresh fiber races the user's effect against a `lockLost` Deferred
+    // so callers can observe Redis-side expirations. We pass the abort signal
+    // to `fn` so it can cooperatively wind down on lost-lock or external stop,
+    // but do NOT interrupt `fn` via `raceFirst` on `lockLost` — aborting a
+    // turn that has already produced tokens would discard the response. The
+    // caller owns the post-lease cleanup; the signal is enough for anyone who
+    // needs to bail out early.
     return yield* Effect.scoped(
       startRefreshFiber(redis, normalized, lockValue, abortController, lockLost).pipe(
-        Effect.andThen(fn(abortController.signal).pipe(Effect.raceFirst(Deferred.await(lockLost)))),
+        Effect.andThen(fn(abortController.signal)),
         Effect.ensuring(cleanup),
       ),
     )

package/src/redis/stream-context.ts

@@ -1,11 +1,14 @@
-import { Context, Schema, Effect, Fiber, Layer, PubSub, Stream } from 'effect'
+import { Context, Schema, Effect, Fiber, Layer, Queue, Stream } from 'effect'
 import type { Redis } from 'ioredis'
 import type { Publisher, Subscriber } from 'resumable-stream/ioredis'
 import { createResumableStreamContext } from 'resumable-stream/ioredis'
 
+import { serverLogger } from '../config/logger'
 import { RedisServiceTag } from '../effect/services'
 import type { RedisConnectionManager } from './connection'
 
+const SUBSCRIBER_QUEUE_CAPACITY = 1024
+
 function toPublisher(client: Redis): Publisher {
   return {
     connect: () => Promise.resolve(),
@@ -26,7 +29,7 @@ class SharedSubscriberCloseError extends Schema.TaggedErrorClass<SharedSubscribe
 export class SharedThreadStreamSubscriberTag extends Context.Service<
   SharedThreadStreamSubscriberTag,
   { readonly subscriber: Subscriber }
->()('SharedThreadStreamSubscriber') {}
+>()('@lota-sdk/core/SharedThreadStreamSubscriber') {}
 
 export const SharedThreadStreamSubscriberLive = Layer.effect(
   SharedThreadStreamSubscriberTag,
@@ -35,13 +38,15 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
     // Disable enableReadyCheck — the ready check sends INFO which is rejected
     // on connections in subscribe mode, causing unhandled ioredis error events.
     const client = redisManager.getConnection().duplicate({ enableReadyCheck: false })
-    client.on('error', () => {}) // prevent [ioredis] Unhandled error event logs
+    client.on('error', (error: unknown) => {
+      serverLogger.warn('Redis subscriber error', { cause: error })
+    })
 
-    const events = yield* PubSub.unbounded<SharedSubscriberEvent>()
+    const events = yield* Queue.bounded<SharedSubscriberEvent>(SUBSCRIBER_QUEUE_CAPACITY)
     const handlers = new Map<string, (message: string) => void>()
 
     const dispatchFiber = yield* Effect.forkScoped(
-      Stream.fromPubSub(events).pipe(
+      Stream.fromQueue(events).pipe(
         Stream.runForEach((event) =>
           Effect.sync(() => {
             handlers.get(event.channel)?.(event.message)
@@ -50,10 +55,13 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
       ),
     )
 
-    const currentContext = yield* Effect.context()
-    const runFork = Effect.runForkWith(currentContext)
     const messageListener = (channel: string, message: string) => {
-      void runFork(PubSub.publish(events, { channel, message }).pipe(Effect.asVoid))
+      // Synchronous bounded enqueue — drops (returns false) when consumer is slow,
+      // surfacing back-pressure instead of growing memory unbounded.
+      const accepted = Queue.offerUnsafe(events, { channel, message })
+      if (!accepted) {
+        serverLogger.warn('Redis subscriber queue full, dropping message', { channel })
+      }
     }
     client.on('message', messageListener)
 
@@ -78,7 +86,7 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
         handlers.clear()
         client.removeListener('message', messageListener)
         yield* Fiber.interrupt(dispatchFiber)
-        yield* PubSub.shutdown(events)
+        yield* Queue.shutdown(events)
         yield* Effect.tryPromise({
           try: () => client.quit(),
           catch: (cause) =>

package/src/runtime/agent-identity-overrides.ts

@@ -1,4 +1,4 @@
-import { getAgentDisplayNames } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { asRecord, readOptionalString } from './thread-chat-helpers'
 
 interface RuntimeAgentIdentityOverrides {
@@ -52,11 +52,15 @@ export function readRuntimeAgentIdentityOverrides(
   }
 }
 
-export function resolveRuntimeAgentDisplayName(overrides: RuntimeAgentIdentityOverrides, agentId: string): string {
+export function resolveRuntimeAgentDisplayName(
+  agentConfig: ResolvedAgentConfig,
+  overrides: RuntimeAgentIdentityOverrides,
+  agentId: string,
+): string {
   const override = readStringOverride(overrides.displayNamesById, agentId)
   if (override !== undefined) {
     return override
   }
 
-  return getAgentDisplayNames()[agentId] ?? agentId
+  return agentConfig.displayNames[agentId] ?? agentId
 }

package/src/runtime/agent-runtime-policy.ts

@@ -1,4 +1,5 @@
 import type {
+  ChatMode,
   ExecutionMode,
   OwnershipDispatchContext,
   PlanArtifactSubmission,
@@ -6,9 +7,8 @@ import type {
   PlanNodeSpecRecord,
 } from '@lota-sdk/shared'
 
-import { getLeadAgentId } from '../config/agent-defaults'
+import type { ResolvedThreadBootstrapConfig } from '../config/thread-defaults'
 import { resolveOnboardingOwnerAgentId } from '../config/thread-defaults'
-import type { ChatMode } from './agent-types'
 export interface AgentRuntimeConfig<TAgent extends string> {
   id: TAgent
   displayName: string
@@ -162,13 +162,18 @@ export function buildThreadAgentToolPolicy<TAgent extends string, TSkill extends
   linearInstalled: boolean
   githubInstalled: boolean
   provideRepoTool: boolean
-  leadAgentId?: TAgent
+  leadAgentId: TAgent
   onboardingOwnerAgentId?: TAgent
+  threadBootstrapConfig?: ResolvedThreadBootstrapConfig
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): AgentToolPolicy<TSkill> {
   const resolvedMode = params.mode ?? toChatMode(params.threadType)
-  const leadAgentId = params.leadAgentId ?? (getLeadAgentId() as TAgent)
-  const onboardingOwnerAgentId = params.onboardingOwnerAgentId ?? (resolveOnboardingOwnerAgentId(leadAgentId) as TAgent)
+  const leadAgentId = params.leadAgentId
+  const onboardingOwnerAgentId =
+    params.onboardingOwnerAgentId ??
+    (params.threadBootstrapConfig
+      ? (resolveOnboardingOwnerAgentId(leadAgentId, params.threadBootstrapConfig) as TAgent)
+      : leadAgentId)
   const skills = resolveActiveAgentSkills({
     agentId: params.agentId,
     threadType: params.threadType,