@lota-sdk/core 0.4.9 → 0.4.11

package/src/services/memory/memory.service.ts

@@ -1,5 +1,6 @@
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { Memory } from '../../db/memory'
 import { isUniqueIndexConflict } from '../../db/memory-store.helpers'
@@ -12,7 +13,7 @@ import type {
   MemoryType,
   RelationType,
 } from '../../db/memory-types'
-import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
+import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
 import { withOrgMemoryLockEffect } from '../../redis/org-memory-lock'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import { HelperModelTag } from '../../runtime/helper-model'
@@ -24,6 +25,9 @@ import {
 } from '../../runtime/retrieval-adapters'
 import type { ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
 import { clampImportance, compactWhitespace } from '../../utils/string'
+import { BackgroundWorkService } from '../background-work.service'
+import type { MemoryServiceError } from './memory-errors'
+import { tryMemoryPromise as memoryTryPromise } from './memory-errors'
 import type { MemoryRerankOutput } from './memory-rerank'
 import { formatMemoryResults, formatRerankedResults, getCandidateLimit } from './memory-utils'
 export type { MemoryRerankOutput } from './memory-rerank'
@@ -48,36 +52,10 @@ const ONBOARDING_MEMORY_EXTRACTION_PROMPT =
 const DIRECT_MEMORY_ASSESSMENT_PROMPT =
   'The user is submitting a direct memory candidate. Keep the wording faithful. Return one fact only when the statement is durable enough for memory; otherwise return no facts.'
 
-class MemoryServiceError extends Schema.TaggedErrorClass<MemoryServiceError>()('MemoryServiceError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
-
 class InvalidAgentNameError extends Schema.TaggedErrorClass<InvalidAgentNameError>()('InvalidAgentNameError', {
   agentName: Schema.String,
 }) {}
 
-function memoryTryPromise<A>(
-  message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, MemoryServiceError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new MemoryServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new MemoryServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new MemoryServiceError({ message, cause }))
-    }
-  })
-}
-
 type EffectSuccess<T> = T extends Effect.Effect<infer A, infer _E, infer _R> ? A : Awaited<T>
 
 function searchMemoriesEffect({
@@ -200,17 +178,18 @@ interface MemoryServiceDeps {
   rerankService: ReturnType<typeof makeRerankService>
   helperModelRuntime: HelperModelRuntime
   orgMemoryCache: OrgMemoryCache
+  agentConfig: ResolvedAgentConfig
 }
 
 export function createMemoryService(deps: MemoryServiceDeps) {
-  const { runtimeConfig, helperModelRuntime, orgMemoryCache } = deps
+  const { runtimeConfig, helperModelRuntime, orgMemoryCache, agentConfig } = deps
   const resolveRerankService = () => deps.rerankService
   const service = {
     searchOrganizationMemories: Effect.fn('MemoryService.searchOrganizationMemories')(function* (
       orgId: string,
       query: string,
     ) {
-      const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
       aiLogger.debug`Organization memory search requested (orgId: ${orgId}, scopeId: ${orgScopeId}, queryLength: ${query.length})`
       const memory = yield* getOrgMemory(orgMemoryCache, orgId)
       const results = yield* searchMemoriesEffect({
@@ -228,7 +207,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
 
     getStaleMemories(orgId: string) {
       return Effect.gen(function* () {
-        const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
         const memory = yield* getOrgMemory(orgMemoryCache, orgId)
         return yield* memoryTryPromise('Failed to load stale memories.', () => memory.getStaleMemories(orgScopeId))
       }).pipe(
@@ -250,7 +229,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       query: string,
       options?: { fastMode?: boolean; limit?: number },
     ) {
-      const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
       aiLogger.debug`searchOrganizationMemoriesRaw - orgId: "${orgId}", scopeId: "${orgScopeId}"`
       const memory = yield* getOrgMemory(orgMemoryCache, orgId)
       const fastMode = options?.fastMode ?? true
@@ -274,12 +253,12 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       agentName: string,
       query: string,
     ) {
-      if (!isRoutableAgentName(agentName)) {
+      if (!isRoutableAgentName(agentConfig, agentName)) {
         aiLogger.debug`Agent memory search skipped - invalid agentName: ${agentName}`
         return 'No stored memories.'
       }
 
-      const scoped = agentScopeId(orgId, agentName)
+      const scoped = yield* agentScopeId(orgId, agentName)
       aiLogger.debug`Agent memory search requested (orgId: ${orgId}, agentName: ${agentName}, scopeId: ${scoped}, queryLength: ${query.length})`
       const memory = yield* getOrgMemory(orgMemoryCache, orgId)
       const results = yield* searchMemoriesEffect({
@@ -305,8 +284,9 @@ export function createMemoryService(deps: MemoryServiceDeps) {
     }) {
       const { orgId, ...listOptions } = params
       const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
       return yield* memoryTryPromise('Failed to list organization memory records.', () =>
-        orgMemory.list({ scopeId: scopeId(ORG_SCOPE_PREFIX, orgId), ...listOptions }),
+        orgMemory.list({ scopeId: orgScopeId, ...listOptions }),
       )
     }),
 
@@ -334,7 +314,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
     }) {
       const limit = Math.min(runtimeConfig.memory.searchK, MAX_MEMORY_RESULTS_PER_SCOPE)
       const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
-      const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
       const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
 
       const retrievalTasks = [
@@ -351,8 +331,8 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         },
       ]
 
-      if (isRoutableAgentName(agentName)) {
-        const agentScoped = agentScopeId(orgId, agentName)
+      if (isRoutableAgentName(agentConfig, agentName)) {
+        const agentScoped = yield* agentScopeId(orgId, agentName)
         retrievalTasks.push({
           scopeTag: `agent:${agentName}`,
           retrieve: () =>
@@ -367,7 +347,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       }
 
       const results = yield* memoryTryPromise('Failed to execute scoped memory retrieval.', () =>
-        executeScopedRetrieval<MemorySearchResult>(retrievalTasks),
+        executeScopedRetrieval(retrievalTasks),
       )
       const totalCandidates = countScopedRetrievalCandidates(results)
       aiLogger.debug`Batched memory search candidates (scopes: ${results.length}, total: ${totalCandidates})`
@@ -409,9 +389,10 @@ export function createMemoryService(deps: MemoryServiceDeps) {
     }) {
       return Effect.gen(function* () {
         const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
         return yield* memoryTryPromise('Failed to create organization memory.', () =>
           memory.insert(content, {
-            scopeId: scopeId(ORG_SCOPE_PREFIX, orgId),
+            scopeId: orgScopeId,
             memoryType,
             importance: importance ?? 1,
             durability,
@@ -421,8 +402,8 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       }).pipe(
         Effect.withSpan('MemoryService.createOrganizationMemory'),
         Effect.tap(() =>
-          Effect.sync(() => {
-            const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+          Effect.gen(function* () {
+            const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
             aiLogger.debug`createOrganizationMemory - orgId: "${orgId}", scopeId: "${orgScopeId}", content preview: "${content.slice(0, 50)}"`
           }),
         ),
@@ -470,12 +451,12 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       metadata?: Record<string, unknown>
       importance?: number
     }) {
-      if (!isRoutableAgentName(agentName)) {
+      if (!isRoutableAgentName(agentConfig, agentName)) {
         return Effect.fail(new InvalidAgentNameError({ agentName }))
       }
 
-      const scoped = agentScopeId(orgId, agentName)
       return Effect.gen(function* () {
+        const scoped = yield* agentScopeId(orgId, agentName)
         const memory = yield* getOrgMemory(orgMemoryCache, orgId)
         return yield* memoryTryPromise('Failed to create agent memory.', () =>
           memory.insert(content, {
@@ -548,17 +529,19 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       if (params.facts.length === 0) return
 
       const orgMemory = yield* getOrgMemory(orgMemoryCache, params.orgId)
+      const orgScopeIdValue = yield* scopeId(ORG_SCOPE_PREFIX, params.orgId)
       const scopes: AddOptions[] = [
         {
-          scopeId: scopeId(ORG_SCOPE_PREFIX, params.orgId),
+          scopeId: orgScopeIdValue,
           memoryType: ORG_MEMORY_TYPE,
           metadata: { orgId: params.orgId, source: params.source, ...params.sourceMetadata },
         },
       ]
 
-      for (const scopedAgentName of resolveAgentScopeNames(undefined, params.agentNames ?? [])) {
+      for (const scopedAgentName of resolveAgentScopeNames(agentConfig, undefined, params.agentNames ?? [])) {
+        const agentScopedValue = yield* agentScopeId(params.orgId, scopedAgentName)
         scopes.push({
-          scopeId: agentScopeId(params.orgId, scopedAgentName),
+          scopeId: agentScopedValue,
           memoryType: ORG_MEMORY_TYPE,
           metadata: {
             orgId: params.orgId,
@@ -621,7 +604,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         return
       }
 
-      const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
       aiLogger.debug`addConversationMemories - orgId: "${orgId}", scopeId: "${orgScopeId}", sourceId: ${sourceId ?? 'none'}`
 
       const onboardingActive = onboardStatus !== undefined && onboardStatus !== 'completed'
@@ -638,8 +621,8 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         },
       ]
 
-      for (const scopedAgentName of resolveAgentScopeNames(agentName, agentNames)) {
-        const agentId = agentScopeId(orgId, scopedAgentName)
+      for (const scopedAgentName of resolveAgentScopeNames(agentConfig, agentName, agentNames)) {
+        const agentId = yield* agentScopeId(orgId, scopedAgentName)
         scopes.push({
           scopeId: agentId,
           memoryType: ORG_MEMORY_TYPE,
@@ -676,7 +659,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
 }
 
 export class MemoryServiceTag extends Context.Service<MemoryServiceTag, ReturnType<typeof createMemoryService>>()(
-  'MemoryService',
+  '@lota-sdk/core/MemoryService',
 ) {}
 
 export const MemoryServiceLive = Layer.effect(
@@ -686,7 +669,9 @@ export const MemoryServiceLive = Layer.effect(
     const runtimeConfig = yield* RuntimeConfigServiceTag
     const rerankService = yield* RerankServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    const orgMemoryCache = yield* makeOrgMemoryCache({ db, runtimeConfig, helperModelRuntime })
-    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache })
+    const background = yield* BackgroundWorkService
+    const agentConfig = yield* AgentConfigServiceTag
+    const orgMemoryCache = yield* makeOrgMemoryCache({ db, runtimeConfig, helperModelRuntime, background })
+    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache, agentConfig })
   }),
 )

package/src/services/memory/rerank.service.ts

@@ -3,6 +3,7 @@ import * as Schema from 'effect/Schema'
 import { z } from 'zod'
 
 import { OPENROUTER_FAST_RERANK_MODEL_ID } from '../../config/model-constants'
+import { makeEffectTryPromiseWithOperation } from '../../effect/helpers'
 import { RuntimeConfigServiceTag } from '../../effect/services'
 import { toValidationError } from '../../effect/zod'
 import { normalizeDirectOpenRouterModelId, resolveOpenRouterApiKey } from '../../openrouter/direct-provider'
@@ -20,16 +21,7 @@ function toRerankServiceError(operation: string, message: string, cause: unknown
   return new RerankServiceError({ operation, message, cause })
 }
 
-function tryRerankPromise<A>(
-  operation: string,
-  message: string,
-  thunk: () => PromiseLike<A> | A,
-): Effect.Effect<A, RerankServiceError> {
-  return Effect.tryPromise({
-    try: () => Promise.resolve(thunk()),
-    catch: (cause) => toRerankServiceError(operation, message, cause),
-  })
-}
+const tryRerankPromise = makeEffectTryPromiseWithOperation(toRerankServiceError)
 
 const RerankResponseSchema = z
   .object({
@@ -197,7 +189,7 @@ export function makeRerankService(config: ResolvedLotaRuntimeConfig) {
 }
 
 export class RerankServiceTag extends Context.Service<RerankServiceTag, ReturnType<typeof makeRerankService>>()(
-  'RerankService',
+  '@lota-sdk/core/RerankService',
 ) {}
 
 export const RerankServiceLive = Layer.effect(

package/src/services/monitoring-window.service.ts

@@ -97,7 +97,7 @@ export function makeMonitoringWindowService(planSchedulerService: ReturnType<typ
 export class MonitoringWindowServiceTag extends Context.Service<
   MonitoringWindowServiceTag,
   ReturnType<typeof makeMonitoringWindowService>
->()('MonitoringWindowService') {}
+>()('@lota-sdk/core/MonitoringWindowService') {}
 
 export const MonitoringWindowServiceLive = Layer.effect(
   MonitoringWindowServiceTag,

package/src/services/mutating-approval.service.ts

@@ -105,7 +105,7 @@ export function makeMutatingApprovalService(threadMessageService: ReturnType<typ
 export class MutatingApprovalServiceTag extends Context.Service<
   MutatingApprovalServiceTag,
   ReturnType<typeof makeMutatingApprovalService>
->()('MutatingApprovalService') {}
+>()('@lota-sdk/core/MutatingApprovalService') {}
 
 export const MutatingApprovalServiceLive = Layer.effect(
   MutatingApprovalServiceTag,

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

@@ -194,6 +194,6 @@ export const nodeWorkspaceService = makeNodeWorkspaceService()
 export class NodeWorkspaceServiceTag extends Context.Service<
   NodeWorkspaceServiceTag,
   ReturnType<typeof makeNodeWorkspaceService>
->()('NodeWorkspaceService') {}
+>()('@lota-sdk/core/NodeWorkspaceService') {}
 
-export const NodeWorkspaceServiceLive = Layer.succeed(NodeWorkspaceServiceTag, nodeWorkspaceService)
+export const NodeWorkspaceServiceLive = Layer.sync(NodeWorkspaceServiceTag, () => makeNodeWorkspaceService())

package/src/services/notification.service.ts

@@ -1,5 +1,5 @@
 import type { NotificationSeverity } from '@lota-sdk/shared'
-import { Context, Layer } from 'effect'
+import { Context, Effect, Layer } from 'effect'
 
 export interface NotificationPayload {
   organizationId: string
@@ -17,9 +17,12 @@ export interface NotificationService {
   notify(payload: NotificationPayload): Promise<void>
   remind(payload: NotificationPayload): Promise<void>
   escalate(payload: NotificationPayload): Promise<void>
+  notifyEffect?(payload: NotificationPayload): Effect.Effect<void, never>
+  remindEffect?(payload: NotificationPayload): Effect.Effect<void, never>
+  escalateEffect?(payload: NotificationPayload): Effect.Effect<void, never>
 }
 
-export function makeNotificationService(): NotificationService {
+export function makeNotificationService(): Required<NotificationService> {
   return {
     notify(_payload: NotificationPayload): Promise<void> {
       return Promise.resolve()
@@ -30,11 +33,20 @@ export function makeNotificationService(): NotificationService {
     escalate(_payload: NotificationPayload): Promise<void> {
       return Promise.resolve()
     },
+    notifyEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
+    remindEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
+    escalateEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
   }
 }
 
 export class NotificationServiceTag extends Context.Service<NotificationServiceTag, NotificationService>()(
-  'NotificationService',
+  '@lota-sdk/core/NotificationService',
 ) {}
 
-export const NotificationServiceLive = Layer.succeed(NotificationServiceTag, makeNotificationService())
+export const NotificationServiceLive = Layer.sync(NotificationServiceTag, () => makeNotificationService())

package/src/services/organization-member.service.ts

@@ -164,7 +164,7 @@ export function makeOrganizationMemberService(db: SurrealDBService) {
 export class OrganizationMemberServiceTag extends Context.Service<
   OrganizationMemberServiceTag,
   ReturnType<typeof makeOrganizationMemberService>
->()('OrganizationMemberService') {}
+>()('@lota-sdk/core/OrganizationMemberService') {}
 
 export const OrganizationMemberServiceLive = Layer.effect(
   OrganizationMemberServiceTag,

package/src/services/organization.service.ts

@@ -1,6 +1,6 @@
-import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
+import { sdkOrganizationRecordSchema, sdkOrganizationSchema } from '@lota-sdk/shared'
+import type { SdkOrganization, SdkOrganizationRecord } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
-import { z } from 'zod'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput, RecordIdRef } from '../db/record-id'
@@ -10,30 +10,7 @@ import { NotFoundError } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 
-const organizationRecordSchema = z.object({
-  id: recordIdSchema,
-  name: z.string(),
-  regularChatDigestLastThreadCursorCreatedAt: z.coerce.date().optional(),
-  regularChatDigestLastThreadCursorId: z.string().optional(),
-  skillExtractionLastCursorId: z.string().optional(),
-  skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-})
-
-const sdkOrganizationSchema = z.object({
-  id: recordIdStringSchema,
-  name: z.string(),
-  regularChatDigestLastThreadCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  regularChatDigestLastThreadCursorId: z.string().nullable().optional(),
-  skillExtractionLastCursorId: z.string().nullable().optional(),
-  skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  createdAt: z.iso.datetime(),
-  updatedAt: z.iso.datetime(),
-})
-
-export type SdkOrganizationRecord = z.infer<typeof organizationRecordSchema>
-export type SdkOrganization = z.infer<typeof sdkOrganizationSchema>
+export type { SdkOrganization, SdkOrganizationRecord }
 
 interface BackgroundCursor {
   createdAt: Date
@@ -49,18 +26,22 @@ function toOptionalCursorTimestamp(value: unknown): string | null {
   return toOptionalIsoDateTimeString(value) ?? null
 }
 
-function toPublic(record: SdkOrganizationRecord): SdkOrganization {
-  return sdkOrganizationSchema.parse({
-    id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
-    name: record.name,
-    regularChatDigestLastThreadCursorCreatedAt: toOptionalCursorTimestamp(
-      record.regularChatDigestLastThreadCursorCreatedAt,
-    ),
-    regularChatDigestLastThreadCursorId: record.regularChatDigestLastThreadCursorId ?? null,
-    skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
-    skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
-    createdAt: toIsoDateTimeString(record.createdAt),
-    updatedAt: toIsoDateTimeString(record.updatedAt),
+function toPublicEffect(record: SdkOrganizationRecord): Effect.Effect<SdkOrganization, OrganizationServiceError> {
+  return Effect.try({
+    try: () =>
+      sdkOrganizationSchema.parse({
+        id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
+        name: record.name,
+        regularChatDigestLastThreadCursorCreatedAt: toOptionalCursorTimestamp(
+          record.regularChatDigestLastThreadCursorCreatedAt,
+        ),
+        regularChatDigestLastThreadCursorId: record.regularChatDigestLastThreadCursorId ?? null,
+        skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
+        skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
+        createdAt: toIsoDateTimeString(record.createdAt),
+        updatedAt: toIsoDateTimeString(record.updatedAt),
+      }),
+    catch: (cause) => toOrganizationServiceError('toPublic', cause),
   })
 }
 
@@ -78,26 +59,26 @@ function toOrganizationServiceError(operation: string, cause: unknown): Organiza
 
 export function makeOrganizationService(db: SurrealDBService) {
   function createOrganization(params: { name: string }) {
-    return db.create(TABLES.ORGANIZATION, { name: params.name }, organizationRecordSchema).pipe(
+    return db.create(TABLES.ORGANIZATION, { name: params.name }, sdkOrganizationRecordSchema).pipe(
       Effect.mapError((cause) => toOrganizationServiceError('createOrganization', cause)),
-      Effect.map(toPublic),
+      Effect.flatMap(toPublicEffect),
     )
   }
 
   function upsertOrganization(params: { id: RecordIdInput; name: string }) {
     const organizationRef = ensureRecordId(params.id, TABLES.ORGANIZATION)
-    return db.upsert(TABLES.ORGANIZATION, organizationRef, { name: params.name }, organizationRecordSchema).pipe(
+    return db.upsert(TABLES.ORGANIZATION, organizationRef, { name: params.name }, sdkOrganizationRecordSchema).pipe(
       Effect.mapError((cause) => toOrganizationServiceError('upsertOrganization', cause)),
-      Effect.map(toPublic),
+      Effect.flatMap(toPublicEffect),
     )
   }
 
   function listOrganizations() {
     return db
-      .findMany(TABLES.ORGANIZATION, {}, organizationRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
+      .findMany(TABLES.ORGANIZATION, {}, sdkOrganizationRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
       .pipe(
         Effect.mapError((cause) => toOrganizationServiceError('listOrganizations', cause)),
-        Effect.map((records) => records.map(toPublic)),
+        Effect.flatMap((records) => Effect.forEach(records, toPublicEffect)),
       )
   }
 
@@ -106,7 +87,7 @@ export function makeOrganizationService(db: SurrealDBService) {
       .findOne(
         TABLES.ORGANIZATION,
         { id: ensureRecordId(organizationId, TABLES.ORGANIZATION) },
-        organizationRecordSchema,
+        sdkOrganizationRecordSchema,
       )
       .pipe(
         Effect.mapError((cause) => toOrganizationServiceError('getOrganizationRecord', cause)),
@@ -117,7 +98,9 @@ export function makeOrganizationService(db: SurrealDBService) {
   }
 
   function getOrganization(organizationId: RecordIdInput) {
-    return getOrganizationRecord(ensureRecordId(organizationId, TABLES.ORGANIZATION)).pipe(Effect.map(toPublic))
+    return getOrganizationRecord(ensureRecordId(organizationId, TABLES.ORGANIZATION)).pipe(
+      Effect.flatMap(toPublicEffect),
+    )
   }
 
   function updateOrganization(organizationId: RecordIdInput, params: { name: string }) {
@@ -126,14 +109,14 @@ export function makeOrganizationService(db: SurrealDBService) {
         TABLES.ORGANIZATION,
         ensureRecordId(organizationId, TABLES.ORGANIZATION),
         { name: params.name },
-        organizationRecordSchema,
+        sdkOrganizationRecordSchema,
       )
       .pipe(
         Effect.mapError((cause) => toOrganizationServiceError('updateOrganization', cause)),
         Effect.flatMap((updated) =>
           updated ? Effect.succeed(updated) : Effect.fail(organizationNotFoundError(organizationId)),
         ),
-        Effect.map(toPublic),
+        Effect.flatMap(toPublicEffect),
       )
   }
 
@@ -161,7 +144,7 @@ export function makeOrganizationService(db: SurrealDBService) {
           regularChatDigestLastThreadCursorCreatedAt: cursor.createdAt,
           regularChatDigestLastThreadCursorId: cursor.id,
         },
-        organizationRecordSchema,
+        sdkOrganizationRecordSchema,
       )
       .pipe(
         Effect.mapError((cause) => toOrganizationServiceError('updateRegularChatDigestCursor', cause)),
@@ -175,7 +158,7 @@ export function makeOrganizationService(db: SurrealDBService) {
         TABLES.ORGANIZATION,
         ensureRecordId(organizationId, TABLES.ORGANIZATION),
         { skillExtractionLastCursorCreatedAt: cursor.createdAt, skillExtractionLastCursorId: cursor.id },
-        organizationRecordSchema,
+        sdkOrganizationRecordSchema,
       )
       .pipe(
         Effect.mapError((cause) => toOrganizationServiceError('updateSkillExtractionCursor', cause)),
@@ -199,7 +182,7 @@ export function makeOrganizationService(db: SurrealDBService) {
 export class OrganizationServiceTag extends Context.Service<
   OrganizationServiceTag,
   ReturnType<typeof makeOrganizationService>
->()('OrganizationService') {}
+>()('@lota-sdk/core/OrganizationService') {}
 
 export const OrganizationServiceLive = Layer.effect(
   OrganizationServiceTag,