@lota-sdk/core 0.4.7 → 0.4.9

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

@@ -14,14 +14,16 @@ import type {
   RecentActivityEventInput,
   RecentActivitySource,
 } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
+import { Context, Effect, Layer } from 'effect'
 import { z } from 'zod'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput, RecordIdRef } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
+import { DatabaseServiceTag } from '../effect/services'
+import { createDeterministicRecordId } from '../utils/crypto'
+import { nowDate, toIsoDateTimeString, toOptionalIsoDateTimeString, unsafeDateFrom } from '../utils/date-time'
 import { compactRecord, compactWhitespace, truncateText } from '../utils/string'
 
 const RecentActivityEventRowSchema = z.object({
@@ -67,11 +69,6 @@ const RecentActivityRowSchema = z.object({
 type RecentActivityEventRow = z.infer<typeof RecentActivityEventRowSchema>
 type RecentActivityRow = z.infer<typeof RecentActivityRowSchema>
 
-function buildDeterministicRecordId(table: string, key: string): RecordId {
-  const digest = new Bun.CryptoHasher('sha256').update(key).digest('hex')
-  return new RecordId(table, digest)
-}
-
 function shouldKeepExistingAgentTitle(existing: RecentActivityRow | null): boolean {
   return existing?.titleSource === 'agent' && compactWhitespace(existing.title).length > 0
 }
@@ -98,286 +95,304 @@ function buildRecentActivityAreaKey(
   return row.mergeKey
 }
 
-class RecentActivityService {
-  private toPublicEvent(row: RecentActivityEventRow): RecentActivityEvent {
-    return RecentActivityEventSchema.parse({
-      id: recordIdToString(
-        ensureRecordId(row.id as RecordIdInput, TABLES.RECENT_ACTIVITY_EVENT),
-        TABLES.RECENT_ACTIVITY_EVENT,
-      ),
-      sourceEventId: row.sourceEventId,
-      source: row.source,
-      kind: row.kind,
-      targetKind: row.targetKind,
-      targetId: row.targetId,
-      mergeKey: row.mergeKey,
-      title: row.title,
-      sourceLabel: row.sourceLabel,
-      deepLink: row.deepLink,
-      ...(row.metadata ? { metadata: row.metadata } : {}),
-      occurredAt: toIsoDateTimeString(row.occurredAt),
-      createdAt: toIsoDateTimeString(row.createdAt),
-    })
-  }
+function toPublicEvent(row: RecentActivityEventRow): RecentActivityEvent {
+  return RecentActivityEventSchema.parse({
+    id: recordIdToString(
+      ensureRecordId(row.id as RecordIdInput, TABLES.RECENT_ACTIVITY_EVENT),
+      TABLES.RECENT_ACTIVITY_EVENT,
+    ),
+    sourceEventId: row.sourceEventId,
+    source: row.source,
+    kind: row.kind,
+    targetKind: row.targetKind,
+    targetId: row.targetId,
+    mergeKey: row.mergeKey,
+    title: row.title,
+    sourceLabel: row.sourceLabel,
+    deepLink: row.deepLink,
+    ...(row.metadata ? { metadata: row.metadata } : {}),
+    occurredAt: toIsoDateTimeString(row.occurredAt),
+    createdAt: toIsoDateTimeString(row.createdAt),
+  })
+}
 
-  private toPublicItem(row: RecentActivityRow): RecentActivity {
-    return RecentActivitySchema.parse({
-      id: recordIdToString(ensureRecordId(row.id as RecordIdInput, TABLES.RECENT_ACTIVITY), TABLES.RECENT_ACTIVITY),
-      kind: row.kind,
-      targetKind: row.targetKind,
-      targetId: row.targetId,
-      mergeKey: row.mergeKey,
-      title: row.title,
-      systemTitle: row.systemTitle,
-      titleSource: row.titleSource,
-      sourceLabel: row.sourceLabel,
-      deepLink: row.deepLink,
-      ...(row.metadata ? { metadata: row.metadata } : {}),
-      latestEventAt: toIsoDateTimeString(row.latestEventAt),
-      titleRefinedAt: toOptionalIsoDateTimeString(row.titleRefinedAt),
-      createdAt: toIsoDateTimeString(row.createdAt),
-      updatedAt: toIsoDateTimeString(row.updatedAt),
-    })
-  }
+function toPublicItem(row: RecentActivityRow): RecentActivity {
+  return RecentActivitySchema.parse({
+    id: recordIdToString(ensureRecordId(row.id as RecordIdInput, TABLES.RECENT_ACTIVITY), TABLES.RECENT_ACTIVITY),
+    kind: row.kind,
+    targetKind: row.targetKind,
+    targetId: row.targetId,
+    mergeKey: row.mergeKey,
+    title: row.title,
+    systemTitle: row.systemTitle,
+    titleSource: row.titleSource,
+    sourceLabel: row.sourceLabel,
+    deepLink: row.deepLink,
+    ...(row.metadata ? { metadata: row.metadata } : {}),
+    latestEventAt: toIsoDateTimeString(row.latestEventAt),
+    titleRefinedAt: toOptionalIsoDateTimeString(row.titleRefinedAt),
+    createdAt: toIsoDateTimeString(row.createdAt),
+    updatedAt: toIsoDateTimeString(row.updatedAt),
+  })
+}
 
-  private sanitizeEvent(input: RecentActivityEventInput): RecentActivityEventInput {
-    return {
-      ...input,
-      sourceEventId: truncateText(input.sourceEventId, 200),
-      ...(input.targetId ? { targetId: truncateText(input.targetId, 200) } : {}),
-      mergeKey: truncateText(input.mergeKey, 200),
-      title: truncateText(input.title, 140),
-      sourceLabel: truncateText(input.sourceLabel, 40),
-      ...(input.metadata ? { metadata: RecentActivityMetadataSchema.parse(input.metadata) } : {}),
-    }
+function sanitizeEvent(input: RecentActivityEventInput): RecentActivityEventInput {
+  return {
+    ...input,
+    sourceEventId: truncateText(input.sourceEventId, 200),
+    ...(input.targetId ? { targetId: truncateText(input.targetId, 200) } : {}),
+    mergeKey: truncateText(input.mergeKey, 200),
+    title: truncateText(input.title, 140),
+    sourceLabel: truncateText(input.sourceLabel, 40),
+    ...(input.metadata ? { metadata: RecentActivityMetadataSchema.parse(input.metadata) } : {}),
   }
+}
 
-  async recordEvents(params: {
+export function makeRecentActivityService(db: SurrealDBService) {
+  function recordEventBody(params: {
     orgId: RecordIdRef
     userId: RecordIdRef
     source: RecentActivitySource
-    events: RecentActivityEventInput[]
-  }): Promise<RecentActivity[]> {
-    await databaseService.connect()
-
-    const results = await Promise.all(
-      params.events.map((candidate) =>
-        this.recordEvent({ orgId: params.orgId, userId: params.userId, source: params.source, event: candidate }),
-      ),
-    )
-    return results.map((r) => r.item)
+    event: RecentActivityEventInput
+  }) {
+    return Effect.gen(function* () {
+      const parsedEvent = sanitizeEvent(RecentActivityEventInputSchema.parse(params.event))
+      const orgIdString = recordIdToString(params.orgId, TABLES.ORGANIZATION)
+      const userIdString = recordIdToString(params.userId, TABLES.USER)
+      const eventRecordId = createDeterministicRecordId(
+        TABLES.RECENT_ACTIVITY_EVENT,
+        `${orgIdString}:${userIdString}:${parsedEvent.sourceEventId}`,
+      )
+      const recentRecordId = createDeterministicRecordId(
+        TABLES.RECENT_ACTIVITY,
+        `${orgIdString}:${userIdString}:${parsedEvent.mergeKey}`,
+      )
+      const occurredAt = parsedEvent.occurredAt ? unsafeDateFrom(parsedEvent.occurredAt) : nowDate()
+      const existingRecent = yield* db.findOne(TABLES.RECENT_ACTIVITY, { id: recentRecordId }, RecentActivityRowSchema)
+
+      const eventRow = yield* db.upsert(
+        TABLES.RECENT_ACTIVITY_EVENT,
+        eventRecordId,
+        compactRecord({
+          organizationId: params.orgId,
+          userId: params.userId,
+          sourceEventId: parsedEvent.sourceEventId,
+          source: params.source,
+          kind: parsedEvent.kind,
+          targetKind: parsedEvent.targetKind,
+          targetId: parsedEvent.targetId,
+          mergeKey: parsedEvent.mergeKey,
+          title: parsedEvent.title,
+          sourceLabel: parsedEvent.sourceLabel,
+          deepLink: parsedEvent.deepLink,
+          metadata: parsedEvent.metadata,
+          occurredAt,
+        }),
+        RecentActivityEventRowSchema,
+        { mutation: 'merge' },
+      )
+
+      const keepExistingAgentTitle = shouldKeepExistingAgentTitle(existingRecent)
+      const visibleTitle = keepExistingAgentTitle && existingRecent ? existingRecent.title : parsedEvent.title
+      const recentRow = yield* db.upsert(
+        TABLES.RECENT_ACTIVITY,
+        recentRecordId,
+        compactRecord({
+          organizationId: params.orgId,
+          userId: params.userId,
+          mergeKey: parsedEvent.mergeKey,
+          kind: parsedEvent.kind,
+          targetKind: parsedEvent.targetKind,
+          targetId: parsedEvent.targetId,
+          title: visibleTitle,
+          systemTitle: parsedEvent.title,
+          titleSource: keepExistingAgentTitle ? 'agent' : 'system',
+          sourceLabel: parsedEvent.sourceLabel,
+          deepLink: parsedEvent.deepLink,
+          metadata: parsedEvent.metadata,
+          latestEventId: eventRecordId,
+          latestSourceEventId: parsedEvent.sourceEventId,
+          latestEventAt: occurredAt,
+        }),
+        RecentActivityRowSchema,
+        { mutation: 'merge' },
+      )
+
+      return { event: toPublicEvent(eventRow), item: toPublicItem(recentRow) }
+    })
   }
 
-  async recordEvent(params: {
+  function recordEvent(params: {
     orgId: RecordIdRef
     userId: RecordIdRef
     source: RecentActivitySource
     event: RecentActivityEventInput
-  }): Promise<{ event: RecentActivityEvent; item: RecentActivity }> {
-    await databaseService.connect()
-
-    const parsedEvent = this.sanitizeEvent(RecentActivityEventInputSchema.parse(params.event))
-    const orgIdString = recordIdToString(params.orgId, TABLES.ORGANIZATION)
-    const userIdString = recordIdToString(params.userId, TABLES.USER)
-    const eventRecordId = buildDeterministicRecordId(
-      TABLES.RECENT_ACTIVITY_EVENT,
-      `${orgIdString}:${userIdString}:${parsedEvent.sourceEventId}`,
-    )
-    const recentRecordId = buildDeterministicRecordId(
-      TABLES.RECENT_ACTIVITY,
-      `${orgIdString}:${userIdString}:${parsedEvent.mergeKey}`,
-    )
-    const occurredAt = parsedEvent.occurredAt ? new Date(parsedEvent.occurredAt) : new Date()
-    const existingRecent = await databaseService.findOne(
-      TABLES.RECENT_ACTIVITY,
-      { id: recentRecordId },
-      RecentActivityRowSchema,
-    )
-
-    const eventRow = await databaseService.upsert(
-      TABLES.RECENT_ACTIVITY_EVENT,
-      eventRecordId,
-      compactRecord({
-        organizationId: params.orgId,
-        userId: params.userId,
-        sourceEventId: parsedEvent.sourceEventId,
-        source: params.source,
-        kind: parsedEvent.kind,
-        targetKind: parsedEvent.targetKind,
-        targetId: parsedEvent.targetId,
-        mergeKey: parsedEvent.mergeKey,
-        title: parsedEvent.title,
-        sourceLabel: parsedEvent.sourceLabel,
-        deepLink: parsedEvent.deepLink,
-        metadata: parsedEvent.metadata,
-        occurredAt,
-      }),
-      RecentActivityEventRowSchema,
-      { mutation: 'merge' },
-    )
-
-    const keepExistingAgentTitle = shouldKeepExistingAgentTitle(existingRecent)
-    const visibleTitle = keepExistingAgentTitle && existingRecent ? existingRecent.title : parsedEvent.title
-    const recentRow = await databaseService.upsert(
-      TABLES.RECENT_ACTIVITY,
-      recentRecordId,
-      compactRecord({
-        organizationId: params.orgId,
-        userId: params.userId,
-        mergeKey: parsedEvent.mergeKey,
-        kind: parsedEvent.kind,
-        targetKind: parsedEvent.targetKind,
-        targetId: parsedEvent.targetId,
-        title: visibleTitle,
-        systemTitle: parsedEvent.title,
-        titleSource: keepExistingAgentTitle ? 'agent' : 'system',
-        sourceLabel: parsedEvent.sourceLabel,
-        deepLink: parsedEvent.deepLink,
-        metadata: parsedEvent.metadata,
-        latestEventId: eventRecordId,
-        latestSourceEventId: parsedEvent.sourceEventId,
-        latestEventAt: occurredAt,
-      }),
-      RecentActivityRowSchema,
-      { mutation: 'merge' },
-    )
-
-    return { event: this.toPublicEvent(eventRow), item: this.toPublicItem(recentRow) }
+  }) {
+    return Effect.gen(function* () {
+      yield* db.connect()
+      return yield* recordEventBody(params)
+    })
   }
 
-  async listRecentActivities(params: {
+  function recordEvents(params: {
     orgId: RecordIdRef
     userId: RecordIdRef
-    limit?: number
-  }): Promise<RecentActivity[]> {
-    await databaseService.connect()
-    const limit = params.limit ?? 5
-    const rows = await databaseService.findMany(
-      TABLES.RECENT_ACTIVITY,
-      { organizationId: params.orgId, userId: params.userId },
-      RecentActivityRowSchema,
-      { orderBy: 'latestEventAt', orderDir: 'DESC', limit: Math.max(limit * 5, 25) },
-    )
-
-    const items: RecentActivity[] = []
-    const seenAreas = new Set<string>()
-
-    for (const row of rows) {
-      const areaKey = buildRecentActivityAreaKey(row)
-      if (seenAreas.has(areaKey)) continue
-
-      seenAreas.add(areaKey)
-      items.push(this.toPublicItem(row))
-
-      if (items.length === limit) break
-    }
-
-    return items
+    source: RecentActivitySource
+    events: RecentActivityEventInput[]
+  }) {
+    return Effect.gen(function* () {
+      yield* db.connect()
+      const results = yield* Effect.all(
+        params.events.map((candidate) =>
+          recordEventBody({ orgId: params.orgId, userId: params.userId, source: params.source, event: candidate }),
+        ),
+      )
+      return results.map((r) => r.item)
+    })
   }
 
-  async listRecentEvents(params: {
-    orgId: RecordIdRef
-    userId: RecordIdRef
-    limit?: number
-  }): Promise<RecentActivityEvent[]> {
-    await databaseService.connect()
-    const rows = await databaseService.findMany(
-      TABLES.RECENT_ACTIVITY_EVENT,
-      { organizationId: params.orgId, userId: params.userId },
-      RecentActivityEventRowSchema,
-      { orderBy: 'occurredAt', orderDir: 'DESC', limit: params.limit ?? 25 },
-    )
-    return rows.map((row) => this.toPublicEvent(row))
-  }
+  const refineTitle = (params: { activityId: string | RecordIdRef; title: string }) =>
+    Effect.gen(function* () {
+      yield* db.connect()
+      const activityRef = ensureRecordId(params.activityId, TABLES.RECENT_ACTIVITY)
+      const existing = yield* db.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
+      if (!existing) return null
+
+      const nextTitle = truncateText(params.title, 80)
+      if (!nextTitle) return toPublicItem(existing)
+      if (compactWhitespace(nextTitle).toLowerCase() === compactWhitespace(existing.title).toLowerCase()) {
+        return toPublicItem(existing)
+      }
+
+      const updated = yield* db.update(
+        TABLES.RECENT_ACTIVITY,
+        activityRef,
+        { title: nextTitle, titleSource: 'agent', titleRefinedAt: nowDate() },
+        RecentActivityRowSchema,
+        { mutation: 'merge' },
+      )
+
+      return updated ? toPublicItem(updated) : null
+    })
 
-  async getRecentActivityById(activityId: string | RecordIdRef): Promise<RecentActivity | null> {
-    await databaseService.connect()
-    const activityRef = ensureRecordId(activityId, TABLES.RECENT_ACTIVITY)
-    const row = await databaseService.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
-    return row ? this.toPublicItem(row) : null
-  }
+  const getRefinementCandidate = (activityId: string | RecordIdRef) =>
+    Effect.gen(function* () {
+      yield* db.connect()
+      const activityRef = ensureRecordId(activityId, TABLES.RECENT_ACTIVITY)
+      const row = yield* db.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
+      if (!row) return null
+
+      return {
+        id: recordIdToString(activityRef, TABLES.RECENT_ACTIVITY),
+        title: row.title,
+        systemTitle: row.systemTitle,
+        sourceLabel: row.sourceLabel,
+        kind: row.kind,
+        metadata: RecentActivityMetadataSchema.parse(row.metadata),
+      }
+    })
 
-  async refineTitle(params: { activityId: string | RecordIdRef; title: string }): Promise<RecentActivity | null> {
-    await databaseService.connect()
-    const activityRef = ensureRecordId(params.activityId, TABLES.RECENT_ACTIVITY)
-    const existing = await databaseService.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
-    if (!existing) return null
-
-    const nextTitle = truncateText(params.title, 80)
-    if (!nextTitle) return this.toPublicItem(existing)
-    if (compactWhitespace(nextTitle).toLowerCase() === compactWhitespace(existing.title).toLowerCase()) {
-      return this.toPublicItem(existing)
-    }
-
-    const updated = await databaseService.update(
-      TABLES.RECENT_ACTIVITY,
-      activityRef,
-      { title: nextTitle, titleSource: 'agent', titleRefinedAt: new Date() },
-      RecentActivityRowSchema,
-      { mutation: 'merge' },
-    )
-
-    return updated ? this.toPublicItem(updated) : null
-  }
+  const listRecentActivities = (params: { orgId: RecordIdRef; userId: RecordIdRef; limit?: number }) =>
+    Effect.gen(function* () {
+      yield* db.connect()
+      const limit = params.limit ?? 5
+      const rows = yield* db.findMany(
+        TABLES.RECENT_ACTIVITY,
+        { organizationId: params.orgId, userId: params.userId },
+        RecentActivityRowSchema,
+        { orderBy: 'latestEventAt', orderDir: 'DESC', limit: Math.max(limit * 5, 25) },
+      )
 
-  async getRefinementCandidate(
-    activityId: string | RecordIdRef,
-  ): Promise<{
-    id: string
-    title: string
-    systemTitle: string
-    sourceLabel: string
-    kind: RecentActivity['kind']
-    metadata: z.infer<typeof RecentActivityMetadataSchema>
-  } | null> {
-    await databaseService.connect()
-    const activityRef = ensureRecordId(activityId, TABLES.RECENT_ACTIVITY)
-    const row = await databaseService.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
-    if (!row) return null
-
-    return {
-      id: recordIdToString(activityRef, TABLES.RECENT_ACTIVITY),
-      title: row.title,
-      systemTitle: row.systemTitle,
-      sourceLabel: row.sourceLabel,
-      kind: row.kind,
-      metadata: RecentActivityMetadataSchema.parse(row.metadata),
-    }
-  }
+      const items: RecentActivity[] = []
+      const seenAreas = new Set<string>()
 
-  isMeaningfulRefinementCandidate(activity: RecentActivity | null): boolean {
-    if (!activity) return false
-    if (activity.kind !== 'chat.turn.completed') return false
-    return activity.titleSource === 'system'
-  }
+      for (const row of rows) {
+        const areaKey = buildRecentActivityAreaKey(row)
+        if (seenAreas.has(areaKey)) continue
 
-  isAgentTitleUseful(params: { currentTitle: string; systemTitle: string; candidateTitle: string }): boolean {
-    const candidate = compactWhitespace(params.candidateTitle)
-    if (!candidate) return false
+        seenAreas.add(areaKey)
+        items.push(toPublicItem(row))
 
-    const normalizedCandidate = candidate.toLowerCase()
-    const normalizedCurrent = compactWhitespace(params.currentTitle).toLowerCase()
-    const normalizedSystem = compactWhitespace(params.systemTitle).toLowerCase()
+        if (items.length === limit) break
+      }
 
-    if (normalizedCandidate === normalizedCurrent || normalizedCandidate === normalizedSystem) {
-      return false
-    }
+      return items
+    })
 
-    if (candidate.length < 8 || candidate.length > 80) {
-      return false
-    }
+  const listRecentEvents = (params: { orgId: RecordIdRef; userId: RecordIdRef; limit?: number }) =>
+    Effect.gen(function* () {
+      yield* db.connect()
+      const rows = yield* db.findMany(
+        TABLES.RECENT_ACTIVITY_EVENT,
+        { organizationId: params.orgId, userId: params.userId },
+        RecentActivityEventRowSchema,
+        { orderBy: 'occurredAt', orderDir: 'DESC', limit: params.limit ?? 25 },
+      )
+      return rows.map((row) => toPublicEvent(row))
+    })
 
-    const bannedTitles = new Set([
-      'follow up',
-      'conversation',
-      'chat',
-      'agent task',
-      'recent activity',
-      'thread update',
-    ])
+  const getRecentActivityById = (activityId: string | RecordIdRef) =>
+    Effect.gen(function* () {
+      yield* db.connect()
+      const activityRef = ensureRecordId(activityId, TABLES.RECENT_ACTIVITY)
+      const row = yield* db.findOne(TABLES.RECENT_ACTIVITY, { id: activityRef }, RecentActivityRowSchema)
+      return row ? toPublicItem(row) : null
+    })
 
-    return !bannedTitles.has(normalizedCandidate)
+  return {
+    recordEvent,
+    recordEvents,
+    listRecentActivities,
+    listRecentEvents,
+    getRecentActivityById,
+    refineTitle,
+    getRefinementCandidate,
+
+    isMeaningfulRefinementCandidate(activity: RecentActivity | null): boolean {
+      if (!activity) return false
+      if (activity.kind !== 'chat.turn.completed') return false
+      return activity.titleSource === 'system'
+    },
+
+    isAgentTitleUseful(params: { currentTitle: string; systemTitle: string; candidateTitle: string }): boolean {
+      const candidate = compactWhitespace(params.candidateTitle)
+      if (!candidate) return false
+
+      const normalizedCandidate = candidate.toLowerCase()
+      const normalizedCurrent = compactWhitespace(params.currentTitle).toLowerCase()
+      const normalizedSystem = compactWhitespace(params.systemTitle).toLowerCase()
+
+      if (normalizedCandidate === normalizedCurrent || normalizedCandidate === normalizedSystem) {
+        return false
+      }
+
+      if (candidate.length < 8 || candidate.length > 80) {
+        return false
+      }
+
+      const bannedTitles = new Set([
+        'follow up',
+        'conversation',
+        'chat',
+        'agent task',
+        'recent activity',
+        'thread update',
+      ])
+
+      return !bannedTitles.has(normalizedCandidate)
+    },
   }
 }
 
-export const recentActivityService = new RecentActivityService()
+export class RecentActivityServiceTag extends Context.Service<
+  RecentActivityServiceTag,
+  ReturnType<typeof makeRecentActivityService>
+>()('RecentActivityService') {}
+
+export const RecentActivityServiceLive = Layer.effect(
+  RecentActivityServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeRecentActivityService(db)
+  }),
+)

package/src/services/skill-resolver.service.ts

@@ -1,19 +1,45 @@
-class SkillResolverService {
-  async resolve(params: {
+import { Context, Effect, Layer } from 'effect'
+
+import { LearnedSkillServiceTag } from './learned-skill.service'
+
+type LearnedSkillService = Context.Service.Shape<typeof LearnedSkillServiceTag>
+
+export interface SkillResolverService {
+  resolve(params: {
     skillRef: string
     organizationId: string
-  }): Promise<{ executorType: 'agent' | 'plugin'; ref: string; operation?: string } | null> {
-    // Dynamic import to avoid circular dependencies and enable testability
-    const { learnedSkillService } = await import('./learned-skill.service')
-    const skill = await learnedSkillService.findByNameOrTag(params.organizationId, params.skillRef)
-    if (!skill) return null
+  }): Effect.Effect<
+    { executorType: 'agent' | 'plugin'; ref: string; operation?: string } | null,
+    Effect.Error<ReturnType<LearnedSkillService['findByNameOrTag']>>
+  >
+}
 
-    if (skill.agentId) {
-      return { executorType: 'agent', ref: skill.agentId }
-    }
+export function makeSkillResolverService(deps: {
+  learnedSkillService: Pick<LearnedSkillService, 'findByNameOrTag'>
+}): SkillResolverService {
+  return {
+    resolve(params) {
+      return Effect.gen(function* () {
+        const skill = yield* deps.learnedSkillService.findByNameOrTag(params.organizationId, params.skillRef)
+        // eslint-disable-next-line typescript-eslint/no-unnecessary-condition -- skill can be null (findByNameOrTag returns T | null)
+        if (!skill || !skill.agentId) {
+          return null
+        }
 
-    return null
+        return { executorType: 'agent' as const, ref: skill.agentId }
+      })
+    },
   }
 }
 
-export const skillResolverService = new SkillResolverService()
+export class SkillResolverServiceTag extends Context.Service<SkillResolverServiceTag, SkillResolverService>()(
+  'SkillResolverService',
+) {}
+
+export const SkillResolverServiceLive = Layer.effect(
+  SkillResolverServiceTag,
+  Effect.gen(function* () {
+    const learnedSkillService = yield* LearnedSkillServiceTag
+    return makeSkillResolverService({ learnedSkillService })
+  }),
+)